[NFC][ValueTracking]: Move some code from isKnownNonZero to isKnownNonZeroFromOperator

[0xdc03]

Summary

There is some pointer simplification code originally from isKnownNonNull
that is now better suited to be in isKnownNonZeroFromOperator.

[goldstein.w.n]

No complaints about the code, but just curious whats the rationale? Why is isKnownNonZeroFromOperator a better home?

[0xdc03]

In D156141#4530090, @goldstein.w.n wrote:

No complaints about the code, but just curious whats the rationale? Why is isKnownNonZeroFromOperator a better home?

For AllocaInst, isKnownNonZeroFromOperator now holds the big switch with all the instruction types so it makes more sense to me for it to be in there.

For CallBase, I think it is better if the code is combined with the rest of the CallInst handling that is already there.

[nikic]

llvm/lib/Analysis/ValueTracking.cpp

2459–2461

Alloca always returns a pointer.

2693–2702

Should add case Instruction::Invoke: here as well.

2694

Can be cast<>. We should probably also guard this against I->getType()->isPointerTy().

[0xdc03]

• Address reviewer comments

[nikic]

LG

llvm/lib/Analysis/ValueTracking.cpp

static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts,
   return false;
 }
 
 static bool isKnownNonZeroFromOperator(const Operator *I,
                                        const APInt &DemandedElts,
                                        unsigned Depth, const SimplifyQuery &Q) {
   unsigned BitWidth = getBitWidth(I->getType()->getScalarType(), Q.DL);
   switch (I->getOpcode()) {
+  case Instruction::Alloca:
+    // Alloca never returns null, malloc might.
+    return I->getType()->getPointerAddressSpace() == 0;
   case Instruction::GetElementPtr:
     if (I->getType()->isPointerTy())
       return isGEPKnownNonNull(cast<GEPOperator>(I), Depth, Q);
     break;
   case Instruction::BitCast: {
     // We need to be a bit careful here. We can only peek through the bitcast
     // if the scalar size of elements in the operand are smaller than and a
     // multiple of the size they are casting too. Take three cases:
     //
     // 1) Unsafe:
static bool isKnownNonZeroFromOperator(const Operator *I,
   case Instruction::Load:
     // A Load tagged with nonnull metadata is never null.
     if (Q.IIQ.getMetadata(cast<LoadInst>(I), LLVMContext::MD_nonnull))
       return true;
 
     // No need to fall through to computeKnownBits as range metadata is already
     // handled in isKnownNonZero.
     return false;
   case Instruction::Call:
+  case Instruction::Invoke:
+    if (I->getType()->isPointerTy()) {
+      const auto *Call = cast<CallBase>(I);
+      if (Call->isReturnNonNull())
+        return true;
+      if (const auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
+        return isKnownNonZero(RP, Depth, Q);
+    }
+
     if (auto *II = dyn_cast<IntrinsicInst>(I)) {
       switch (II->getIntrinsicID()) {
       case Intrinsic::sshl_sat:
       case Intrinsic::ushl_sat:
       case Intrinsic::abs:
       case Intrinsic::bitreverse:
       case Intrinsic::bswap:
       case Intrinsic::ctpop:
#endif
 
   // Some of the tests below are recursive, so bail out if we hit the limit.
   if (Depth++ >= MaxAnalysisRecursionDepth)
     return false;
 
   // Check for pointer simplifications.
 
   if (PointerType *PtrTy = dyn_cast<PointerType>(V->getType())) {
-    // Alloca never returns null, malloc might.
-    if (isa<AllocaInst>(V) && PtrTy->getAddressSpace() == 0)
-      return true;
-
     // A byval, inalloca may not be null in a non-default addres space. A
     // nonnull argument is assumed never 0.
     if (const Argument *A = dyn_cast<Argument>(V)) {
       if (((A->hasPassPointeeByValueCopyAttr() &&
             !NullPointerIsDefined(A->getParent(), PtrTy->getAddressSpace())) ||
            A->hasNonNullAttr()))
         return true;
     }
-
-    if (const auto *Call = dyn_cast<CallBase>(V)) {
-      if (Call->isReturnNonNull())
-        return true;
-      if (const auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
-        return isKnownNonZero(RP, Depth, Q);
-    }
   }
 
   if (const auto *I = dyn_cast<Operator>(V))
     if (isKnownNonZeroFromOperator(I, DemandedElts, Depth, Q))
       return true;
 
   if (!isa<Constant>(V) &&
       isKnownNonNullFromDominatingCondition(V, Q.CxtI, Q.DT))