[AArch64][NFC] Call the API getVScaleRange directly

[Allen]

Summary

Use the maximum 64 for BitWidth of getVScaleRange to avoid returning an empty range.

the previous changes bring in a Buildbot failure because MinSVEVectorSize = MinSVEVectorSize.

error: explicitly assigning value of variable of type 'unsigned int' to itself [-Werror,-Wself-assign]

[dmgreen]

I like the cleanup. getVScaleRange can fail, returning an empty range. Would this handle those cases too?

[nikic]

llvm/lib/Analysis/InstructionSimplify.cpp

6544

if (const APInt *C = CR.getSingleElement())

[Allen]

In D155708#4517477, @dmgreen wrote:

I like the cleanup. getVScaleRange can fail, returning an empty range. Would this handle those cases too?

Use the maximum 64 for BitWidth of getVScaleRange to avoid returning an empty range.

[Allen]

ping

[sdesmalen]

In D155708#4518310, @Allen wrote:

In D155708#4517477, @dmgreen wrote:

I like the cleanup. getVScaleRange can fail, returning an empty range. Would this handle those cases too?

Use the maximum 64 for BitWidth of getVScaleRange to avoid returning an empty range.

It seems getSingleElement() returns nullptr when:

• The range is empty
• The range is invalid
• The maximum < minimum (e.g. for a range of vscale_range(1, 0)).

So I think the change is fine, regardless of the bitwidth.

[nikic]

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

405

I'm not sure this is going to do the right thing if there is no upper bound on the range. Won't the * 128 overflow in that case?

[Allen]

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

405

This refactor doesn't reduces the range of the upper limit.
Maybe we assume there is no overflow because the maximum value of vscale is 2048 for arm targets, https://reviews.llvm.org/D98030

[DavidSpickett]

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

420

/work/open_source/lldb-cross-compile/llvm-project/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp:420:22: warning: explicitly assigning value of variable of type 'unsigned int' to itself [-Wself-assign]
    MinSVEVectorSize = MinSVEVectorSize;
    ~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~

Compiling with clang-11.

[Allen]

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

420

Thanks for the reminder, I already revert , and will fix this bug.

[Allen]

Fix build error

error: explicitly assigning value of variable of type 'unsigned int' to itself [-Werror,-Wself-assign]

