[SVE] Allow scalable vector splats to be gep indices

[ctetreau]

Summary

getSplatValue(): Make getSplatValue work for scalable vector splats
of the form returned by ConstantVector::getSplat().

getUniqueInteger(): The value returned by getSplatValue() is the same
value that is returned by getAggregateElement(0). No need to have the
second call, and this allows this function to work for scalable splats.

getIndexType() and getCastOpcode(): These can call getElementCount() and
VectorType::get(Type *, VectorType *)

Added test for gep using scalable vector splat

[efriedma]

I'll assume you didn't mean to post this for review

[ctetreau]

fixed issues with previous implementation, used new functionality to enable scalable vector indices to GEP, and added test

[ctetreau]

rebase

[efriedma]

Posted https://reviews.llvm.org/D82061 to try to make the GEP-related bits more sane.

llvm/lib/IR/Constants.cpp

1567

Constant::getUniqueInteger() is a terrible API. I'd prefer to fix the callers so it doesn't need to handle scalable vectors.

[ctetreau]

Split getSplatVal stuff into its own commit, rebase

[ctetreau]

@efriedma I think so long as the language reference states that gep into a struct accepts any vector splat index, then this patch should be accepted. (assuming it has no technical issues) It's a trivial change, that is probably an improvement regardless of if we consider the use case to be valid.

[ctetreau]

llvm/lib/IR/Constants.cpp

1567

That may be true, but my version is better than what existed previously.

llvm/lib/IR/Constants.cpp

 Constant *Constant::getSplatValue(bool AllowUndefs) const {
   assert(this->getType()->isVectorTy() && "Only valid for vectors!");
   if (isa<ConstantAggregateZero>(this))
     return getNullValue(cast<VectorType>(getType())->getElementType());
   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
     return CV->getSplatValue();
   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     return CV->getSplatValue(AllowUndefs);
+
+  // Check if this is a constant expression splat of the form returned by
+  // ConstantVector::getSplat()
+  Constant *SplatVal = nullptr;
+  ConstantInt *Index = nullptr;
+
+  match(this,
+        m_Shuffle(m_InsertElt(m_Undef(), m_Constant(SplatVal), m_ConstantInt()),
+                  m_Undef()));
+
+  if (Index && Index->getValue() == 0) {
+    if (SplatVal) {
+      return SplatVal;
+    }
+  }
+
   return nullptr;
 }
 
 Constant *ConstantVector::getSplatValue(bool AllowUndefs) const {
   // Check out first element.
   Constant *Elt = getOperand(0);
   // Then make sure all remaining elements point to the same value.
   for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
if (isa<UndefValue>(Elt))
       Elt = OpC;
 
     if (OpC != Elt)
       return nullptr;
   }
   return Elt;
 }
 
 const APInt &Constant::getUniqueInteger() const {
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     return CI->getValue();
   assert(this->getSplatValue() && "Doesn't contain a unique integer!");
   const Constant *C = this->getAggregateElement(0U);
   assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
   return cast<ConstantInt>(C)->getValue();
 }