Given dessa CC = {a, b, c}, if "a = extElt V0, 0" and

"b = extElt V1, 0", where V0 != V1, only enable aliasing
for one of two extElt instructions.

To be able to alias both, it needs to coalesce
V0 and V1. The current algo does not handle coalescing
v0 and V1 as they are different values and no longer
be treated as alias. A different algo is needed for
handling this case

Change-Id: I014ea28a06b9e2e1bf2efc51452d553cd70671c9

Author: jgu222

IGC/Compiler/CISACodeGen/VariableReuseAnalysis.cpp

@@ -989,8 +989,7 @@ void VariableReuseAnalysis::visitExtractElementInst(ExtractElementInst& I)
     //  be merged into part of other value.)
     if (m_HasBecomeNoopInsts.count(EEI) ||
         m_DeSSA->isNoopAliaser(EEI) ||
-        isOrCoalescedWithArg(EEI) ||
-        isOrCoalescedWithArg(vecVal) ||
+        !isSingleVecAliasee(vecVal) ||
         (m_WIA && m_WIA->whichDepend(EEI) != m_WIA->whichDepend(vecVal))) {
         return;
     }
@@ -1002,7 +1001,7 @@ void VariableReuseAnalysis::visitExtractElementInst(ExtractElementInst& I)
     // skip it for now (implementation choice).
     // Note that payload-coalescing does not use node value yet.
     if (hasBeenPayloadCoalesced(EEI) ||
-        isVecAliaser(EEI_nv)) {
+        !isSingleVecAliaser(EEI_nv)) {
         return;
     }
 
@@ -1450,8 +1449,19 @@ void VariableReuseAnalysis::addVecAlias(
         aliaserSV->Aliasers.clear();
     }
 
-    // Finally, add aliaserSV into root's Aliaser vector
+    // Finally, add aliaserSV into root's Aliaser vector and
+    // update aliaser to its root map if aliaser's not isolated.
     rootSV->Aliasers.push_back(aliaserSV);
+    // aliaser
+    Value* rv0 = m_DeSSA ? m_DeSSA->getRootValue(Aliaser) : nullptr;
+    if (rv0) {
+        m_root2AliasMap[rv0] = Aliaser;
+    }
+    // aliasee
+    Value* rv1 = m_DeSSA ? m_DeSSA->getRootValue(Aliasee) : nullptr;
+    if (rv1) {
+        m_root2AliasMap[rv1] = Aliasee;
+    }
 }
 
 SSubVecDesc* VariableReuseAnalysis::getOrCreateSubVecDesc(Value* V)
@@ -1463,15 +1473,43 @@ SSubVecDesc* VariableReuseAnalysis::getOrCreateSubVecDesc(Value* V)
     return m_aliasMap[V];
 }
 
-bool VariableReuseAnalysis::isVecAliaser(llvm::Value* V) const
+bool VariableReuseAnalysis::isVecAliased(Value* V) const
+{
+    if (m_aliasMap.count(V) > 0) {
+        return true;
+    }
+
+    Value* rv = m_DeSSA ? m_DeSSA->getRootValue(V) : nullptr;
+    return (rv && m_root2AliasMap.count(rv) > 0);
+}
+
+bool VariableReuseAnalysis::isSingleVecAliaser(llvm::Value* V) const
 {
     auto II = m_aliasMap.find(V);
-    if (II == m_aliasMap.end())
-        return false;
-    SSubVecDesc* SV = II->second;
-    return SV->Aliaser != SV->BaseVector;
+    if (II != m_aliasMap.end()) {
+        SSubVecDesc* SV = II->second;
+        if (SV->Aliaser != SV->BaseVector)
+            return false;
+    }
+
+    return isSingleVecAliasee(V);
+}
+
+bool VariableReuseAnalysis::isSingleVecAliasee(llvm::Value* V) const
+{
+    // Check if any value of its dessa CC has been aliased already.
+    Value* rv = m_DeSSA ? m_DeSSA->getRootValue(V) : nullptr;
+    if (rv) {
+        auto II = m_root2AliasMap.find(rv);
+        if (II != m_root2AliasMap.end()) {
+            Value* aV = II->second;
+            return  V == aV;
+        }
+    }
+    return true;
 }
 
+
 // A chain of IEIs is used to define a vector. If all elements of this vector
 // are inserted via this chain IEI that has a constant index, populate AllIEIs.
 //   input:  FirstIEI (first IEI, usually with index = 0)

IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp

@@ -193,6 +193,7 @@ class VariableReuseAnalysis : public llvm::FunctionPass,
   typedef llvm::SmallVector<SVecInsEltInfo, 32> VecInsEltInfoTy;
   typedef llvm::DenseMap<llvm::Value*, SSubVecDesc*> AliasMapTy;
   typedef llvm::SmallVector<llvm::Value*, 32> ValueVectorTy;
+  typedef llvm::DenseMap<llvm::Value*, llvm::Value*> Val2ValMapTy;
 
   // following to be deleted
   typedef llvm::DenseMap<llvm::Value*, SSubVecDesc> ValueAliasMapTy;
@@ -283,8 +284,9 @@ class VariableReuseAnalysis : public llvm::FunctionPass,
   int getCongruentClassSize(llvm::Value* V);
   bool isSameSizeValue(llvm::Value* V0, llvm::Value* V1);
 
-  bool isVecAliased(llvm::Value* V) const { return m_aliasMap.count(V) > 0; }
-  bool isVecAliaser(llvm::Value* V) const;
+  bool isVecAliased(llvm::Value* V) const;
+  bool isSingleVecAliaser(llvm::Value* V) const;
+  bool isSingleVecAliasee(llvm::Value* V) const;
 
   // getRootValue():
   //   return dessa root value; if dessa root value
@@ -400,6 +402,7 @@ class VariableReuseAnalysis : public llvm::FunctionPass,
     m_ValueAliasMap.clear();
     m_AliasRootMap.clear();
     m_aliasMap.clear();
+    m_root2AliasMap.clear();
     m_HasBecomeNoopInsts.clear();
   }
 
@@ -533,6 +536,13 @@ class VariableReuseAnalysis : public llvm::FunctionPass,
   //SmallPtrSet<llvm::Instruction*, 16> m_Visited;
   ValueAliasMapTy m_ExtractFrom;
   ValueAliasMapTy m_insertTo;
+
+  // Temporaries under VATemp
+  // if a value V is in a dessa CC and V is aliased,
+  // add <V's root, V> into the map.  This is a quick
+  // way to check if any of values in a dessa CC has
+  // been aliased (either aliaser or aliasee)
+  Val2ValMapTy m_root2AliasMap;
 };
 
 llvm::FunctionPass *createVariableReuseAnalysisPass();