Use isSafeToLoadUnconditionally in isSafeToSpeculativelyExecute

[hfinkel]

Seems reasonable. Do you have a test case, or at least an explanation for why you'd like to do this?

[apilipenko]

isSafeToLoadUnconditionally is more aggressive than isDereferenceableAndAlignedPointer. Besides calling isDereferenceable it scans the context BB to see if the location was loaded/stored before. So, with this change isSafeToSpeculativelyExecute callers will also benefit from BB scan. Although, so far in practice the only place where isSafeToSpeculativelyExecute is called with a context is LICM.

[reames]

Resigning from a stale review (2016). Feel free to re-add if thread ever revived.

lib/Analysis/ValueTracking.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"

         // Speculative load may create a race that did not exist in the source.
         LI->getParent()->getParent()->hasFnAttribute(
             Attribute::SanitizeThread) ||
         // Speculative load may load data from dirty regions.
         LI->getParent()->getParent()->hasFnAttribute(
             Attribute::SanitizeAddress))
       return false;
     const DataLayout &DL = LI->getModule()->getDataLayout();
-    return isDereferenceableAndAlignedPointer(
-        LI->getPointerOperand(), LI->getAlignment(), DL, CtxI, DT, TLI);
+    return 
+      isSafeToLoadUnconditionally(const_cast<Value*>(LI->getPointerOperand()),
+                                  LI->getAlignment(),
+                                  const_cast<Instruction*>(CtxI), DL, DT, TLI);
   }
   case Instruction::Call: {
     if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
       switch (II->getIntrinsicID()) {
       // These synthetic intrinsics have no side-effects and just mark
       // information about their operands.
       // FIXME: There are other no-op synthetic instructions that potentially
       // should be considered at least *safe* to speculate...