[PATCH 11/27] [noalias] D9379: llvm.noalias and ValueTracking

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Rebase of:

• D9379: llvm.noalias - don't interfere with llvm.assume
• D9398: llvm.noalias - GetUnderlyingObjects to optionally collect noalias calls

And adapted for full restrict.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/include/llvm/Analysis/ValueTracking.h

constexpr unsigned MaxAnalysisRecursionDepth = 6;
   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) {
+  const Value *
+  getUnderlyingObject(const Value *V, unsigned MaxLookup = 6,
+                      SmallVectorImpl<Instruction *> *NoAlias = nullptr);
+  inline Value *
+  getUnderlyingObject(Value *V, unsigned MaxLookup = 6,
+                      SmallVectorImpl<Instruction *> *NoAlias = nullptr) {
     // Force const to avoid infinite recursion.
     const Value *VConst = V;
-    return const_cast<Value *>(getUnderlyingObject(VConst, MaxLookup));
+    return const_cast<Value *>(getUnderlyingObject(VConst, MaxLookup, NoAlias));
   }
 
   /// This method is similar to getUnderlyingObject except that it can
   /// look through phi and select instructions and return multiple objects.
   ///
   /// If LoopInfo is passed, loop phis are further analyzed.  If a pointer
   /// accesses different objects in each iteration, we don't look through the
   /// phi node. E.g. consider this loop nest:
constexpr unsigned MaxAnalysisRecursionDepth = 6;
   ///     Curr = A[i];
   ///     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.
+  /// it shouldn't look through the phi above. If a NoAlias vector is provided,
+  /// it is filled with any llvm.noalias intrinsics looked through to find the
+  /// underlying objects.
   void getUnderlyingObjects(const Value *V,
                             SmallVectorImpl<const Value *> &Objects,
-                            LoopInfo *LI = nullptr, unsigned MaxLookup = 6);
+                            LoopInfo *LI = nullptr, unsigned MaxLookup = 6,
+                            SmallVectorImpl<Instruction *> *NoAlias = nullptr);
 
   /// 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/include/llvm/IR/IntrinsicInst.h

bool isAssumeLikeIntrinsic() const {
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
     case Intrinsic::dbg_label:
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
     case Intrinsic::experimental_noalias_scope_decl:
+    case Intrinsic::noalias_decl:
+    case Intrinsic::noalias:
+    case Intrinsic::provenance_noalias:
+    case Intrinsic::noalias_arg_guard:
+    case Intrinsic::noalias_copy_guard:
     case Intrinsic::objectsize:
     case Intrinsic::ptr_annotation:
     case Intrinsic::var_annotation:
       return true;
     }
     return false;
   }
 

llvm/lib/Analysis/ValueTracking.cpp

if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
     return Call->getArgOperand(0);
   return nullptr;
 }
 
 bool llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
     const CallBase *Call, bool MustPreserveNullness) {
   switch (Call->getIntrinsicID()) {
   case Intrinsic::launder_invariant_group:
+  case Intrinsic::noalias_arg_guard:
+  case Intrinsic::noalias_copy_guard:
   case Intrinsic::strip_invariant_group:
   case Intrinsic::aarch64_irg:
   case Intrinsic::aarch64_tagp:
     return true;
   case Intrinsic::ptrmask:
     return !MustPreserveNullness;
   default:
     return false;
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,
+                          SmallVectorImpl<Instruction *> *NoAlias) {
   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 (!V->getType()->isPointerTy())
         return V;
     } else if (auto *GA = dyn_cast<GlobalAlias>(V)) {
       if (GA->isInterposable())
         return V;
       V = GA->getAliasee();
     } else {
       if (auto *PHI = dyn_cast<PHINode>(V)) {
         // Look through single-arg phi nodes created by LCSSA.
         if (PHI->getNumIncomingValues() == 1) {
           V = PHI->getIncomingValue(0);
           continue;
         }
       } else if (auto *Call = dyn_cast<CallBase>(V)) {
+        if (NoAlias) {
+          // We are gathering information for ScopedAANoAlias -
+          // Look through noalias and provenance.noalias intrinsic
+          if (Call->getIntrinsicID() == Intrinsic::provenance_noalias ||
+              Call->getIntrinsicID() == Intrinsic::noalias) {
+            NoAlias->push_back(const_cast<CallBase *>(
+                Call)); //@ FIXME: const cast should not be needed
+            V = Call->getArgOperand(0);
+            continue;
+          }
+          // Look trough noalias.arg.guard, and follow the ptr_provenance
+          if (Call->getIntrinsicID() == Intrinsic::noalias_arg_guard) {
+            V = Call->getArgOperand(1);
+            continue;
+          }
+        } else {
+          // We are not gathering information for SCopedAANoAlias -
+          // Look through noalias.arg.guard and follow the pointer path
+          if (Call->getIntrinsicID() == Intrinsic::noalias_arg_guard) {
+            V = Call->getArgOperand(0);
+            continue;
+          }
+        }
+
         // 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)) {
           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,
+                                SmallVectorImpl<Instruction *> *NoAlias) {
   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, NoAlias);
 
     if (!Visited.insert(P).second)
       continue;
 
     if (auto *SI = dyn_cast<SelectInst>(P)) {
       Worklist.push_back(SI->getTrueValue());
       Worklist.push_back(SI->getFalseValue());
       continue;