[ValueTracking] Add option to ignore ptrmask in getUnderlyingObject*

[krzysz00]

Summary

In some cases (an upcoming pass of mine that deals with a non-integral
address space) we want getUnderlyingObject() to regard the result of a
ptrmask() or other similar intrinsic that performs arbitrary bit
manipulation on a pointer to be considered a new object for analysis
purposes.

This commit supports this usecase by adding AllowBitManipulation as an
option to getUnderlyingObject*(). It will not break existing code
because the option defaults to true, which preserves the existing
behavior.

[arsenm]

Needs tests. Also feels like the wrong way to deal with this. The whole point of ptrmask is that it does keep pointing to the underlying object? ptrmask also isn't arbitrary bit manipulation, it's an and

[krzysz00]

On further consideation of the underlying problem, I won't need this.

llvm/include/llvm/Analysis/ValueTracking.h

 /// the intrinsic must preserve the nullness of the pointer.
 bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
     const CallBase *Call, bool MustPreserveNullness);
 
 /// This method strips off any GEP address adjustments and pointer casts from
 /// the specified value, returning the original object being addressed. Note
 /// that the returned value has pointer type if the specified value does. If
 /// the MaxLookup value is non-zero, it limits the number of instructions to
-/// be stripped off.
-const Value *getUnderlyingObject(const Value *V, unsigned MaxLookup = 6);
-inline Value *getUnderlyingObject(Value *V, unsigned MaxLookup = 6) {
+/// be stripped off. This will look through llvm.ptrmask unless
+/// AllowBitManipulation is false.
+const Value *getUnderlyingObject(const Value *V, unsigned MaxLookup = 6,
+                                 bool AllowBitManipulation = true);
+inline Value *getUnderlyingObject(Value *V, unsigned MaxLookup = 6,
+                                  bool AllowBitManipulation = true) {
   // Force const to avoid infinite recursion.
   const Value *VConst = V;
   return const_cast<Value *>(getUnderlyingObject(VConst, MaxLookup));
 }
 
 /// This method is similar to getUnderlyingObject except that it can
 /// look through phi and select instructions and return multiple objects.
 ///

 ///     for (j: 0..N) {
 ///        Curr[j] = Prev[j] * B[j]
 ///     }
 ///   }
 ///
 /// Since A[i] and A[i-1] are independent pointers, getUnderlyingObjects
 /// should not assume that Curr and Prev share the same underlying object thus
 /// it shouldn't look through the phi above.
+///
 void getUnderlyingObjects(const Value *V,
                           SmallVectorImpl<const Value *> &Objects,
-                          LoopInfo *LI = nullptr, unsigned MaxLookup = 6);
+                          LoopInfo *LI = nullptr, unsigned MaxLookup = 6,
+                          bool AllowBitManipulation = true);
 
 /// This is a wrapper around getUnderlyingObjects and adds support for basic
 /// ptrtoint+arithmetic+inttoptr sequences.
 bool getUnderlyingObjectsForCodeGen(const Value *V,
                                     SmallVectorImpl<Value *> &Objects);
 
 /// Returns unique alloca where the value comes from, or nullptr.
 /// If OffsetZero is true check that V points to the begining of the alloca.

llvm/lib/Analysis/ValueTracking.cpp

static bool isSameUnderlyingObjectInLoop(const PHINode *PN,
   //       int *p = a[i];
   //       ...
   if (auto *Load = dyn_cast<LoadInst>(PrevValue))
     if (!L->isLoopInvariant(Load->getPointerOperand()))
       return false;
   return true;
 }
 
-const Value *llvm::getUnderlyingObject(const Value *V, unsigned MaxLookup) {
+const Value *llvm::getUnderlyingObject(const Value *V, unsigned MaxLookup,
+                                       bool AllowBitManipulation) {
   if (!V->getType()->isPointerTy())
     return V;
   for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
     if (auto *GEP = dyn_cast<GEPOperator>(V)) {
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast ||
                Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
       V = cast<Operator>(V)->getOperand(0);
if (auto *GEP = dyn_cast<GEPOperator>(V)) {
         // CaptureTracking can know about special capturing properties of some
         // intrinsics like launder.invariant.group, that can't be expressed with
         // the attributes, but have properties like returning aliasing pointer.
         // Because some analysis may assume that nocaptured pointer is not
         // returned from some special intrinsic (because function would have to
         // be marked with returns attribute), it is crucial to use this function
         // because it should be in sync with CaptureTracking. Not using it may
         // cause weird miscompilations where 2 aliasing pointers are assumed to
-        // noalias.
-        if (auto *RP = getArgumentAliasingToReturnedPointer(Call, false)) {
+        // noalias. If bit manipulation is forbidden, then intrinsics that do
+        // not preserve the null pointer, namely ptrmask, count as a new
+        // underlying object.
+        if (auto *RP = getArgumentAliasingToReturnedPointer(
+                Call, !AllowBitManipulation)) {
           V = RP;
           continue;
         }
       }
 
       return V;
     }
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   }
   return V;
 }
 
 void llvm::getUnderlyingObjects(const Value *V,
                                 SmallVectorImpl<const Value *> &Objects,
-                                LoopInfo *LI, unsigned MaxLookup) {
+                                LoopInfo *LI, unsigned MaxLookup,
+                                bool AllowBitManipulation) {
   SmallPtrSet<const Value *, 4> Visited;
   SmallVector<const Value *, 4> Worklist;
   Worklist.push_back(V);
   do {
     const Value *P = Worklist.pop_back_val();
-    P = getUnderlyingObject(P, MaxLookup);
+    P = getUnderlyingObject(P, MaxLookup, AllowBitManipulation);
 
     if (!Visited.insert(P).second)
       continue;
 
     if (auto *SI = dyn_cast<SelectInst>(P)) {
       Worklist.push_back(SI->getTrueValue());
       Worklist.push_back(SI->getFalseValue());
       continue;