[LangRef] Require that vscale be a power of two

This change proposes that we require vscale to be a power of two.
This is already true for both in tree backends which support scalable
types.

We had two mechanism for exposing this to the optimizer.

First, we specify that any function with vscale_range must have
a vscale power-of-two type.  In practice, clang will always emit this
attribute for RISCV and AArch64.  Note there's a semantic oddity
here as vscale is required to be a global constant, and yet attributes
are per function.

Second, we have a TTI hook.  Again, both targets which support scalable
vectors returned true for this hook.

This change removes both the TTI hook and the vscale_range
check in ValueTracking (since they're no longer needed), and
deletes the very small amount of code which becomes dead once
the results of the TTI hook are constant.

As can be seen from the test diffs, we had at least some places
which hadn't used the existing hooks.  This might be an artifact
of the way the tests were written, I haven't checked closely.

The biggest argument against this change is that we might someday
want to support a non-power-of-two vscale.  I argue that this
is false generality, and we should simplify for near term reality.
If a piece of hardware comes along with a register size which is
not a multiple of two (as the original SVE specification allowed
before it was revised), we can reverse this change at that time.

Author: preames

llvm/docs/LangRef.rst

@@ -4442,10 +4442,11 @@ elementtype may be any integer, floating-point, pointer type, or a sized
 target extension type that has the ``CanBeVectorElement`` property. Vectors
 of size zero are not allowed. For scalable vectors, the total number of
 elements is a constant multiple (called vscale) of the specified number
-of elements; vscale is a positive integer that is unknown at compile time
-and the same hardware-dependent constant for all scalable vectors at run
-time. The size of a specific scalable vector type is thus constant within
-IR, even if the exact size in bytes cannot be determined until run time.
+of elements; vscale is a positive power-of-two integer that is unknown
+at compile time and the same hardware-dependent constant for all scalable
+vectors at run time. The size of a specific scalable vector type is thus
+constant within IR, even if the exact size in bytes cannot be determined
+until run time.
 
 :Examples:
 
@@ -30398,8 +30399,8 @@ vectors such as ``<vscale x 16 x i8>``.
 Semantics:
 """"""""""
 
-``vscale`` is a positive value that is constant throughout program
-execution, but is unknown at compile time.
+``vscale`` is a positive power-of-two value that is constant throughout
+program execution, but is unknown at compile time.
 If the result value does not fit in the result type, then the result is
 a :ref:`poison value <poisonvalues>`.
 

llvm/include/llvm/Analysis/TargetTransformInfo.h

@@ -1220,9 +1220,6 @@ class TargetTransformInfo {
   /// \return the value of vscale to tune the cost model for.
   LLVM_ABI std::optional<unsigned> getVScaleForTuning() const;
 
-  /// \return true if vscale is known to be a power of 2
-  LLVM_ABI bool isVScaleKnownToBeAPowerOfTwo() const;
-
   /// \return True if the vectorization factor should be chosen to
   /// make the vector of the smallest element type match the size of a
   /// vector register. For wider element types, this could result in

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -591,7 +591,6 @@ class TargetTransformInfoImplBase {
   virtual std::optional<unsigned> getVScaleForTuning() const {
     return std::nullopt;
   }
-  virtual bool isVScaleKnownToBeAPowerOfTwo() const { return false; }
 
   virtual bool
   shouldMaximizeVectorBandwidth(TargetTransformInfo::RegisterKind K) const {

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -864,7 +864,6 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
   std::optional<unsigned> getVScaleForTuning() const override {
     return std::nullopt;
   }
-  bool isVScaleKnownToBeAPowerOfTwo() const override { return false; }
 
   /// Estimate the overhead of scalarizing an instruction. Insert and Extract
   /// are set if the demanded result elements need to be inserted and/or

llvm/include/llvm/CodeGen/TargetLowering.h

@@ -623,9 +623,6 @@ class LLVM_ABI TargetLoweringBase {
     return BypassSlowDivWidths;
   }
 
-  /// Return true only if vscale must be a power of two.
-  virtual bool isVScaleKnownToBeAPowerOfTwo() const { return false; }
-
   /// Return true if Flow Control is an expensive operation that should be
   /// avoided.
   bool isJumpExpensive() const { return JumpIsExpensive; }

llvm/lib/Analysis/TargetTransformInfo.cpp

@@ -795,10 +795,6 @@ std::optional<unsigned> TargetTransformInfo::getVScaleForTuning() const {
   return TTIImpl->getVScaleForTuning();
 }
 
-bool TargetTransformInfo::isVScaleKnownToBeAPowerOfTwo() const {
-  return TTIImpl->isVScaleKnownToBeAPowerOfTwo();
-}
-
 bool TargetTransformInfo::shouldMaximizeVectorBandwidth(
     TargetTransformInfo::RegisterKind K) const {
   return TTIImpl->shouldMaximizeVectorBandwidth(K);

llvm/lib/Analysis/ValueTracking.cpp

@@ -2474,11 +2474,9 @@ bool llvm::isKnownToBeAPowerOfTwo(const Value *V, bool OrZero,
   if (!I)
     return false;
 
-  if (Q.CxtI && match(V, m_VScale())) {
-    const Function *F = Q.CxtI->getFunction();
-    // The vscale_range indicates vscale is a power-of-two.
-    return F->hasFnAttribute(Attribute::VScaleRange);
-  }
+  // vscale is a power-of-two by definition
+  if (match(V, m_VScale()))
+    return true;
 
   // 1 << X is clearly a power of two if the one is not shifted off the end.  If
   // it is shifted off the end then the result is undefined.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

@@ -4660,7 +4660,6 @@ bool SelectionDAG::isKnownToBeAPowerOfTwo(SDValue Val, unsigned Depth) const {
 
   // vscale(power-of-two) is a power-of-two for some targets
   if (Val.getOpcode() == ISD::VSCALE &&
-      getTargetLoweringInfo().isVScaleKnownToBeAPowerOfTwo() &&
       isKnownToBeAPowerOfTwo(Val.getOperand(0), Depth + 1))
     return true;
 

llvm/lib/Target/AArch64/AArch64ISelLowering.h

@@ -517,8 +517,6 @@ class AArch64TargetLowering : public TargetLowering {
                               SDValue Chain, SDValue InGlue, unsigned Condition,
                               SDValue PStateSM = SDValue()) const;
 
-  bool isVScaleKnownToBeAPowerOfTwo() const override { return true; }
-
   // Normally SVE is only used for byte size vectors that do not fit within a
   // NEON vector. This changes when OverrideNEON is true, allowing SVE to be
   // used for 64bit and 128bit vectors as well.

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

@@ -156,8 +156,6 @@ class AArch64TTIImpl final : public BasicTTIImplBase<AArch64TTIImpl> {
     return ST->getVScaleForTuning();
   }
 
-  bool isVScaleKnownToBeAPowerOfTwo() const override { return true; }
-
   bool shouldMaximizeVectorBandwidth(
       TargetTransformInfo::RegisterKind K) const override;