[Analysis] Fix issues when querying vscale attributes on functions

[david-arm]

Summary

There are several places in the code that are currently broken as
they assume an Instruction always has a parent Function when
attempting to get the vscale_range attribute. This patch adds checks
that an Instruction has a parent.

[sdesmalen]

I don't think all these cases are currently broken, because InstCombine traverses nodes that are in the IR. I'm not against having an extra guard for it though.
Is it worth adding a test for the ValueTracking case to avoid regression?

[david-arm]

Hi @sdesmalen, yeah I agree it would be good to have a test for the ValueTracking.cpp fix, but I wasn't sure how to create a simple, reliable test case where I is guaranteed not to have a parent?

[sdesmalen]

In D110158#3012207, @david-arm wrote:

Hi @sdesmalen, yeah I agree it would be good to have a test for the ValueTracking.cpp fix, but I wasn't sure how to create a simple, reliable test case where I is guaranteed not to have a parent?

Maybe a unittest in llvm/unittests/Support/KnownBitsTest.cpp?

[david-arm]

• Added unit test for parentless vscale call instructions

[david-arm]

• Simplified the unit test so we can avoid calling parseAssembly

[sdesmalen]

LGTM, cheers @david-arm!

llvm/lib/Analysis/ValueTracking.cpp

if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
       case Intrinsic::riscv_vsetvli:
       case Intrinsic::riscv_vsetvlimax:
         // Assume that VL output is positive and would fit in an int32_t.
         // TODO: VLEN might be capped at 16 bits in a future V spec update.
         if (BitWidth >= 32)
           Known.Zero.setBitsFrom(31);
         break;
       case Intrinsic::vscale: {
-        if (!II->getFunction()->hasFnAttribute(Attribute::VScaleRange))
+        if (!II->getParent() ||
+            !II->getFunction()->hasFnAttribute(Attribute::VScaleRange))
           break;
 
         auto VScaleRange = II->getFunction()
                                ->getFnAttribute(Attribute::VScaleRange)
                                .getVScaleRangeArgs();
 
         if (VScaleRange.second == 0)
           break;

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

if (AWidth == DestWidth && AWidth > Log2_32(SrcWidth)) {
       Value *WidthDiff = ConstantInt::get(A->getType(), SrcWidth - AWidth);
       Value *NarrowCtlz =
           Builder.CreateIntrinsic(Intrinsic::ctlz, {Trunc.getType()}, {A, B});
       return BinaryOperator::CreateAdd(NarrowCtlz, WidthDiff);
     }
   }
 
   if (match(Src, m_VScale(DL))) {
-    if (Trunc.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
+    if (Trunc.getFunction() &&
+        Trunc.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
       unsigned MaxVScale = Trunc.getFunction()
                                ->getFnAttribute(Attribute::VScaleRange)
                                .getVScaleRangeArgs()
                                .second;
       if (MaxVScale > 0 && Log2_32(MaxVScale) < DestWidth) {
         Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
         return replaceInstUsesWith(Trunc, VScale);
       }
Instruction *InstCombinerImpl::visitZExt(ZExtInst &CI) {
   if (match(Src, m_OneUse(m_Xor(m_Value(And), m_Constant(C)))) &&
       match(And, m_OneUse(m_And(m_Trunc(m_Value(X)), m_Specific(C)))) &&
       X->getType() == CI.getType()) {
     Constant *ZC = ConstantExpr::getZExt(C, CI.getType());
     return BinaryOperator::CreateXor(Builder.CreateAnd(X, ZC), ZC);
   }
 
   if (match(Src, m_VScale(DL))) {
-    if (CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
+    if (CI.getFunction() &&
+        CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
       unsigned MaxVScale = CI.getFunction()
                                ->getFnAttribute(Attribute::VScaleRange)
                                .getVScaleRangeArgs()
                                .second;
       unsigned TypeWidth = Src->getType()->getScalarSizeInBits();
       if (MaxVScale > 0 && Log2_32(MaxVScale) < TypeWidth) {
         Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
         return replaceInstUsesWith(CI, VScale);
if (match(Src, m_OneUse(m_AShr(m_Trunc(m_Value(X)),
       X->getType() == DestTy) {
     Constant *ShlAmtC = ConstantInt::get(DestTy, DestBitSize - SrcBitSize);
     Constant *AshrAmtC = ConstantInt::get(DestTy, DestBitSize - 1);
     Value *Shl = Builder.CreateShl(X, ShlAmtC);
     return BinaryOperator::CreateAShr(Shl, AshrAmtC);
   }
 
   if (match(Src, m_VScale(DL))) {
-    if (CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
+    if (CI.getFunction() &&
+        CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
       unsigned MaxVScale = CI.getFunction()
                                ->getFnAttribute(Attribute::VScaleRange)
                                .getVScaleRangeArgs()
                                .second;
       if (MaxVScale > 0 && Log2_32(MaxVScale) < (SrcBitSize - 1)) {
         Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
         return replaceInstUsesWith(CI, VScale);
       }

llvm/unittests/Analysis/ValueTrackingTest.cpp

 //===- ValueTrackingTest.cpp - ValueTracking tests ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/KnownBits.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Transforms/Utils/Local.h"
TEST_F(ComputeKnownBitsTest, ComputeKnownBitsAddWithRange) {
   EXPECT_EQ(Known.Zero.getZExtValue(), (~(65536llu - 1)) << 1);
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
   // The known range is not precise given computeKnownBits works
   // with the masks of zeros and ones, not the ranges.
   EXPECT_EQ(Known.getMinValue(), 0u);
   EXPECT_EQ(Known.getMaxValue(), 131071);
 }
 
+TEST_F(ComputeKnownBitsTest, ComputeKnownBitsUnknownVScale) {
+  Module M("", Context);
+  IRBuilder<> Builder(Context);
+  Function *TheFn =
+      Intrinsic::getDeclaration(&M, Intrinsic::vscale, {Builder.getInt32Ty()});
+  CallInst *CI = Builder.CreateCall(TheFn, {}, {}, "");
+
+  KnownBits Known = computeKnownBits(CI, M.getDataLayout(), /* Depth */ 0);
+  delete CI;
+
+  // There is no parent function so we cannot look up the vscale_range
+  // attribute to determine the number of bits.
+  EXPECT_EQ(Known.One.getZExtValue(), 0u);
+  EXPECT_EQ(Known.Zero.getZExtValue(), 0u);
+}
+
 // 512 + [32, 64) doesn't produce overlapping bits.
 // Make sure we get all the individual bits properly.
 TEST_F(ComputeKnownBitsTest, ComputeKnownBitsAddWithRangeNoOverlap) {
   parseAssembly("define void @test(i64* %p) {\n"
                 "  %A = load i64, i64* %p, !range !{i64 32, i64 64}\n"
                 "  %APlus512 = add i64 %A, 512\n"
                 "  %c = icmp ugt i64 %APlus512, 523\n"
                 "  call void @llvm.assume(i1 %c)\n"