diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp
index 414da76ea7221eec8339ed91c6e9d2fd49fde806..8d830ea69a8041e2953e5e42db55ea390dbd179c 100644
--- a/src/maple_ipa/src/interleaved_manager.cpp
+++ b/src/maple_ipa/src/interleaved_manager.cpp
@@ -52,7 +52,7 @@ void InterleavedManager::AddPhases(std::vector<std::string> &phases, bool isModu
     MeFuncPhaseManager *fpm = GetMempool()->New<MeFuncPhaseManager>(GetMempool(), mirModule, mrm);
     fpm->RegisterFuncPhases();
     if (genMpl) {
-      fpm->SetGenMempool(true);
+      fpm->SetGenMeMpl(true);
     }
     if (timePhases) {
       fpm->SetTimePhases(true);
@@ -98,7 +98,7 @@ void InterleavedManager::Run() {
         fpm->Run(func, rangeNum, meInput);
         rangeNum++;
       }
-      if (fpm->GetGenMempool()) {
+      if (fpm->GetGenMeMpl()) {
         mirModule.Emit("comb.me.mpl");
       }
     } else {
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index cadf730d4fe77f07d96332467ef822e743094320..fbcd29305bfecfd57941bbb3847a2d68908f80c3 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -21,8 +21,7 @@ namespace maple {
 class VersionSt;
 class OriginalSt;
 class MeStmt;
-class MeVarPhiNode;
-class MeRegPhiNode;
+class MePhiNode;
 class IRMap;
 enum BBKind {
   kBBUnknown,  // uninitialized
@@ -367,15 +366,15 @@ class BB {
     return phiList;
   }
 
-  const MapleMap<OStIdx, MeVarPhiNode*> &GetMevarPhiList() const {
+  const MapleMap<OStIdx, MePhiNode*> &GetMevarPhiList() const {
     return mevarPhiList;
   }
 
-  MapleMap<OStIdx, MeVarPhiNode*> &GetMevarPhiList() {
+  MapleMap<OStIdx, MePhiNode*> &GetMevarPhiList() {
     return mevarPhiList;
   }
 
-  MapleMap<OStIdx, MeRegPhiNode*> &GetMeregphiList() {
+  MapleMap<OStIdx, MePhiNode*> &GetMeregphiList() {
     return meregPhiList;
   }
 
@@ -385,8 +384,8 @@ class BB {
   MapleVector<BB*> pred;  // predecessor list
   MapleVector<BB*> succ;  // successor list
   MapleMap<OriginalSt*, PhiNode> phiList;
-  MapleMap<OStIdx, MeVarPhiNode*> mevarPhiList;
-  MapleMap<OStIdx, MeRegPhiNode*> meregPhiList;
+  MapleMap<OStIdx, MePhiNode*> mevarPhiList;
+  MapleMap<OStIdx, MePhiNode*> meregPhiList;
   uint32 frequency;
   BBKind kind;
   uint32 attributes;
diff --git a/src/maple_me/include/irmap.h b/src/maple_me/include/irmap.h
index fae859984cddcc40da3c4da76e80907e430c9051..fdada40ffaa468cafc8285609b9f41d9f8f3861b 100644
--- a/src/maple_me/include/irmap.h
+++ b/src/maple_me/include/irmap.h
@@ -97,8 +97,7 @@ class IRMap : public AnalysisResult {
     return ssaTab->GetVerSt(veridx);
   }
 
-  MeRegPhiNode *CreateMeRegPhi(RegMeExpr*);
-  MeVarPhiNode *CreateMeVarPhi(VarMeExpr*);
+  MePhiNode *CreateMePhi(ScalarMeExpr*);
   bool Verify();  // iterate hash table and check with meexpr_table
   BB *GetFalseBrBB(CondGotoMeStmt*);
   std::string PhaseName() const {
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index d253296a04f5b0cca6c43e73be5346a93c00989f..ccf3cb90e1aa623e6057f19984224001a34e550f 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -182,29 +182,20 @@ class ChiMeNode;      // forward decl
 class MustDefMeNode;  // forward decl
 class IassignMeStmt;  // forward decl
 
-
-// represant dread
-class VarMeExpr : public MeExpr {
+// base class for VarMeExpr and RegMeExpr
+class ScalarMeExpr : public MeExpr {
  public:
- public:
-  VarMeExpr(MapleAllocator *alloc, int32 exprid, OStIdx oidx, size_t vidx)
-      : MeExpr(exprid, kMeOpVar),
+  ScalarMeExpr(int32 exprid, OStIdx oidx, size_t vidx, MeExprOp op)
+      : MeExpr(exprid, op),
         def{ .defStmt = nullptr },
-        ostIdx(oidx),
-        vstIdx(vidx),
-        fieldID(0),
-        inferredTyIdx(0),
-        inferredTypeCandidates(alloc->Adapter()),
         defBy(kDefByNo),
-        maybeNull(true) {
+        ostIdx(oidx),
+        vstIdx(vidx) {
   }
 
-  ~VarMeExpr() = default;
+  ~ScalarMeExpr() = default;
 
-  void Dump(IRMap*, int32 indent = 0) const;
   bool IsUseSameSymbol(MeExpr*) const;
-  BaseNode *EmitExpr(SSATab*);
-  bool IsValidVerIdx(SSATab *ssaTab);
   void SetDefByStmt(MeStmt *defStmt) {
     defBy = kDefByStmt;
     def.defStmt = defStmt;
@@ -214,17 +205,7 @@ class VarMeExpr : public MeExpr {
     return defBy == kDefByPhi;
   }
 
-  MeVarPhiNode *GetMeVarPhiDef() const {
-    return IsDefByPhi() ? def.defPhi : nullptr;
-  }
-
   BB *DefByBB();
-  bool IsVolatile(SSATab*);
-  // indicate if the variable is local variable but not a function formal variable
-  bool IsPureLocal(SSATab*, const MIRFunction*) const;
-  bool IsZeroVersion(SSATab*) const;
-  BB *GetDefByBBMeStmt(Dominance*, MeStmtPtr&);
-  VarMeExpr *ResolveVarMeValue();
 
   const OStIdx &GetOStIdx() const {
     return ostIdx;
@@ -238,26 +219,6 @@ class VarMeExpr : public MeExpr {
     vstIdx = vstIdxVal;
   }
 
-  FieldID GetFieldID() const {
-    return fieldID;
-  }
-
-  void SetFieldID(FieldID fieldId) {
-    fieldID = fieldId;
-  }
-
-  TyIdx &GetInferredTyIdx() {
-    return inferredTyIdx;
-  }
-
-  void SetInferredTyIdx(TyIdx inferredTyIdxVal) {
-    inferredTyIdx = inferredTyIdxVal;
-  }
-
-  MapleVector<TyIdx> &GetInferredTypeCandidates() {
-    return inferredTypeCandidates;
-  }
-
   MeDefBy GetDefBy() const {
     return defBy;
   }
@@ -266,14 +227,6 @@ class VarMeExpr : public MeExpr {
     defBy = defByVal;
   }
 
-  bool GetMaybeNull() {
-    return maybeNull;
-  }
-
-  void SetMaybeNull(bool maybeNullVal) {
-    maybeNull = maybeNullVal;
-  }
-
   MeStmt *GetDefStmt() const {
     return def.defStmt;
   }
@@ -282,11 +235,11 @@ class VarMeExpr : public MeExpr {
     def.defStmt = defStmt;
   }
 
-  MeVarPhiNode *GetDefPhi() {
+  MePhiNode *GetDefPhi() {
     return def.defPhi;
   }
 
-  void SetDefPhi(MeVarPhiNode *defPhi) {
+  void SetDefPhi(MePhiNode *defPhi) {
     def.defPhi = defPhi;
   }
 
@@ -306,61 +259,119 @@ class VarMeExpr : public MeExpr {
     def.defMustDef = defMustDef;
   }
 
- private:
+ protected:
   union {
     MeStmt *defStmt;  // definition stmt of this var
-    MeVarPhiNode *defPhi;
+    MePhiNode *defPhi;
     ChiMeNode *defChi;          // definition node by Chi
     MustDefMeNode *defMustDef;  // definition by callassigned
   } def;
-
+  MeDefBy defBy;
   OStIdx ostIdx;  // the index in MEOptimizer's OriginalStTable;
   size_t vstIdx;  // the index in MEOptimizer's VersionStTable, 0 if not in VersionStTable
+};
+
+// represant dread
+class VarMeExpr : public ScalarMeExpr {
+ public:
+  VarMeExpr(MapleAllocator *alloc, int32 exprid, OStIdx oidx, size_t vidx)
+      : ScalarMeExpr(exprid, oidx, vidx, kMeOpVar),
+        fieldID(0),
+        inferredTyIdx(0),
+        inferredTypeCandidates(alloc->Adapter()),
+        maybeNull(true) {
+  }
+
+  ~VarMeExpr() = default;
+
+  void Dump(IRMap*, int32 indent = 0) const;
+  BaseNode *EmitExpr(SSATab*);
+  bool IsValidVerIdx(SSATab *ssaTab);
+
+  MePhiNode *GetMeVarPhiDef() const {
+    return IsDefByPhi() ? def.defPhi : nullptr;
+  }
+
+  bool IsVolatile(SSATab*);
+  // indicate if the variable is local variable but not a function formal variable
+  bool IsPureLocal(SSATab*, const MIRFunction*) const;
+  bool IsZeroVersion(SSATab*) const;
+  BB *GetDefByBBMeStmt(Dominance*, MeStmtPtr&);
+  VarMeExpr *ResolveVarMeValue();
+
+  FieldID GetFieldID() const {
+    return fieldID;
+  }
+
+  void SetFieldID(FieldID fieldId) {
+    fieldID = fieldId;
+  }
+
+  TyIdx &GetInferredTyIdx() {
+    return inferredTyIdx;
+  }
+
+  void SetInferredTyIdx(TyIdx inferredTyIdxVal) {
+    inferredTyIdx = inferredTyIdxVal;
+  }
+
+  MapleVector<TyIdx> &GetInferredTypeCandidates() {
+    return inferredTypeCandidates;
+  }
+
+  bool GetMaybeNull() {
+    return maybeNull;
+  }
+
+  void SetMaybeNull(bool maybeNullVal) {
+    maybeNull = maybeNullVal;
+  }
+
+ private:
+  /* bool recursivePtr: 1;    // if pointer to recursive data structures */
   FieldID fieldID;
   TyIdx inferredTyIdx; /* Non zero if it has a known type (allocation type is seen). */
   MapleVector<TyIdx> inferredTypeCandidates;
-  MeDefBy defBy;
   bool maybeNull;  // false if definitely not null
 };
 
-class MeVarPhiNode {
+class MePhiNode {
  public:
-  explicit MeVarPhiNode(MapleAllocator *alloc)
-      : lhs(nullptr), opnds(2, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) {
-    opnds.pop_back();
-    opnds.pop_back();
+  explicit MePhiNode(MapleAllocator *alloc)
+      : opnds(2, nullptr, alloc->Adapter()) {
+    opnds.resize(0);
   }
 
-  MeVarPhiNode(VarMeExpr *var, MapleAllocator *alloc)
-      : lhs(var), opnds(2, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) {
-    var->SetDefPhi(this);
-    var->SetDefBy(kDefByPhi);
-    opnds.pop_back();
-    opnds.pop_back();
+  MePhiNode(ScalarMeExpr *var, MapleAllocator *alloc)
+      : lhs(var), opnds(2, nullptr, alloc->Adapter()) {
+    opnds.resize(0);
   }
 
-  ~MeVarPhiNode() = default;
+  ~MePhiNode() = default;
 
-  void UpdateLHS(VarMeExpr *var) {
+  void UpdateLHS(ScalarMeExpr *var) {
     lhs = var;
     var->SetDefBy(kDefByPhi);
     var->SetDefPhi(this);
   }
 
+  bool UseReg() {
+    return lhs->GetMeOp() == kMeOpReg;
+  }
   bool IsPureLocal(SSATab *ssatab, MIRFunction *mirfunc);
   void Dump(IRMap *irmap) const;
 
-  VarMeExpr *GetOpnd(size_t idx) const {
-    ASSERT(idx < opnds.size(), "out of range in MeVarPhiNode::GetOpnd");
+  ScalarMeExpr *GetOpnd(size_t idx) const {
+    ASSERT(idx < opnds.size(), "out of range in MePhiNode::GetOpnd");
     return opnds.at(idx);
   }
 
-  void SetOpnd(size_t idx, VarMeExpr *opnd) {
-    CHECK_FATAL(idx < opnds.size(), "out of range in MeVarPhiNode::SetOpnd");
+  void SetOpnd(size_t idx, ScalarMeExpr *opnd) {
+    CHECK_FATAL(idx < opnds.size(), "out of range in MePhiNode::SetOpnd");
     opnds[idx] = opnd;
   }
 
-  MapleVector<VarMeExpr*> &GetOpnds() {
+  MapleVector<ScalarMeExpr*> &GetOpnds() {
     return opnds;
   }
 
@@ -380,54 +391,36 @@ class MeVarPhiNode {
     return defBB;
   }
 
-  VarMeExpr *GetLHS() {
+  ScalarMeExpr *GetLHS() {
     return lhs;
   }
 
-  void SetLHS(VarMeExpr *value) {
+  void SetLHS(ScalarMeExpr *value) {
     lhs = value;
   }
 
  private:
-  VarMeExpr *lhs;
-  MapleVector<VarMeExpr*> opnds;
-  bool isLive;
-  BB *defBB;  // the bb that defines this phi
+  ScalarMeExpr *lhs = nullptr;
+  MapleVector<ScalarMeExpr*> opnds;
+  bool isLive = true;
+  BB *defBB = nullptr;  // the bb that defines this phi
 };
 
-class RegMeExpr : public MeExpr {
+class RegMeExpr : public ScalarMeExpr {
  public:
   RegMeExpr(MapleAllocator *alloc, int32 exprid, PregIdx preg, PUIdx pidx, OStIdx oidx, uint32 vidx)
-      : MeExpr(exprid, kMeOpReg),
+      : ScalarMeExpr(exprid, oidx, vidx, kMeOpReg),
         regIdx(preg),
-        defBy(kDefByNo),
         recursivePtr(false),
         puIdx(pidx),
-        ostIdx(oidx),
-        vstIdx(vidx),
-        phiUseSet(std::less<MeRegPhiNode*>(), alloc->Adapter()) {
-    def.defStmt = nullptr;
+        phiUseSet(std::less<MePhiNode*>(), alloc->Adapter()) {
   }
 
   ~RegMeExpr() = default;
 
   void Dump(IRMap*, int32 indent = 0) const;
   BaseNode *EmitExpr(SSATab*);
-  void SetDefByStmt(MeStmt *defStmt) {
-    defBy = kDefByStmt;
-    def.defStmt = defStmt;
-  }
 
-  bool IsDefByPhi() const {
-    return defBy == kDefByPhi;
-  }
-
-  MeRegPhiNode *GetMeRegPhiDef() {
-    return IsDefByPhi() ? def.defPhi : nullptr;
-  }
-
-  bool IsUseSameSymbol(MeExpr*) const;
-  BB *DefByBB();
   RegMeExpr *FindDefByStmt(std::set<RegMeExpr*> *visited);
 
   PregIdx16 GetRegIdx() const {
@@ -438,127 +431,20 @@ class RegMeExpr : public MeExpr {
     regIdx = regIdxVal;
   }
 
-  MeDefBy GetDefBy() const {
-    return defBy;
-  }
-
-  void SetDefBy(MeDefBy defByVal) {
-    defBy = defByVal;
-  }
-
   PUIdx GetPuIdx() const {
     return puIdx;
   }
 
-  OStIdx GetOstIdx() const {
-    return ostIdx;
-  }
-
-  MapleSet<MeRegPhiNode*> &GetPhiUseSet() {
+  MapleSet<MePhiNode*> &GetPhiUseSet() {
     return phiUseSet;
   }
 
-  MeStmt *GetDefStmt() const {
-    return def.defStmt;
-  }
-
-  MeRegPhiNode *GetDefPhi() {
-    return def.defPhi;
-  }
-
-  MustDefMeNode *GetDefMustDef() {
-    return def.defMustDef;
-  }
-
-  void SetDefStmt(MeStmt *defStmtVal) {
-    def.defStmt = defStmtVal;
-  }
-
-  void SetDefPhi(MeRegPhiNode *defPhiVal) {
-    def.defPhi = defPhiVal;
-  }
-
-  void SetDefMustDef(MustDefMeNode *defMustDefVal) {
-    def.defMustDef = defMustDefVal;
-  }
-
  private:
   PregIdx16 regIdx;
-  MeDefBy defBy;
   bool recursivePtr;  // if pointer to recursive data structures;
   // used only is_escaped is false
   PUIdx puIdx;
-  OStIdx ostIdx;                      // the index in MEOptimizer's OriginalStTable;
-  uint32 vstIdx;                      // the index in MEOptimizer's VersionStTable, 0 if not in VersionStTable
-  MapleSet<MeRegPhiNode*> phiUseSet;  // the use set of this reg node, used by preg renamer
-  union {
-    MeStmt *defStmt;
-    MeRegPhiNode *defPhi;
-    MustDefMeNode *defMustDef;  // definition by callassigned
-  } def;
-};
-
-class MeRegPhiNode {
- public:
-  explicit MeRegPhiNode(MapleAllocator *alloc)
-      : lhs(nullptr), opnds(2, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) {
-    opnds.pop_back();
-    opnds.pop_back();
-  }
-
-  ~MeRegPhiNode() = default;
-
-  void UpdateLHS(RegMeExpr *reg) {
-    lhs = reg;
-    reg->SetDefBy(kDefByPhi);
-    reg->SetDefPhi(this);
-  }
-
-  void Dump(IRMap *irMap) const;
-
-  RegMeExpr *GetLHS() {
-    return lhs;
-  }
-
-  void SetLHS(RegMeExpr *lhsVal) {
-    lhs = lhsVal;
-  }
-
-  MapleVector<RegMeExpr*> &GetOpnds() {
-    return opnds;
-  }
-
-  RegMeExpr *GetOpnd(size_t idx) {
-    CHECK_FATAL(idx < opnds.size(), "out of range in MeRegPhiNode::GetOpnd");
-    return opnds[idx];
-  }
-
-  void SetOpnd(size_t idx, RegMeExpr *opnd) {
-    CHECK_FATAL(idx < opnds.size(), "out of range in MeRegPhiNode::SetOpnd");
-    opnds[idx] = opnd;
-  }
-
-  void SetIsLive(bool isLiveVal) {
-    isLive = isLiveVal;
-  }
-
-  bool GetIsLive() {
-    return isLive;
-  }
-
-  void SetDefBB(BB *defBBVal) {
-    defBB = defBBVal;
-  }
-
-  BB *GetDefBB() {
-    return defBB;
-  }
-
- private:
-  RegMeExpr *lhs;
-  MapleVector<RegMeExpr*> opnds;
-  bool isLive;
-  BB *defBB;  // the bb that defines this phi
+  MapleSet<MePhiNode*> phiUseSet;  // the use set of this reg node, used by preg renamer
 };
 
 class ConstMeExpr : public MeExpr {
@@ -705,11 +591,11 @@ class AddrofMeExpr : public MeExpr {
   bool IsUseSameSymbol(MeExpr*) const;
   BaseNode *EmitExpr(SSATab*);
 
-  OStIdx &GetOstIdx() {
+  OStIdx &GetOStIdx() {
     return ostIdx;
   }
 
-  OStIdx GetOstIdx() const {
+  OStIdx GetOStIdx() const {
     return ostIdx;
   }
 
diff --git a/src/maple_me/include/me_phase_manager.h b/src/maple_me/include/me_phase_manager.h
index 5a02b4c2de9734c975e30ac1006dd16a69a344f9..f2e74bb13e2be6914836c8050f4cc9920b71337c 100644
--- a/src/maple_me/include/me_phase_manager.h
+++ b/src/maple_me/include/me_phase_manager.h
@@ -34,7 +34,7 @@ class MeFuncPhaseManager : public PhaseManager {
         mirModule(mod),
         modResMgr(mrm),
         mePhaseType(kMePhaseInvalid),
-        genMempool(false),
+        genMeMpl(false),
         timePhases(false) {}
 
   ~MeFuncPhaseManager() {
@@ -66,12 +66,12 @@ class MeFuncPhaseManager : public PhaseManager {
 
   bool FuncFilter(const std::string &filter, const std::string &name);
 
-  bool GetGenMempool() {
-    return genMempool;
+  bool GetGenMeMpl() {
+    return genMeMpl;
   }
 
-  void SetGenMempool(bool pl) {
-    genMempool = pl;
+  void SetGenMeMpl(bool pl) {
+    genMeMpl = pl;
   }
 
   void SetTimePhases(bool phs) {
@@ -84,7 +84,7 @@ class MeFuncPhaseManager : public PhaseManager {
   MIRModule &mirModule;
   ModuleResultMgr *modResMgr;
   MePhaseType mePhaseType;
-  bool genMempool;
+  bool genMeMpl;
   bool timePhases;
 };
 
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index a8d3597aaf9ae3121e0d8549c343f7d079d5b9f7..bb4d54ec962e54753ad95971f361751f11407abf 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -54,7 +54,7 @@ void IRMap::BuildPhiMeNode(BB *bb) {
     OriginalSt *origst = phi.first;
     VersionSt *verSt = phi.second.GetResult();
     if (origst->IsPregOst()) {
-      MeRegPhiNode *phimenode = NewInPool<MeRegPhiNode>();
+      MePhiNode *phimenode = NewInPool<MePhiNode>();
       RegMeExpr *medef = GetOrCreateRegFromVerSt(verSt);
       phimenode->UpdateLHS(medef);
       phimenode->SetDefBB(bb);
@@ -62,9 +62,9 @@ void IRMap::BuildPhiMeNode(BB *bb) {
       for (VersionSt *opnd : phi.second.GetPhiOpns()) {
         phimenode->GetOpnds().push_back(GetOrCreateRegFromVerSt(opnd));
       }
-      bb->GetMeregphiList().insert(std::make_pair(medef->GetOstIdx(), phimenode));
+      bb->GetMeregphiList().insert(std::make_pair(medef->GetOStIdx(), phimenode));
     } else {
-      MeVarPhiNode *phimenode = NewInPool<MeVarPhiNode>();
+      MePhiNode *phimenode = NewInPool<MePhiNode>();
       VarMeExpr *medef = GetOrCreateVarFromVerSt(verSt);
       phimenode->UpdateLHS(medef);
       phimenode->SetDefBB(bb);
@@ -140,7 +140,7 @@ RegMeExpr *IRMap::CreateRegMeExprVersion(const OriginalSt *pregOrgst) {
 
 RegMeExpr *IRMap::CreateRegMeExprVersion(const RegMeExpr *origExpr) {
   RegMeExpr *regreadexpr =
-      NewInPool<RegMeExpr>(exprID++, origExpr->GetRegIdx(), origExpr->GetPuIdx(), origExpr->GetOstIdx(), 0);
+      NewInPool<RegMeExpr>(exprID++, origExpr->GetRegIdx(), origExpr->GetPuIdx(), origExpr->GetOStIdx(), 0);
   regreadexpr->InitBase(origExpr->GetOp(), origExpr->GetPrimType(), origExpr->GetNumOpnds());
   regMeExprTable.push_back(regreadexpr);
   return regreadexpr;
@@ -1005,12 +1005,12 @@ MeExpr *IRMap::HashMeExpr(MeExpr *meExpr) {
           itexpr = static_cast<AddrofMeExpr*>(itexpr->GetNext());
           continue;
         }
-        if (itexpr->GetOstIdx() == addrofmeexpr->GetOstIdx() && itexpr->GetFieldID() == addrofmeexpr->GetFieldID()) {
+        if (itexpr->GetOStIdx() == addrofmeexpr->GetOStIdx() && itexpr->GetFieldID() == addrofmeexpr->GetFieldID()) {
           return itexpr;
         }
         itexpr = static_cast<AddrofMeExpr*>(itexpr->GetNext());
       }
-      AddrofMeExpr *newaddrofmeexpr = New<AddrofMeExpr>(exprID++, addrofmeexpr->GetOstIdx());
+      AddrofMeExpr *newaddrofmeexpr = New<AddrofMeExpr>(exprID++, addrofmeexpr->GetOStIdx());
       newaddrofmeexpr->InitBase(meExpr->GetOp(), meExpr->GetPrimType(), meExpr->GetNumOpnds());
       newaddrofmeexpr->SetFieldID(addrofmeexpr->GetFieldID());
       PutToBucket(hidx, newaddrofmeexpr);
@@ -1234,16 +1234,10 @@ bool IRMap::ReplaceMeExprStmt(MeStmt *meStmt, MeExpr *meExpr, MeExpr *repexpr) {
   return isReplaced;
 }
 
-MeRegPhiNode *IRMap::CreateMeRegPhi(RegMeExpr *mevar) {
-  MeRegPhiNode *phimereg = NewInPool<MeRegPhiNode>();
-  phimereg->UpdateLHS(mevar);
-  return phimereg;
-}
-
-MeVarPhiNode *IRMap::CreateMeVarPhi(VarMeExpr *mevar) {
-  MeVarPhiNode *phimevar = NewInPool<MeVarPhiNode>();
-  phimevar->UpdateLHS(mevar);
-  return phimevar;
+MePhiNode *IRMap::CreateMePhi(ScalarMeExpr *meExpr) {
+  MePhiNode *phime = NewInPool<MePhiNode>();
+  phime->UpdateLHS(meExpr);
+  return phime;
 }
 
 DassignMeStmt *IRMap::CreateDassignMeStmt(MeExpr *lhs, MeExpr *rhs, BB *curbb) {
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index e5f8b7ead6143d7e581530ce980b9b2c2c1ef58b..c9292be08051f4cef7358e90c99c36545f2ce085 100644
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -484,8 +484,8 @@ void MirCFG::ConvertPhis2IdentityAssigns(BB *meBB) {
     OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(varPhiIt->first);
     if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
       DassignMeStmt *dassign = func->GetIRMap()->NewInPool<DassignMeStmt>();
-      MeVarPhiNode *varPhi = varPhiIt->second;
-      dassign->SetLHS(varPhi->GetLHS());
+      MePhiNode *varPhi = varPhiIt->second;
+      dassign->SetLHS(static_cast<VarMeExpr*>(varPhi->GetLHS()));
       dassign->SetRHS(varPhi->GetOpnd(0));
       dassign->SetBB(varPhi->GetDefBB());
       dassign->SetIsLive(varPhi->GetIsLive());
@@ -504,8 +504,8 @@ void MirCFG::ConvertPhis2IdentityAssigns(BB *meBB) {
     OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(regPhiIt->first);
     if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
       RegassignMeStmt *regass = func->GetIRMap()->New<RegassignMeStmt>();
-      MeRegPhiNode *regPhi = regPhiIt->second;
-      regass->SetLHS(regPhi->GetLHS());
+      MePhiNode *regPhi = regPhiIt->second;
+      regass->SetLHS(static_cast<RegMeExpr*>(regPhi->GetLHS()));
       regass->SetRHS(regPhi->GetOpnd(0));
       regass->SetBB(regPhi->GetDefBB());
       regass->SetIsLive(regPhi->GetIsLive());
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index 5598336cec26c0b5a8cf970186dc8d92c39d871c..b8e97595d2eb91dd55995ef1e055668e1a777ef3 100644
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -185,9 +185,10 @@ RegMeExpr *RegMeExpr::FindDefByStmt(std::set<RegMeExpr*> *visited) {
     return this;
   }
   if (GetDefBy() == kDefByPhi) {
-    MeRegPhiNode *phireg = GetDefPhi();
-    for (RegMeExpr *phiOpnd : phireg->GetOpnds()) {
-      RegMeExpr *res = phiOpnd->FindDefByStmt(visited);
+    MePhiNode *phireg = GetDefPhi();
+    for (ScalarMeExpr *phiOpnd : phireg->GetOpnds()) {
+      RegMeExpr *regOpnd = static_cast<RegMeExpr*>(phiOpnd);
+      RegMeExpr *res = regOpnd->FindDefByStmt(visited);
       if (res != nullptr) {
         return res;
       }
@@ -371,7 +372,7 @@ BB *VarMeExpr::GetDefByBBMeStmt(Dominance *dominance, MeStmtPtr &defMeStmt) {
       break;
     }
     case kDefByPhi: {
-      MeVarPhiNode *defphi = def.defPhi;
+      MePhiNode *defphi = def.defPhi;
       bbx = defphi->GetDefBB();
       break;
     }
@@ -381,14 +382,6 @@ BB *VarMeExpr::GetDefByBBMeStmt(Dominance *dominance, MeStmtPtr &defMeStmt) {
   return bbx;
 }
 
-bool VarMeExpr::IsUseSameSymbol(MeExpr *meexpr) const {
-  VarMeExpr *varMeExpr = dynamic_cast<VarMeExpr*>(meexpr);
-  if (varMeExpr == nullptr) {
-    return false;
-  }
-  return ostIdx == varMeExpr->ostIdx;
-}
-
 bool VarMeExpr::IsPureLocal(SSATab *ssatab, const MIRFunction *mirfunc) const {
   MIRSymbol *st = ssatab->GetMIRSymbolFromID(ostIdx);
   return st->IsLocal() && !mirfunc->IsAFormal(st);
@@ -400,34 +393,6 @@ bool VarMeExpr::IsZeroVersion(SSATab *ssatab) const {
   return ost->GetZeroVersionIndex() == vstIdx;
 }
 
-bool RegMeExpr::IsUseSameSymbol(MeExpr *meExpr) const {
-  RegMeExpr *regMeExpr = dynamic_cast<RegMeExpr*>(meExpr);
-  if (regMeExpr == nullptr) {
-    return false;
-  }
-  return ostIdx == regMeExpr->ostIdx;
-}
-
-BB *RegMeExpr::DefByBB() {
-  switch (defBy) {
-    case kDefByNo:
-      return nullptr;
-    case kDefByStmt:
-      ASSERT(def.defStmt, "VarMeExpr::DefByBB: defStmt cannot be nullptr");
-      return def.defStmt->GetBB();
-    case kDefByPhi:
-      ASSERT(def.defPhi, "VarMeExpr::DefByBB: defPhi cannot be nullptr");
-      return def.defPhi->GetDefBB();
-    case kDefByMustDef:
-      ASSERT(def.defMustDef, "VarMeExpr::DefByBB: defMustDef cannot be nullptr");
-      ASSERT(def.defMustDef->GetBase(), "VarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
-      return def.defMustDef->GetBase()->GetBB();
-    default:
-      ASSERT(false, "reg define unknown");
-      return nullptr;
-  }
-}
-
 bool AddrofMeExpr::IsUseSameSymbol(MeExpr *meexpr) const {
   AddrofMeExpr *varMeExpr = dynamic_cast<AddrofMeExpr*>(meexpr);
   if (!varMeExpr) {
@@ -492,9 +457,22 @@ int64 ConstMeExpr::GetIntValue() const {
   return mirConst->GetValue();
 }
 
-void MeVarPhiNode::Dump(IRMap *irMap) const {
-  LogInfo::MapleLogger() << "VAR:";
-  irMap->GetSSATab()->GetOriginalStFromID(lhs->GetOStIdx())->Dump();
+void MePhiNode::Dump(IRMap *irMap) const {
+  OriginalSt *ost = irMap->GetSSATab()->GetOriginalStFromID(lhs->GetOStIdx());
+  bool isSym = ost->IsSymbolOst();
+  if (isSym) {
+    LogInfo::MapleLogger() << "VAR:";
+    ost->Dump();
+  } else {
+    PregIdx regId = static_cast<RegMeExpr*>(lhs)->GetRegIdx();
+    LogInfo::MapleLogger() << "REGVAR: " << regId;
+    LogInfo::MapleLogger() << "(%"
+                           << irMap->GetMIRModule()->CurFunction()
+                                                   ->GetPregTab()
+                                                   ->PregFromPregIdx(regId)
+                                                   ->GetPregNo()
+                           << ")";
+  }
   LogInfo::MapleLogger() << " mx" << lhs->GetExprID();
   LogInfo::MapleLogger() << " = MEPHI{";
   for (size_t i = 0; i < opnds.size(); i++) {
@@ -504,31 +482,12 @@ void MeVarPhiNode::Dump(IRMap *irMap) const {
     }
   }
   LogInfo::MapleLogger() << "}";
-  if (!isLive) {
+  if (isSym && !isLive) {
     LogInfo::MapleLogger() << " dead";
   }
   LogInfo::MapleLogger() << std::endl;
 }
 
-void MeRegPhiNode::Dump(IRMap *irMap) const {
-  LogInfo::MapleLogger() << "REGVAR: " << lhs->GetRegIdx();
-  LogInfo::MapleLogger() << "(%"
-                         << irMap->GetMIRModule()->CurFunction()
-                                                 ->GetPregTab()
-                                                 ->PregFromPregIdx(static_cast<PregIdx>(lhs->GetRegIdx()))
-                                                 ->GetPregNo()
-                         << ")";
-  LogInfo::MapleLogger() << " mx" << lhs->GetExprID();
-  LogInfo::MapleLogger() << " = MEPHI{";
-  for (size_t i = 0; i < opnds.size(); i++) {
-    LogInfo::MapleLogger() << "mx" << opnds[i]->GetExprID();
-    if (i != opnds.size() - 1) {
-      LogInfo::MapleLogger() << ",";
-    }
-  }
-  LogInfo::MapleLogger() << "}" << std::endl;
-}
-
 void VarMeExpr::Dump(IRMap *irMap, int32 indent) const {
   LogInfo::MapleLogger() << "VAR ";
   irMap->GetSSATab()->GetOriginalStFromID(ostIdx)->Dump();
@@ -1082,28 +1041,36 @@ void AssertMeStmt::Dump(IRMap *irMap) const {
   LogInfo::MapleLogger() << std::endl;
 }
 
-BB *VarMeExpr::DefByBB() {
+bool ScalarMeExpr::IsUseSameSymbol(MeExpr *meexpr) const {
+  ScalarMeExpr *scalar = dynamic_cast<ScalarMeExpr*>(meexpr);
+  if (scalar == nullptr) {
+    return false;
+  }
+  return ostIdx == scalar->ostIdx;
+}
+
+BB *ScalarMeExpr::DefByBB() {
   switch (defBy) {
     case kDefByNo:
       return nullptr;
     case kDefByStmt:
-      ASSERT(def.defStmt, "VarMeExpr::DefByBB: defStmt cannot be nullptr");
+      ASSERT(def.defStmt, "ScalarMeExpr::DefByBB: defStmt cannot be nullptr");
       return def.defStmt->GetBB();
     case kDefByPhi:
-      ASSERT(def.defPhi, "VarMeExpr::DefByBB: defPhi cannot be nullptr");
+      ASSERT(def.defPhi, "ScalarMeExpr::DefByBB: defPhi cannot be nullptr");
       return def.defPhi->GetDefBB();
     case kDefByChi: {
-      ASSERT(def.defChi, "VarMeExpr::DefByBB: defChi cannot be nullptr");
-      ASSERT(def.defChi->GetBase(), "VarMeExpr::DefByBB: defChi->base cannot be nullptr");
+      ASSERT(def.defChi, "ScalarMeExpr::DefByBB: defChi cannot be nullptr");
+      ASSERT(def.defChi->GetBase(), "ScalarMeExpr::DefByBB: defChi->base cannot be nullptr");
       return def.defChi->GetBase()->GetBB();
     }
     case kDefByMustDef: {
-      ASSERT(def.defMustDef, "VarMeExpr::DefByBB: defMustDef cannot be nullptr");
-      ASSERT(def.defMustDef->GetBase(), "VarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
+      ASSERT(def.defMustDef, "ScalarMeExpr::DefByBB: defMustDef cannot be nullptr");
+      ASSERT(def.defMustDef->GetBase(), "ScalarMeExpr::DefByBB: defMustDef->base cannot be nullptr");
       return def.defMustDef->GetBase()->GetBB();
     }
     default:
-      ASSERT(false, "var define unknown");
+      ASSERT(false, "scalar define unknown");
       return nullptr;
   }
 }
@@ -1182,10 +1149,10 @@ MapleMap<OStIdx, ChiMeNode*> *GenericGetChiListFromVarMeExprInner(VarMeExpr *exp
   }
   visited.insert(expr);
   if (expr->GetDefBy() == kDefByPhi) {
-    MeVarPhiNode *phime = expr->GetDefPhi();
-    MapleVector<VarMeExpr*> &phiopnds = phime->GetOpnds();
+    MePhiNode *phime = expr->GetDefPhi();
+    MapleVector<ScalarMeExpr*> &phiopnds = phime->GetOpnds();
     for (auto it = phiopnds.begin(); it != phiopnds.end(); it++) {
-      VarMeExpr *meexpr = *it;
+      VarMeExpr *meexpr = static_cast<VarMeExpr*>(*it);
       MapleMap<OStIdx, ChiMeNode*> *chiList = GenericGetChiListFromVarMeExprInner(meexpr, visited);
       if (chiList != nullptr) {
         return chiList;
diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp
index 3c1d46c74741201788fcf3f66c55a3e5d7c0e7a4..2f07d2313ced3f274136926ae055d4428930863b 100644
--- a/src/maple_me/src/me_ssa_update.cpp
+++ b/src/maple_me/src/me_ssa_update.cpp
@@ -50,12 +50,12 @@ void SSAUpdate::InsertPhis() {
       // insert a phi node
       BB *bb = func->GetBBFromID(bbid);
       ASSERT(bb != nullptr, "null ptr check");
-      MapleMap<OStIdx, MeVarPhiNode*>::iterator phiListIt = bb->GetMevarPhiList().find(it->first);
+      MapleMap<OStIdx, MePhiNode*>::iterator phiListIt = bb->GetMevarPhiList().find(it->first);
       if (phiListIt != bb->GetMevarPhiList().end()) {
         phiListIt->second->SetIsLive(true);
         continue;
       }
-      MeVarPhiNode *phiMeNode = irMap->NewInPool<MeVarPhiNode>();
+      MePhiNode *phiMeNode = irMap->NewInPool<MePhiNode>();
       phiMeNode->SetDefBB(bb);
       phiMeNode->GetOpnds().resize(bb->GetPred().size());
       bb->GetMevarPhiList().insert(std::make_pair(it->first, phiMeNode));
@@ -68,10 +68,10 @@ void SSAUpdate::InsertPhis() {
 void SSAUpdate::RenamePhi(BB *bb) {
   MapleMap<OStIdx, MapleStack<VarMeExpr*>*>::iterator it1 = renameStacks.begin();
   for (; it1 != renameStacks.end(); it1++) {
-    MapleMap<OStIdx, MeVarPhiNode*>::iterator it2 = bb->GetMevarPhiList().find(it1->first);
+    MapleMap<OStIdx, MePhiNode*>::iterator it2 = bb->GetMevarPhiList().find(it1->first);
     if (it2 != bb->GetMevarPhiList().end()) {
       // if there is existing phi result node
-      MeVarPhiNode *phi = it2->second;
+      MePhiNode *phi = it2->second;
       phi->SetIsLive(true);  // always make it live, for correctness
       if (phi->GetLHS() == nullptr) {
         // create a new VarMeExpr defined by this phi
@@ -86,7 +86,7 @@ void SSAUpdate::RenamePhi(BB *bb) {
         phi->UpdateLHS(newvar);
         it1->second->push(newvar);  // push the stack
       } else {
-        it1->second->push(phi->GetLHS());  // push the stack
+        it1->second->push(static_cast<VarMeExpr*>(phi->GetLHS()));  // push the stack
       }
     }
   }
@@ -221,11 +221,11 @@ void SSAUpdate::RenamePhiOpndsInSucc(BB *bb) {
     CHECK_FATAL(index < succ->GetPred().size(), "RenamePhiOpndsinSucc: cannot find corresponding pred");
     MapleMap<OStIdx, MapleStack<VarMeExpr*>*>::iterator it1 = renameStacks.begin();
     for (; it1 != renameStacks.end(); it1++) {
-      MapleMap<OStIdx, MeVarPhiNode*>::iterator it2 = succ->GetMevarPhiList().find(it1->first);
+      MapleMap<OStIdx, MePhiNode*>::iterator it2 = succ->GetMevarPhiList().find(it1->first);
       if (it2 == succ->GetMevarPhiList().end()) {
         continue;
       }
-      MeVarPhiNode *phi = it2->second;
+      MePhiNode *phi = it2->second;
       MapleStack<VarMeExpr*> *renameStack = it1->second;
       VarMeExpr *curvar = renameStack->top();
       if (phi->GetOpnd(index) != curvar) {