llvm/lib/Analysis/InstructionSimplify.cpp

   Function *F = cast<Function>(Callee);
   Intrinsic::ID IID = F->getIntrinsicID();
 
   // Most of the intrinsics with no operands have some kind of side effect.
   // Don't simplify.
   if (!NumOperands) {
     switch (IID) {
     case Intrinsic::vscale: {
-      auto Attr = Call->getFunction()->getFnAttribute(Attribute::VScaleRange);
-      if (!Attr.isValid())
-        return nullptr;
-      unsigned VScaleMin = Attr.getVScaleRangeMin();
-      std::optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
-      if (VScaleMax && VScaleMin == VScaleMax)
-        return ConstantInt::get(F->getReturnType(), VScaleMin);
+      Type *RetTy = F->getReturnType();
+      ConstantRange CR = getVScaleRange(Call->getFunction(), 64);
+      if (const APInt *C = CR.getSingleElement())
+        return ConstantInt::get(RetTy, C->getZExtValue());
       return nullptr;
     }
     default:
       return nullptr;
     }
   }
 
   if (NumOperands == 1)

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

                                 bool ConstantFold) {
   assert(MulImm.getSignificantBits() <= VT.getSizeInBits() &&
          "Immediate does not fit VT");
 
   MulImm = MulImm.sextOrTrunc(VT.getSizeInBits());
 
   if (ConstantFold) {
     const MachineFunction &MF = getMachineFunction();
-    auto Attr = MF.getFunction().getFnAttribute(Attribute::VScaleRange);
-    if (Attr.isValid()) {
-      unsigned VScaleMin = Attr.getVScaleRangeMin();
-      if (std::optional<unsigned> VScaleMax = Attr.getVScaleRangeMax())
-        if (*VScaleMax == VScaleMin)
-          return getConstant(MulImm * VScaleMin, DL, VT);
-    }
+    const Function &F = MF.getFunction();
+    ConstantRange CR = getVScaleRange(&F, 64);
+    if (const APInt *C = CR.getSingleElement())
+      return getConstant(MulImm * C->getZExtValue(), DL, VT);
   }
 
   return getNode(ISD::VSCALE, DL, VT, getConstant(MulImm, DL, VT));
 }
 
 SDValue SelectionDAG::getElementCount(const SDLoc &DL, EVT VT, ElementCount EC,
                                       bool ConstantFold) {
   if (EC.isScalable())

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

 #include "AArch64MacroFusion.h"
 #include "AArch64Subtarget.h"
 #include "AArch64TargetObjectFile.h"
 #include "AArch64TargetTransformInfo.h"
 #include "MCTargetDesc/AArch64MCTargetDesc.h"
 #include "TargetInfo/AArch64TargetInfo.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/CodeGen/CFIFixup.h"
 #include "llvm/CodeGen/CSEConfigBase.h"
 #include "llvm/CodeGen/GlobalISel/CSEInfo.h"
 #include "llvm/CodeGen/GlobalISel/IRTranslator.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
 #include "llvm/CodeGen/GlobalISel/Legalizer.h"
 #include "llvm/CodeGen/GlobalISel/LoadStoreOpt.h"
 #include "llvm/CodeGen/GlobalISel/Localizer.h"

 
   bool StreamingSVEMode = F.hasFnAttribute("aarch64_pstate_sm_enabled") ||
                           F.hasFnAttribute("aarch64_pstate_sm_body");
   bool StreamingCompatibleSVEMode =
       F.hasFnAttribute("aarch64_pstate_sm_compatible");
 
   unsigned MinSVEVectorSize = 0;
   unsigned MaxSVEVectorSize = 0;
-  Attribute VScaleRangeAttr = F.getFnAttribute(Attribute::VScaleRange);
-  if (VScaleRangeAttr.isValid()) {
-    std::optional<unsigned> VScaleMax = VScaleRangeAttr.getVScaleRangeMax();
-    MinSVEVectorSize = VScaleRangeAttr.getVScaleRangeMin() * 128;
-    MaxSVEVectorSize = VScaleMax ? *VScaleMax * 128 : 0;
+  if (F.hasFnAttribute(Attribute::VScaleRange)) {
+    ConstantRange CR = getVScaleRange(&F, 64);
+    MinSVEVectorSize = CR.getUnsignedMin().getZExtValue() * 128;
+    MaxSVEVectorSize = CR.getUnsignedMax().getZExtValue() * 128;
   } else {
     MinSVEVectorSize = SVEVectorBitsMinOpt;
     MaxSVEVectorSize = SVEVectorBitsMaxOpt;
   }
 
   assert(MinSVEVectorSize % 128 == 0 &&
          "SVE requires vector length in multiples of 128!");
   assert(MaxSVEVectorSize % 128 == 0 &&
          "SVE requires vector length in multiples of 128!");
   assert((MaxSVEVectorSize >= MinSVEVectorSize || MaxSVEVectorSize == 0) &&
          "Minimum SVE vector size should not be larger than its maximum!");
 
   // Sanitize user input in case of no asserts
-  if (MaxSVEVectorSize == 0)
-    MinSVEVectorSize = (MinSVEVectorSize / 128) * 128;
-  else {
-    MinSVEVectorSize =
-        (std::min(MinSVEVectorSize, MaxSVEVectorSize) / 128) * 128;
-    MaxSVEVectorSize =
-        (std::max(MinSVEVectorSize, MaxSVEVectorSize) / 128) * 128;
+  if (MaxSVEVectorSize != 0) {
+    MinSVEVectorSize = std::min(MinSVEVectorSize, MaxSVEVectorSize);
+    MaxSVEVectorSize = std::max(MinSVEVectorSize, MaxSVEVectorSize);
   }
 
   SmallString<512> Key;
   raw_svector_ostream(Key) << "SVEMin" << MinSVEVectorSize << "SVEMax"
                            << MaxSVEVectorSize
                            << "StreamingSVEMode=" << StreamingSVEMode
                            << "StreamingCompatibleSVEMode="
                            << StreamingCompatibleSVEMode << CPU << TuneCPU