isSafeToLoadUnconditionally support queries without a context

[apilipenko]

Summary

This is required to use this function from isSafeToSpeculativelyExecute.

[hfinkel]

include/llvm/Analysis/Loads.h

37 ↗

(On Diff #45004)

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.

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

bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
                                         const DataLayout &DL,
                                         const Instruction *CtxI = nullptr,
                                         const DominatorTree *DT = nullptr,
                                         const TargetLibraryInfo *TLI = nullptr);
 
 /// isSafeToLoadUnconditionally - Return true if we know that executing a load
 /// from this value cannot trap.
 ///
-/// If DT is specified this method performs context-sensitive analysis.
+/// If DT and ScanFrom are specified this method performs context-sensitive
+/// analysis and returns true if it is safe to load immediately before 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,
+                                 Instruction *ScanFrom = nullptr,
                                  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

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 DT and ScanFrom are specified this method performs context-sensitive
+/// analysis and returns true if it is safe to load immediately before ScanFrom.
 ///
 /// 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,
+                                       const DataLayout &DL,
                                        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 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))
if (BaseType && BaseType->isSized()) {
     if (Align <= BaseAlign) {
       // Check if the load is within the bounds of the underlying object.
       if (ByteOffset + LoadSize <= DL.getTypeAllocSize(BaseType) &&
           ((ByteOffset % Align) == 0))
         return true;
     }
   }
 
+  if (!ScanFrom)
+    return false;
+
   // 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).
   BasicBlock::iterator BBI = ScanFrom->getIterator(),
                        E = ScanFrom->getParent()->begin();
 

llvm/trunk/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, DL, SI) &&
+          isSafeToLoadUnconditionally(SI->getOperand(2), Align, DL, SI)) {
         LoadInst *V1 = Builder->CreateLoad(SI->getOperand(1),
                                            SI->getOperand(1)->getName()+".val");
         LoadInst *V2 = Builder->CreateLoad(SI->getOperand(2),
                                            SI->getOperand(2)->getName()+".val");
         assert(LI.isUnordered() && "implied by above");
         V1->setAlignment(Align);
         V1->setAtomic(LI.getOrdering(), LI.getSynchScope());
         V2->setAlignment(Align);

llvm/trunk/lib/Transforms/Scalar/SROA.cpp

for (User *U : PN.users()) {
 
     MaxAlign = std::max(MaxAlign, LI->getAlignment());
     HaveLoad = true;
   }
 
   if (!HaveLoad)
     return false;
 
+  const DataLayout &DL = PN.getModule()->getDataLayout();
+
   // We can only transform this if it is safe to push the loads into the
   // predecessor blocks. The only thing to watch out for is that we can't put
   // a possibly trapping load in the predecessor if it is a critical edge.
   for (unsigned Idx = 0, Num = PN.getNumIncomingValues(); Idx != Num; ++Idx) {
     TerminatorInst *TI = PN.getIncomingBlock(Idx)->getTerminator();
     Value *InVal = PN.getIncomingValue(Idx);
 
     // If the value is produced by the terminator of the predecessor (an
     // invoke) or it has side-effects, there is no valid place to put a load
     // in the predecessor.
     if (TI == InVal || TI->mayHaveSideEffects())
       return false;
 
     // 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, DL, TI))
       continue;
 
     return false;
   }
 
   return true;
 }
 

 ///   %V2 = load i32* %Other
 ///   %V = select i1 %cond, i32 %V1, i32 %V2
 ///
 /// We can do this to a select if its only uses are loads and if the operand
 /// to the select can be loaded unconditionally.
 static bool isSafeSelectToSpeculate(SelectInst &SI) {
   Value *TValue = SI.getTrueValue();
   Value *FValue = SI.getFalseValue();
+  const DataLayout &DL = SI.getModule()->getDataLayout();
 
   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(), DL, LI))
       return false;
-    if (!isSafeToLoadUnconditionally(FValue, LI->getAlignment(), LI))
+    if (!isSafeToLoadUnconditionally(FValue, LI->getAlignment(), DL, LI))
       return false;
   }
 
   return true;
 }
 
 static void speculateSelectInstLoads(SelectInst &SI) {
   DEBUG(dbgs() << "    original: " << SI << "\n");

llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp

 /// to:
 ///   %V1 = load i32* %Alloca      -> will be mem2reg'd
 ///   %V2 = load i32* %Other
 ///   %V = select i1 %cond, i32 %V1, i32 %V2
 ///
 /// We can do this to a select if its only uses are loads and if the operand to
 /// the select can be loaded unconditionally.
 static bool isSafeSelectToSpeculate(SelectInst *SI) {
+  const DataLayout &DL = SI->getModule()->getDataLayout();
+
   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))
+                                     DL, LI))
       return false;
     if (!isSafeToLoadUnconditionally(SI->getFalseValue(), LI->getAlignment(),
-                                     LI))
+                                     DL, LI))
       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
for (User *U : PN->users()) {
     // could store.
     for (BasicBlock::iterator BBI(PN); &*BBI != LI; ++BBI)
       if (BBI->mayWriteToMemory())
         return false;
 
     MaxAlign = std::max(MaxAlign, LI->getAlignment());
   }
 
+  const DataLayout &DL = PN->getModule()->getDataLayout();
+
   // Okay, we know that we have one or more loads in the same block as the PHI.
   // We can transform this if it is safe to push the loads into the predecessor
   // blocks.  The only thing to watch out for is that we can't put a possibly
   // trapping load in the predecessor if it is a critical edge.
   for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
     BasicBlock *Pred = PN->getIncomingBlock(i);
     Value *InVal = PN->getIncomingValue(i);
 
     // If the terminator of the predecessor has side-effects (an invoke),
     // there is no safe place to put a load in the predecessor.
     if (Pred->getTerminator()->mayHaveSideEffects())
       return false;
 
     // If the value is produced by the terminator of the predecessor
     // (an invoke), there is no valid place to put a load in the predecessor.
     if (Pred->getTerminator() == InVal)
       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, DL, Pred->getTerminator()))
       continue;
 
     return false;
   }
 
   return true;
 }
 

llvm/trunk/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(), DL, L))
         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