isSafeToLoadUnconditionally support queries without a context

[apilipenko]

Summary

This is required to use this function from isSafeToSpeculativelyExecute.

[hfinkel]

include/llvm/Analysis/Loads.h

37

If DL is required, and ScanFrom is now not required, why not flip the order so that you can default ScanFrom to nullptr?

[apilipenko]

Flip ScanFrom and DL arguments as suggested by Hal.

[hfinkel]

LGTM.

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 the ScanFrom is specified this method performs context-sensitive analysis
+/// and returns true if it is safe to load immediately before the ScanFrom.
+///
+/// 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,
+                                 const DataLayout &DL,
                                  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

lib/Analysis/Loads.cpp

 /// 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,
+                                       const DataLayout &DL,
                                        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, ScanFrom, DT, TLI))
+  // 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;
 
+  if (!ScanFrom)
+    return false;
+
   PointerType *AddrTy = cast<PointerType>(V->getType());
   uint64_t LoadSize = DL.getTypeStoreSize(AddrTy->getElementType());
 
   // Otherwise, be a little bit aggressive by scanning the local block where we
   // want to check to see if the pointer is already being loaded or stored
   // from/to.  If so, the previous load or store would have already trapped,
   // so there is no harm doing an extra load (also, CSE will later eliminate
   // the load entirely).

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

if (Op->hasOneUse()) {
     // introduced loads cannot trap!  Something like this is valid as long as
     // the condition is always false: load (select bool %C, int* null, int* %G),
     // but it would not be valid if we transformed it to load from null
     // unconditionally.
     //
     if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
       // load (select (Cond, &V1, &V2))  --> select(Cond, load &V1, load &V2).
       unsigned Align = LI.getAlignment();
-      if (isSafeToLoadUnconditionally(SI->getOperand(1), Align, SI) &&
-          isSafeToLoadUnconditionally(SI->getOperand(2), Align, SI)) {
+      if (isSafeToLoadUnconditionally(SI->getOperand(1), Align, SI, DL) &&
+          isSafeToLoadUnconditionally(SI->getOperand(2), Align, SI, DL)) {
         LoadInst *V1 = Builder->CreateLoad(SI->getOperand(1),
                                            SI->getOperand(1)->getName()+".val");
         LoadInst *V2 = Builder->CreateLoad(SI->getOperand(2),
                                            SI->getOperand(2)->getName()+".val");
         V1->setAlignment(Align);
         V2->setAlignment(Align);
         return SelectInst::Create(SI->getCondition(), V1, V2);
       }

lib/Transforms/Scalar/SROA.cpp

     // If the predecessor has a single successor, then the edge isn't
     // critical.
     if (TI->getNumSuccessors() == 1)
       continue;
 
     // If this pointer is always safe to load, or if we can prove that there
     // is already a load in the block, then we can move the load to the pred
     // block.
-    if (isSafeToLoadUnconditionally(InVal, MaxAlign, TI))
+    if (isSafeToLoadUnconditionally(InVal, MaxAlign, TI, DL))
       continue;
 
     return false;
   }
 
   return true;
 }
 

   for (User *U : SI.users()) {
     LoadInst *LI = dyn_cast<LoadInst>(U);
     if (!LI || !LI->isSimple())
       return false;
 
     // Both operands to the select need to be dereferencable, either
     // absolutely (e.g. allocas) or at this point because we can see other
     // accesses to it.
-    if (!isSafeToLoadUnconditionally(TValue, LI->getAlignment(), LI))
+    if (!isSafeToLoadUnconditionally(TValue, LI->getAlignment(), LI, DL))
       return false;
-    if (!isSafeToLoadUnconditionally(FValue, LI->getAlignment(), LI))
+    if (!isSafeToLoadUnconditionally(FValue, LI->getAlignment(), LI, DL))
       return false;
   }
 
   return true;
 }
 
 static void speculateSelectInstLoads(SelectInst &SI) {
   DEBUG(dbgs() << "    original: " << SI << "\n");

lib/Transforms/Scalar/ScalarReplAggregates.cpp

 
   for (User *U : SI->users()) {
     LoadInst *LI = dyn_cast<LoadInst>(U);
     if (!LI || !LI->isSimple()) return false;
 
     // Both operands to the select need to be dereferencable, either absolutely
     // (e.g. allocas) or at this point because we can see other accesses to it.
     if (!isSafeToLoadUnconditionally(SI->getTrueValue(), LI->getAlignment(),
-                                     LI))
+                                     LI, DL))
       return false;
     if (!isSafeToLoadUnconditionally(SI->getFalseValue(), LI->getAlignment(),
-                                     LI))
+                                     LI, DL))
       return false;
   }
 
   return true;
 }
 
 /// isSafePHIToSpeculate - PHI instructions that use an alloca and are
 /// subsequently loaded can be rewritten to load both input pointers in the pred

       return false;
 
     // If the predecessor has a single successor, then the edge isn't critical.
     if (Pred->getTerminator()->getNumSuccessors() == 1)
       continue;
 
     // If this pointer is always safe to load, or if we can prove that there is
     // already a load in the block, then we can move the load to the pred block.
-    if (isSafeToLoadUnconditionally(InVal, MaxAlign, Pred->getTerminator()))
+    if (isSafeToLoadUnconditionally(InVal, MaxAlign, Pred->getTerminator(), DL))
       continue;
 
     return false;
   }
 
   return true;
 }
 

lib/Transforms/Scalar/TailRecursionElimination.cpp

bool TailCallElim::CanMoveAboveCall(Instruction *I, CallInst *CI) {
 
   if (LoadInst *L = dyn_cast<LoadInst>(I)) {
     // Loads may always be moved above calls without side effects.
     if (CI->mayHaveSideEffects()) {
       // Non-volatile loads may be moved above a call with side effects if it
       // does not write to memory and the load provably won't trap.
       // FIXME: Writes to memory only matter if they may alias the pointer
       // being loaded from.
+      const DataLayout &DL = L->getModule()->getDataLayout();
       if (CI->mayWriteToMemory() ||
           !isSafeToLoadUnconditionally(L->getPointerOperand(),
-                                       L->getAlignment(), L))
+                                       L->getAlignment(), L, DL))
         return false;
     }
   }
 
   // Otherwise, if this is a side-effect free instruction, check to make sure
   // that it does not use the return value of the call.  If it doesn't use the
   // return value of the call, it must only use things that are defined before
   // the call, or movable instructions between the call and the instruction