[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->getFunction() ||
+            !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);
       }