Analysis: Add AssumptionCache to isSafeToSpeculativelyExecute

[arsenm]

Summary

Does not update any of the uses.

[jdoerfert]

One nit to consider. LG

llvm/lib/Transforms/Scalar/GVN.cpp

1541

Might be worth to do /* AC */ nullptr but we don't do that consistently unfortunately.

[arsenm]

llvm/lib/Transforms/Scalar/GVN.cpp

1541

I'm queuing up patches to pass it through everywhere, so it won't stay like this long

[arsenm]

ce44357216ecb764b9613535abb72167a53f6faa

llvm/include/llvm/Analysis/ValueTracking.h

 /// itself and its operands, so if this method returns true, it is safe to
 /// move the instruction as long as the correct dominance relationships for
 /// the operands and users hold.
 ///
 /// This method can return true for instructions that read memory;
 /// for such instructions, moving them may change the resulting value.
 bool isSafeToSpeculativelyExecute(const Instruction *I,
                                   const Instruction *CtxI = nullptr,
+                                  AssumptionCache *AC = nullptr,
                                   const DominatorTree *DT = nullptr,
                                   const TargetLibraryInfo *TLI = nullptr);
 
 /// This returns the same result as isSafeToSpeculativelyExecute if Opcode is
 /// the actual opcode of Inst. If the provided and actual opcode differ, the
 /// function (virtually) overrides the opcode of Inst with the provided
 /// Opcode. There are come constraints in this case:
 /// * If Opcode has a fixed number of operands (eg, as binary operators do),
 ///   then Inst has to have at least as many leading operands. The function
 ///   will ignore all trailing operands beyond that number.
 /// * If Opcode allows for an arbitrary number of operands (eg, as CallInsts
 ///   do), then all operands are considered.
 /// * The virtual instruction has to satisfy all typing rules of the provided
 ///   Opcode.
 /// * This function is pessimistic in the following sense: If one actually
 ///   materialized the virtual instruction, then isSafeToSpeculativelyExecute
 ///   may say that the materialized instruction is speculatable whereas this
 ///   function may have said that the instruction wouldn't be speculatable.
 ///   This behavior is a shortcoming in the current implementation and not
 ///   intentional.
 bool isSafeToSpeculativelyExecuteWithOpcode(
     unsigned Opcode, const Instruction *Inst, const Instruction *CtxI = nullptr,
-    const DominatorTree *DT = nullptr, const TargetLibraryInfo *TLI = nullptr);
+    AssumptionCache *AC = nullptr, const DominatorTree *DT = nullptr,
+    const TargetLibraryInfo *TLI = nullptr);
 
 /// Returns true if the result or effects of the given instructions \p I
 /// depend values not reachable through the def use graph.
 /// * Memory dependence arises for example if the instruction reads from
 ///   memory or may produce effects or undefined behaviour. Memory dependent
 ///   instructions generally cannot be reorderd with respect to other memory
 ///   dependent instructions.
 /// * Control dependence arises for example if the instruction may fault

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::mustSuppressSpeculation(const LoadInst &LI) {
   return F.hasFnAttribute(Attribute::SanitizeThread) ||
     // Speculative load may load data from dirty regions.
     F.hasFnAttribute(Attribute::SanitizeAddress) ||
     F.hasFnAttribute(Attribute::SanitizeHWAddress);
 }
 
 bool llvm::isSafeToSpeculativelyExecute(const Instruction *Inst,
                                         const Instruction *CtxI,
+                                        AssumptionCache *AC,
                                         const DominatorTree *DT,
                                         const TargetLibraryInfo *TLI) {
   return isSafeToSpeculativelyExecuteWithOpcode(Inst->getOpcode(), Inst, CtxI,
-                                                DT, TLI);
+                                                AC, DT, TLI);
 }
 
 bool llvm::isSafeToSpeculativelyExecuteWithOpcode(
     unsigned Opcode, const Instruction *Inst, const Instruction *CtxI,
-    const DominatorTree *DT, const TargetLibraryInfo *TLI) {
+    AssumptionCache *AC, const DominatorTree *DT,
+    const TargetLibraryInfo *TLI) {
 #ifndef NDEBUG
   if (Inst->getOpcode() != Opcode) {
     // Check that the operands are actually compatible with the Opcode override.
     auto hasEqualReturnAndLeadingOperandTypes =
         [](const Instruction *Inst, unsigned NumLeadingOperands) {
           if (Inst->getNumOperands() < NumLeadingOperands)
             return false;
           const Type *ExpectedType = Inst->getType();
#endif
   }
   case Instruction::Load: {
     const LoadInst *LI = dyn_cast<LoadInst>(Inst);
     if (!LI)
       return false;
     if (mustSuppressSpeculation(*LI))
       return false;
     const DataLayout &DL = LI->getModule()->getDataLayout();
-    return isDereferenceableAndAlignedPointer(
-        LI->getPointerOperand(), LI->getType(), LI->getAlign(), DL, CtxI,
-        nullptr, // FIXME
-        DT, TLI);
+    return isDereferenceableAndAlignedPointer(LI->getPointerOperand(),
+                                              LI->getType(), LI->getAlign(), DL,
+                                              CtxI, AC, DT, TLI);
   }
   case Instruction::Call: {
     auto *CI = dyn_cast<const CallInst>(Inst);
     if (!CI)
       return false;
     const Function *Callee = CI->getCalledFunction();
 
     // The called function could have undefined behavior or side-effects, even

llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp

return isa<BinaryOperator>(I) || isa<CastInst>(I) || isa<SelectInst>(I) ||
       isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||
       isa<InsertValueInst>(I);
 }
 
 // Return true if the given instruction can be hoisted by CHR.
 static bool isHoistable(Instruction *I, DominatorTree &DT) {
   if (!isHoistableInstructionType(I))
     return false;
-  return isSafeToSpeculativelyExecute(I, nullptr, &DT);
+  return isSafeToSpeculativelyExecute(I, nullptr, nullptr, &DT);
 }
 
 // Recursively traverse the use-def chains of the given value and return a set
 // of the unhoistable base values defined within the scope (excluding the
 // first-region entry block) or the (hoistable or unhoistable) base values that
 // are defined outside (including the first-region entry block) of the
 // scope. The returned set doesn't include constants.
 static const std::set<Value *> &

llvm/lib/Transforms/Scalar/GVN.cpp

bool GVNPass::PerformLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock,
   // that one block.
   if (NumUnavailablePreds != 1)
       return false;
 
   // Now we know where we will insert load. We must ensure that it is safe
   // to speculatively execute the load at that points.
   if (MustEnsureSafetyOfSpeculativeExecution) {
     if (CriticalEdgePred.size())
-      if (!isSafeToSpeculativelyExecute(Load, LoadBB->getFirstNonPHI(), DT))
+      if (!isSafeToSpeculativelyExecute(Load, LoadBB->getFirstNonPHI(), nullptr,
+                                        DT))
         return false;
     for (auto &PL : PredLoads)
-      if (!isSafeToSpeculativelyExecute(Load, PL.first->getTerminator(), DT))
+      if (!isSafeToSpeculativelyExecute(Load, PL.first->getTerminator(),
+                                        nullptr, DT))
         return false;
   }
 
   // Split critical edges, and update the unavailable predecessors accordingly.
   for (BasicBlock *OrigPred : CriticalEdgePred) {
     BasicBlock *NewPred = splitCriticalEdges(OrigPred, LoadBB);
     assert(!PredLoads.count(OrigPred) && "Split edges shouldn't be in map!");
     PredLoads[NewPred] = nullptr;

llvm/lib/Transforms/Scalar/GuardWidening.cpp

static Value *getCondition(Instruction *I) {
   BasicBlock *IfTrueBB, *IfFalseBB;
   if (parseWidenableBranch(I, Cond, WC, IfTrueBB, IfFalseBB))
     return Cond;
 
   return cast<BranchInst>(I)->getCondition();
 }
 
 // Set the condition for \p I to \p NewCond. \p I can either be a guard or a
-// conditional branch.  
+// conditional branch.
 static void setCondition(Instruction *I, Value *NewCond) {
   if (IntrinsicInst *GI = dyn_cast<IntrinsicInst>(I)) {
     assert(GI->getIntrinsicID() == Intrinsic::experimental_guard &&
            "Bad guard intrinsic?");
     GI->setArgOperand(0, NewCond);
     return;
   }
   cast<BranchInst>(I)->setCondition(NewCond);
class GuardWideningImpl {
   }
 
   /// If \p InvertCondition is false, Widen \p ToWiden to fail if
   /// \p NewCondition is false, otherwise make it fail if \p NewCondition is
   /// true (in addition to whatever it is already checking).
   void widenGuard(Instruction *ToWiden, Value *NewCondition,
                   bool InvertCondition) {
     Value *Result;
-    
     widenCondCommon(getCondition(ToWiden), NewCondition, ToWiden, Result,
                     InvertCondition);
     if (isGuardAsWidenableBranch(ToWiden)) {
       setWidenableBranchCond(cast<BranchInst>(ToWiden), Result);
       return;
     }
     setCondition(ToWiden, Result);
   }

 
 bool GuardWideningImpl::isAvailableAt(
     const Value *V, const Instruction *Loc,
     SmallPtrSetImpl<const Instruction *> &Visited) const {
   auto *Inst = dyn_cast<Instruction>(V);
   if (!Inst || DT.dominates(Inst, Loc) || Visited.count(Inst))
     return true;
 
-  if (!isSafeToSpeculativelyExecute(Inst, Loc, &DT) ||
+  if (!isSafeToSpeculativelyExecute(Inst, Loc, nullptr, &DT) ||
       Inst->mayReadFromMemory())
     return false;
 
   Visited.insert(Inst);
 
   // We only want to go _up_ the dominance chain when recursing.
   assert(!isa<PHINode>(Loc) &&
          "PHIs should return false for isSafeToSpeculativelyExecute");
   assert(DT.isReachableFromEntry(Inst->getParent()) &&
          "We did a DFS from the block entry!");
   return all_of(Inst->operands(),
                 [&](Value *Op) { return isAvailableAt(Op, Loc, Visited); });
 }
 
 void GuardWideningImpl::makeAvailableAt(Value *V, Instruction *Loc) const {
   auto *Inst = dyn_cast<Instruction>(V);
   if (!Inst || DT.dominates(Inst, Loc))
     return;
 
-  assert(isSafeToSpeculativelyExecute(Inst, Loc, &DT) &&
+  assert(isSafeToSpeculativelyExecute(Inst, Loc, nullptr, &DT) &&
          !Inst->mayReadFromMemory() && "Should've checked with isAvailableAt!");
 
   for (Value *Op : Inst->operands())
     makeAvailableAt(Op, Loc);
 
   Inst->moveBefore(Loc);
   // If we moved instruction before guard we must clean poison generating flags.
   Inst->dropPoisonGeneratingFlags();

llvm/lib/Transforms/Scalar/LICM.cpp

 /// Only sink or hoist an instruction if it is not a trapping instruction,
 /// or if the instruction is known not to trap when moved to the preheader.
 /// or if it is a trapping instruction and is guaranteed to execute.
 static bool isSafeToExecuteUnconditionally(
     Instruction &Inst, const DominatorTree *DT, const TargetLibraryInfo *TLI,
     const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo,
     OptimizationRemarkEmitter *ORE, const Instruction *CtxI,
     bool AllowSpeculation) {
-  if (AllowSpeculation && isSafeToSpeculativelyExecute(&Inst, CtxI, DT, TLI))
+  if (AllowSpeculation &&
+      isSafeToSpeculativelyExecute(&Inst, CtxI, nullptr, DT, TLI))
     return true;
 
   bool GuaranteedToExecute =
       SafetyInfo->isGuaranteedToExecute(Inst, DT, CurLoop);
 
   if (!GuaranteedToExecute) {
     auto *LI = dyn_cast<LoadInst>(&Inst);
     if (LI && CurLoop->isLoopInvariant(LI->getPointerOperand()))