[SVE] Fix invalid usages of getNumElements() in ValueTracking

[ctetreau]

Summary

Fix invalid usage of getNumElements in ComputeNumSignBits.
getNumElements was being used to compute the DemandedElts. Since we
can't know the length of a scalable vector, we will instead ignore the
value of DemandedElts, and bail out in any codepath that needs it.

Fix invalid usages of getNumElements in
computeNumSignBitsVectorConstant. Bail out early if the vector is
scalable.

Identified by test case LLVM.Transforms/InstCombine::nsw.ll

[ctetreau]

minor stylistic changes

[sdesmalen]

Is there a way we can test/guard this?

llvm/lib/Analysis/ValueTracking.cpp

378

By checking the result of dyn_cast<FixedVectorType>, this switch will select APInt(1, 1) when Ty is a ScalableVectorType.
I guess this should just bail out when the type is a scalable vector.

2698

This should be !isa<VectorType>, because APInt(1, 1) doesn't work for scalable vectors.

Should this function also bail out early when the type is a scalablevector?

[ctetreau]

llvm/lib/Analysis/ValueTracking.cpp

378

I did this on purpose for the same reasoning as in D79053.

Though I'm no longer convinced that it will work for that commit either. I'm thinking these might need a bigger rework that I was hoping to do today. Some sort of scalable APInt? Or maybe we just need a polynomial type?

[ctetreau]

I'm going to abandon this and roll the changes into D79053.

For now, I'm just going to bail for all things that take a DemandedElts.

llvm/lib/Analysis/ValueTracking.cpp

 }
 
 static unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts,
                                    unsigned Depth, const Query &Q);
 
 static unsigned ComputeNumSignBits(const Value *V, unsigned Depth,
                                    const Query &Q) {
   Type *Ty = V->getType();
+  auto *FVTy = dyn_cast<FixedVectorType>(Ty);
   APInt DemandedElts =
-      Ty->isVectorTy()
-          ? APInt::getAllOnesValue(cast<VectorType>(Ty)->getNumElements())
-          : APInt(1, 1);
+      FVTy ? APInt::getAllOnesValue(FVTy->getNumElements()) : APInt(1, 1);
   return ComputeNumSignBits(V, DemandedElts, Depth, Q);
 }
 
 unsigned llvm::ComputeNumSignBits(const Value *V, const DataLayout &DL,
                                   unsigned Depth, AssumptionCache *AC,
                                   const Instruction *CxtI,
                                   const DominatorTree *DT, bool UseInstrInfo) {
   return ::ComputeNumSignBits(
static bool isSignedMinMaxClamp(const Value *Select, const Value *&In,
 
   if (SPF == SPF_SMIN)
     std::swap(CLow, CHigh);
 
   In = LHS2;
   return CLow->sle(*CHigh);
 }
 
-/// For vector constants, loop over the elements and find the constant with the
-/// minimum number of sign bits. Return 0 if the value is not a vector constant
-/// or if any element was not analyzed; otherwise, return the count for the
-/// element with the minimum number of sign bits.
-static unsigned computeNumSignBitsVectorConstant(const Value *V,
+/// For fixed width vector constants, loop over the elements and find the
+/// constant with the minimum number of sign bits. Return 0 if the value is
+/// not a vector constant or if any element was not analyzed; otherwise,
+/// return the count for the element with the minimum number of sign bits.
+static unsigned ComputeNumSignBitsVectorConstant(const Value *V,
                                                  const APInt &DemandedElts,
                                                  unsigned TyBits) {
   const auto *CV = dyn_cast<Constant>(V);
-  if (!CV || !CV->getType()->isVectorTy())
+  if (!CV || !isa<FixedVectorType>(CV->getType()))
     return 0;
 
   unsigned MinSignBits = TyBits;
-  unsigned NumElts = cast<VectorType>(CV->getType())->getNumElements();
+  unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
   for (unsigned i = 0; i != NumElts; ++i) {
     if (!DemandedElts[i])
       continue;
     // If we find a non-ConstantInt, bail out.
     auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
     if (!Elt)
       return 0;
 
static unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts,
   assert(Result > 0 && "At least one sign bit needs to be present!");
   return Result;
 }
 
 /// Return the number of times the sign bit of the register is replicated into
 /// the other bits. We know that at least 1 bit is always equal to the sign bit
 /// (itself), but other cases can give us information. For example, immediately
 /// after an "ashr X, 2", we know that the top 3 bits are all equal to each
-/// other, so we return 3. For vectors, return the number of sign bits for the
-/// vector element with the minimum number of known sign bits of the demanded
-/// elements in the vector specified by DemandedElts.
+/// other, so we return 3. For fixed width vectors, return the number of sign
+/// bits for the vector element with the minimum number of known sign bits of
+/// the demanded elements in the vector specified by DemandedElts.
 static unsigned ComputeNumSignBitsImpl(const Value *V,
                                        const APInt &DemandedElts,
                                        unsigned Depth, const Query &Q) {
   assert(Depth <= MaxDepth && "Limit Search Depth");
 
   // We return the minimum number of sign bits that are guaranteed to be present
   // in V, so for undef we have to conservatively return 1.  We don't have the
   // same behavior for poison though -- that's a FIXME today.
 
   Type *Ty = V->getType();
-  assert(((Ty->isVectorTy() && cast<VectorType>(Ty)->getNumElements() ==
-                                   DemandedElts.getBitWidth()) ||
-          (!Ty->isVectorTy() && DemandedElts == APInt(1, 1))) &&
+  assert(((isa<FixedVectorType>(Ty) &&
+           cast<FixedVectorType>(Ty)->getNumElements() ==
+          (!isa<FixedVectorType>(Ty) && DemandedElts == APInt(1, 1))) &&
          "Unexpected vector size");
 
   Type *ScalarTy = Ty->getScalarType();
   unsigned TyBits = ScalarTy->isPointerTy() ?
     Q.DL.getPointerTypeSizeInBits(ScalarTy) :
     Q.DL.getTypeSizeInBits(ScalarTy);
 
   unsigned Tmp, Tmp2;
static unsigned ComputeNumSignBitsImpl(const Value *V,
   }
 
   // Finally, if we can prove that the top bits of the result are 0's or 1's,
   // use this information.
 
   // If we can examine all elements of a vector constant successfully, we're
   // done (we can't do any better than that). If not, keep trying.
   if (unsigned VecSignBits =
-          computeNumSignBitsVectorConstant(V, DemandedElts, TyBits))
+          ComputeNumSignBitsVectorConstant(V, DemandedElts, TyBits))
     return VecSignBits;
 
   KnownBits Known(TyBits);
   computeKnownBits(V, DemandedElts, Known, Depth, Q);
 
   // If we know that the sign bit is either zero or one, determine the number of
   // identical bits in the top of the input value.
   return std::max(FirstAnswer, Known.countMinSignBits());