[IPT] Don't use OrderedInstructions (NFC)

[nikic]

Summary

Use Instruction::comesBefore() instead of OrderedInstructions inside InstructionPrecedenceTracking. This also removes the dominator tree dependency.

[fhahn]

LGTM, thanks!

[MaskRay]

include/llvm/Analysis/InstructionPrecedenceTracking.h

51–52

Delete the default constructor.

95–96

ditto

[nikic]

Remove trivial constructors.

[nikic]

Remove one more constructor...

[MaskRay]

LGTM.

include/llvm/Analysis/InstructionPrecedenceTracking.h

 // The class provides caching that allows to answer these queries quickly. The
 // user must make sure that the cached data is invalidated properly whenever
 // a content of some tracked block is changed.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_INSTRUCTIONPRECEDENCETRACKING_H
 #define LLVM_ANALYSIS_INSTRUCTIONPRECEDENCETRACKING_H
 
-#include "llvm/IR/Dominators.h"
-#include "llvm/Analysis/OrderedInstructions.h"
+#include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
+class BasicBlock;
+class Instruction;
+
 class InstructionPrecedenceTracking {
   // Maps a block to the topmost special instruction in it. If the value is
   // nullptr, it means that it is known that this block does not contain any
   // special instructions.
   DenseMap<const BasicBlock *, const Instruction *> FirstSpecialInsts;
-  // Allows to answer queries about precedence of instructions within one block.
-  OrderedInstructions OI;
 
   // Fills information about the given block's special instructions.
   void fill(const BasicBlock *BB);
 
 #ifndef NDEBUG
   /// Asserts that the cached info for \p BB is up-to-date. This helps to catch
   /// the usage error of accessing a block without properly invalidating after a
   /// previous transform.
   void validate(const BasicBlock *BB) const;
 
   /// Asserts whether or not the contents of this tracking is up-to-date. This
   /// helps to catch the usage error of accessing a block without properly
   /// invalidating after a previous transform.
   void validateAll() const;
 #endif
 
 protected:
-  InstructionPrecedenceTracking(DominatorTree *DT)
-      : OI(OrderedInstructions(DT)) {}
-
   /// Returns the topmost special instruction from the block \p BB. Returns
   /// nullptr if there is no special instructions in the block.
   const Instruction *getFirstSpecialInstruction(const BasicBlock *BB);
 
   /// Returns true iff at least one instruction from the basic block \p BB is
   /// special.
   bool hasSpecialInstructions(const BasicBlock *BB);
 
   /// Returns true iff the first special instruction of \p Insn's block exists

 /// This class allows to keep track on instructions with implicit control flow.
 /// These are instructions that may not pass execution to their successors. For
 /// example, throwing calls and guards do not always do this. If we need to know
 /// for sure that some instruction is guaranteed to execute if the given block
 /// is reached, then we need to make sure that there is no implicit control flow
 /// instruction (ICFI) preceding it. For example, this check is required if we
 /// perform PRE moving non-speculable instruction to other place.
 class ImplicitControlFlowTracking : public InstructionPrecedenceTracking {
 public:
-  ImplicitControlFlowTracking(DominatorTree *DT)
-      : InstructionPrecedenceTracking(DT) {}
-
   /// Returns the topmost instruction with implicit control flow from the given
   /// basic block. Returns nullptr if there is no such instructions in the block.
   const Instruction *getFirstICFI(const BasicBlock *BB) {
     return getFirstSpecialInstruction(BB);
   }
 
   /// Returns true if at least one instruction from the given basic block has
   /// implicit control flow.
   bool hasICF(const BasicBlock *BB) {
     return hasSpecialInstructions(BB);
   }
 
   /// Returns true if the first ICFI of Insn's block exists and dominates Insn.
   bool isDominatedByICFIFromSameBlock(const Instruction *Insn) {
     return isPreceededBySpecialInstruction(Insn);
   }
 
   virtual bool isSpecialInstruction(const Instruction *Insn) const;
 };
 
 class MemoryWriteTracking : public InstructionPrecedenceTracking {
 public:
-  MemoryWriteTracking(DominatorTree *DT) : InstructionPrecedenceTracking(DT) {}
-
   /// Returns the topmost instruction that may write memory from the given
   /// basic block. Returns nullptr if there is no such instructions in the block.
   const Instruction *getFirstMemoryWrite(const BasicBlock *BB) {
     return getFirstSpecialInstruction(BB);
   }
 
   /// Returns true if at least one instruction from the given basic block may
   /// write memory.

include/llvm/Analysis/MustExecute.h

public:
   virtual bool anyBlockMayThrow() const;
 
   virtual void computeLoopSafetyInfo(const Loop *CurLoop);
 
   virtual bool isGuaranteedToExecute(const Instruction &Inst,
                                      const DominatorTree *DT,
                                      const Loop *CurLoop) const;
 
-  SimpleLoopSafetyInfo() : LoopSafetyInfo() {};
-
   virtual ~SimpleLoopSafetyInfo() {};
 };
 
 /// This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to
 /// give precise answers on "may throw" queries. This implementation uses cache
 /// that should be invalidated by calling the methods insertInstructionTo and
 /// removeInstruction whenever we modify a basic block's contents by adding or
 /// removing instructions.
public:
   /// it correct after this insertion.
   void insertInstructionTo(const Instruction *Inst, const BasicBlock *BB);
 
   /// Inform safety info that we are planning to remove the instruction \p Inst
   /// from its block. It will make all cache updates to keep it correct after
   /// this removal.
   void removeInstruction(const Instruction *Inst);
 
-  ICFLoopSafetyInfo(DominatorTree *DT) : LoopSafetyInfo(), ICF(DT), MW(DT) {};
+  ICFLoopSafetyInfo() : LoopSafetyInfo() {};
 
   virtual ~ICFLoopSafetyInfo() {};
 };
 
 bool mayContainIrreducibleControl(const Function &F, const LoopInfo *LI);
 
 struct MustBeExecutedContextExplorer;
 

