[PredicateInfo] Use new Instruction::comesBefore instead of OI (NFC).

[fhahn]

Summary

The recently added Instruction::comesBefore can be used instead of
maintaining a separate odereding in OrderedInstructions.

[nikic]

LGTM

The recently added Instruction::comesBefore can be used instead of
maintaining a separate odereding in OrderedInstructions.

To be clear, OrderedInstructions does not maintain a separate ordering anymore, it's just a thin wrapper around Instruction::comesBefore() (for the local case, which is the only thing we're using here.)

llvm/lib/Transforms/Utils/PredicateInfo.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CFG.h"
-#include "llvm/Analysis/OrderedInstructions.h"
 #include "llvm/IR/AssemblyAnnotationWriter.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
struct ValueDFS {
   Value *Def = nullptr;
   Use *U = nullptr;
   // Neither PInfo nor EdgeOnly participate in the ordering
   PredicateBase *PInfo = nullptr;
   bool EdgeOnly = false;
 };
 
 // Perform a strict weak ordering on instructions and arguments.
-static bool valueComesBefore(OrderedInstructions &OI, const Value *A,
-                             const Value *B) {
+static bool valueComesBefore(const Value *A, const Value *B) {
   auto *ArgA = dyn_cast_or_null<Argument>(A);
   auto *ArgB = dyn_cast_or_null<Argument>(B);
   if (ArgA && !ArgB)
     return true;
   if (ArgB && !ArgA)
     return false;
   if (ArgA && ArgB)
     return ArgA->getArgNo() < ArgB->getArgNo();
-  return OI.dfsBefore(cast<Instruction>(A), cast<Instruction>(B));
+  return cast<Instruction>(A)->comesBefore(cast<Instruction>(B));
 }
 
-// This compares ValueDFS structures, creating OrderedBasicBlocks where
-// necessary to compare uses/defs in the same block.  Doing so allows us to walk
-// the minimum number of instructions necessary to compute our def/use ordering.
+// This compares ValueDFS structures. Doing so allows us to walk the minimum
+// number of instructions necessary to compute our def/use ordering.
 struct ValueDFS_Compare {
   DominatorTree &DT;
-  OrderedInstructions &OI;
-  ValueDFS_Compare(DominatorTree &DT, OrderedInstructions &OI)
-      : DT(DT), OI(OI) {}
+  ValueDFS_Compare(DominatorTree &DT) : DT(DT) {}
 
   bool operator()(const ValueDFS &A, const ValueDFS &B) const {
     if (&A == &B)
       return false;
     // The only case we can't directly compare them is when they in the same
     // block, and both have localnum == middle.  In that case, we have to use
     // comesbefore to see what the real ordering is, because they are in the
     // same basic block.
bool localComesBefore(const ValueDFS &A, const ValueDFS &B) const {
 
     // See if we have real values or uses. If we have real values, we are
     // guaranteed they are instructions or arguments. No matter what, we are
     // guaranteed they are in the same block if they are instructions.
     auto *ArgA = dyn_cast_or_null<Argument>(ADef);
     auto *ArgB = dyn_cast_or_null<Argument>(BDef);
 
     if (ArgA || ArgB)
-      return valueComesBefore(OI, ArgA, ArgB);
+      return valueComesBefore(ArgA, ArgB);
 
     auto *AInst = getDefOrUser(ADef, A.U);
     auto *BInst = getDefOrUser(BDef, B.U);
-    return valueComesBefore(OI, AInst, BInst);
+    return valueComesBefore(AInst, BInst);
   }
 };
 
 class PredicateInfoBuilder {
   // Used to store information about each value we might rename.
   struct ValueInfo {
     SmallVector<PredicateBase *, 4> Infos;
   };
 
   PredicateInfo &PI;
   Function &F;
   DominatorTree &DT;
   AssumptionCache &AC;
-  OrderedInstructions OI;
 
   // This stores info about each operand or comparison result we make copies
   // of. The real ValueInfos start at index 1, index 0 is unused so that we
   // can more easily detect invalid indexing.
   SmallVector<ValueInfo, 32> ValueInfos;
 
   // This gives the index into the ValueInfos array for a given Value. Because
   // 0 is not a valid Value Info index, you can use DenseMap::lookup and tell
class PredicateInfoBuilder {
   void convertUsesToDFSOrdered(Value *, SmallVectorImpl<ValueDFS> &);
   Value *materializeStack(unsigned int &, ValueDFSStack &, Value *);
   bool stackIsInScope(const ValueDFSStack &, const ValueDFS &) const;
   void popStackUntilDFSScope(ValueDFSStack &, const ValueDFS &);
 
 public:
   PredicateInfoBuilder(PredicateInfo &PI, Function &F, DominatorTree &DT,
                        AssumptionCache &AC)
-      : PI(PI), F(F), DT(DT), AC(AC), OI(&DT) {
+      : PI(PI), F(F), DT(DT), AC(AC) {
     // Push an empty operand info so that we can detect 0 as not finding one
     ValueInfos.resize(1);
   }
 
   void buildPredicateInfo();
 };
 
 bool PredicateInfoBuilder::stackIsInScope(const ValueDFSStack &Stack,

 // propagating liveness info, we don't actually insert the predicateinfo
 // instruction def until we see a use that it would dominate.  Once we see such
 // a use, we materialize the predicateinfo instruction in the right place and
 // use it.
 //
 // TODO: Use this algorithm to perform fast single-variable renaming in
 // promotememtoreg and memoryssa.
 void PredicateInfoBuilder::renameUses(SmallVectorImpl<Value *> &OpsToRename) {
-  ValueDFS_Compare Compare(DT, OI);
+  ValueDFS_Compare Compare(DT);
   // Compute liveness, and rename in O(uses) per Op.
   for (auto *Op : OpsToRename) {
     LLVM_DEBUG(dbgs() << "Visiting " << *Op << "\n");
     unsigned Counter = 0;
     SmallVector<ValueDFS, 16> OrderedUses;
     const auto &ValueInfo = getValueInfo(Op);
     // Insert the possible copies into the def/use list.
     // They will become real copies if we find a real use for them, and never