Make context-sensitive isDereferenceable queries in isSafeToLoadUnconditionally

[apilipenko]

Summary

Separated from D10920

[reames]

Please update at least one user of the API and write a test case that shows the difference in behaviour.

include/llvm/Analysis/Loads.h

29 ↗

(On Diff #45001)

Comment needs updated.

[apilipenko]

Context sensitive queries support is required to replace isDereferenceableAndAlignedPointer in isSafeToExecuteSpecualtively (D16232). There is one more change required to do this because isSafeToExecuteSpecualtively can have no context and pass null as ScanFrom (D16231). Does it make sense to combine them into one patch?

[reames]

LGTM w/minor comment addressed.

(p.s. For those following, Artur pointed out to me that the use was in the original review I asked to be split into several parts. Given that, I'm withdrawing my request for an example use.)

include/llvm/Analysis/Loads.h

29 ↗

(On Diff #45001)

Comment still needs updated.

llvm/trunk/include/llvm/Analysis/Loads.h

 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
 class DataLayout;
 class MDNode;
 
 /// isSafeToLoadUnconditionally - Return true if we know that executing a load
-/// from this value cannot trap.  If it is not obviously safe to load from the
-/// specified pointer, we do a quick local scan of the basic block containing
-/// ScanFrom, to determine if the address is already accessed.
+/// from this value cannot trap.
+///
+/// If DT is specified this method performs context-sensitive analysis.
+///
+/// If it is not obviously safe to load from the specified pointer, we do a
+/// quick local scan of the basic block containing ScanFrom, to determine if
+/// the address is already accessed.
 bool isSafeToLoadUnconditionally(Value *V, unsigned Align,
-                                 Instruction *ScanFrom);
+                                 Instruction *ScanFrom,
+                                 const DominatorTree *DT = nullptr,
+                                 const TargetLibraryInfo *TLI = nullptr);
 
 /// DefMaxInstsToScan - the default number of maximum instructions
 /// to scan in the block, used by FindAvailableLoadedValue().
 extern cl::opt<unsigned> DefMaxInstsToScan;
 
 /// FindAvailableLoadedValue - Scan the ScanBB block backwards (starting at
 /// the instruction before ScanFrom) checking to see if we have the value at
 /// the memory address *Ptr locally available within a small number of

llvm/trunk/lib/Analysis/Loads.cpp

if (const Instruction *BI = dyn_cast<Instruction>(B))
         return true;
 
   // Otherwise they may not be equivalent.
   return false;
 }
 
 /// \brief Check if executing a load of this pointer value cannot trap.
 ///
+/// If DT is specified this method performs context-sensitive analysis.
+///
 /// If it is not obviously safe to load from the specified pointer, we do
 /// a quick local scan of the basic block containing \c ScanFrom, to determine
 /// if the address is already accessed.
 ///
 /// This uses the pointee type to determine how many bytes need to be safe to
 /// load from the pointer.
 bool llvm::isSafeToLoadUnconditionally(Value *V, unsigned Align,
-                                       Instruction *ScanFrom) {
+                                       Instruction *ScanFrom,
+                                       const DominatorTree *DT,
+                                       const TargetLibraryInfo *TLI) {
   const DataLayout &DL = ScanFrom->getModule()->getDataLayout();
 
   // Zero alignment means that the load has the ABI alignment for the target
   if (Align == 0)
     Align = DL.getABITypeAlignment(V->getType()->getPointerElementType());
   assert(isPowerOf2_32(Align));
 
-  if (isDereferenceableAndAlignedPointer(V, Align, DL))
+  // If DT is not specified we can't make context-sensitive query
+  const Instruction* CtxI = DT ? ScanFrom : nullptr;
+  if (isDereferenceableAndAlignedPointer(V, Align, DL, CtxI, DT, TLI))
     return true;
 
   int64_t ByteOffset = 0;
   Value *Base = V;
   Base = GetPointerBaseWithConstantOffset(V, ByteOffset, DL);
 
   if (ByteOffset < 0) // out of bounds
     return false;