lib/Analysis/InstructionPrecedenceTracking.cpp

bool InstructionPrecedenceTracking::hasSpecialInstructions(
     const BasicBlock *BB) {
   return getFirstSpecialInstruction(BB) != nullptr;
 }
 
 bool InstructionPrecedenceTracking::isPreceededBySpecialInstruction(
     const Instruction *Insn) {
   const Instruction *MaybeFirstSpecial =
       getFirstSpecialInstruction(Insn->getParent());
-  return MaybeFirstSpecial && OI.dominates(MaybeFirstSpecial, Insn);
+  return MaybeFirstSpecial && MaybeFirstSpecial->comesBefore(Insn);
 }
 
 void InstructionPrecedenceTracking::fill(const BasicBlock *BB) {
   FirstSpecialInsts.erase(BB);
   for (auto &I : *BB)
     if (isSpecialInstruction(&I)) {
       FirstSpecialInsts[BB] = &I;
       return;

lib/Transforms/Scalar/GVN.cpp

bool GVN::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
                   MemoryDependenceResults *RunMD, LoopInfo *LI,
                   OptimizationRemarkEmitter *RunORE) {
   AC = &RunAC;
   DT = &RunDT;
   VN.setDomTree(DT);
   TLI = &RunTLI;
   VN.setAliasAnalysis(&RunAA);
   MD = RunMD;
-  ImplicitControlFlowTracking ImplicitCFT(DT);
+  ImplicitControlFlowTracking ImplicitCFT;
   ICF = &ImplicitCFT;
   this->LI = LI;
   VN.setMemDep(MD);
   ORE = RunORE;
   InvalidBlockRPONumbers = true;
 
   bool Changed = false;
   bool ShouldContinue = true;

lib/Transforms/Scalar/LICM.cpp

for (auto *BB : L->getBlocks()) {
         break;
     }
   }
 
   // Get the preheader block to move instructions into...
   BasicBlock *Preheader = L->getLoopPreheader();
 
   // Compute loop safety information.
-  ICFLoopSafetyInfo SafetyInfo(DT);
+  ICFLoopSafetyInfo SafetyInfo;
   SafetyInfo.computeLoopSafetyInfo(L);
 
   // We want to visit all of the instructions in this loop... that are not parts
   // of our subloops (they have already had their invariants hoisted out of
   // their loop, into this loop, so there is no need to process the BODIES of
   // the subloops).
   //
   // Traverse the body of the loop in depth first order on the dominator tree so