[GVN] MemorySSA for GVN: remove all mention of MemDep from GVN

[mkazantsev]

This patch has dependencies that haven't been reviewed yet, nor any reviewers assigned to them. Marking as "request changes" just to hide it from my list, until all underlying patches have been merged or at least approved. Feel free to request again when they're in and the context of this change is clear.

[chill]

This is still a couple of months away from committing.

[mkazantsev]

I don't understand what's going on here and not sure if I can give any useful feedback.

llvm/include/llvm/Transforms/Scalar/GVN.h

 class CallInst;
 class ExtractValueInst;
 class Function;
 class FunctionPass;
 class GetElementPtrInst;
 class ImplicitControlFlowTracking;
 class LoadInst;
 class LoopInfo;
-class MemDepResult;
 class MemoryAccess;
-class MemoryDependenceResults;
 class MemoryLocation;
 class MemorySSA;
 class MemorySSAUpdater;
 class NonLocalDepResult;
 class OptimizationRemarkEmitter;
 class PHINode;
 class TargetLibraryInfo;
 class Value;

 ///      None - relying on a global default.
 /// Intended use is to create a default object, modify parameters with
 /// additional setters and then pass it to GVN.
 struct GVNOptions {
   Optional<bool> AllowPRE = None;
   Optional<bool> AllowLoadPRE = None;
   Optional<bool> AllowLoadInLoopPRE = None;
   Optional<bool> AllowLoadPRESplitBackedge = None;
-  Optional<bool> AllowMemDep = None;
   Optional<bool> AllowMemorySSA = None;
 
   GVNOptions() = default;
 
   /// Enables or disables PRE in GVN.
   GVNOptions &setPRE(bool PRE) {
     AllowPRE = PRE;
     return *this;
struct GVNOptions {
   }
 
   /// Enables or disables PRE of loads in GVN.
   GVNOptions &setLoadPRESplitBackedge(bool LoadPRESplitBackedge) {
     AllowLoadPRESplitBackedge = LoadPRESplitBackedge;
     return *this;
   }
 
-  /// Enables or disables use of MemDepAnalysis.
-  GVNOptions &setMemDep(bool MemDep) {
-    AllowMemDep = MemDep;
-    return *this;
-  }
-
   /// Enables or disables use of MemorySSA.
   GVNOptions &setMemorySSA(bool MemSSA) {
     AllowMemorySSA = MemSSA;
     return *this;
   }
 };
 
 /// The core GVN pass object.
public:
   /// our various maps and marks it for deletion.
   void markInstructionForDeletion(Instruction *I) {
     VN.erase(I);
     InstrsToErase.push_back(I);
   }
 
   DominatorTree &getDominatorTree() const { return *DT; }
   AAResults *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
-  MemoryDependenceResults &getMemDep() const { return *MD; }
 
   bool isPREEnabled() const;
   bool isLoadPREEnabled() const;
   bool isLoadInLoopPREEnabled() const;
   bool isLoadPRESplitBackedgeEnabled() const;
-  bool isMemDepEnabled() const;
   bool isMemorySSAEnabled() const;
 
   /// This class holds the mapping between values and value numbers.  It is used
   /// as an efficient mechanism to determine the expression-wise equivalence of
   /// two values.
   class ValueTable {
     DenseMap<Value *, uint32_t> valueNumbering;
     DenseMap<Expression, uint32_t> expressionNumbering;
class ValueTable {
     DenseMap<uint32_t, BasicBlock *> NumberingBB;
 
     // Cache for phi-translate in scalarpre.
     using PhiTranslateMap =
         DenseMap<std::pair<uint32_t, const BasicBlock *>, uint32_t>;
     PhiTranslateMap PhiTranslateTable;
 
     AAResults *AA = nullptr;
-    MemoryDependenceResults *MD = nullptr;
     MemorySSA *MSSA = nullptr;
     DominatorTree *DT = nullptr;
 
     uint32_t nextValueNumber = 1;
 
     Expression createExpr(Instruction *I);
     Expression createCmpExpr(unsigned Opcode, CmpInst::Predicate Predicate,
                              Value *LHS, Value *RHS);
uint32_t phiTranslate(const BasicBlock *BB, const BasicBlock *PhiBlock,
                           uint32_t Num, GVNPass &Gvn);
     void eraseTranslateCacheEntry(uint32_t Num, const BasicBlock &CurrBlock);
     bool exists(Value *V) const;
     void add(Value *V, uint32_t num);
     void clear();
     void erase(Value *v);
     void setAliasAnalysis(AAResults *A) { AA = A; }
     AAResults *getAliasAnalysis() const { return AA; }
-    void setMemDep(MemoryDependenceResults *M) { MD = M; }
     void setMemorySSA(MemorySSA *M) { MSSA = M; }
     void setDomTree(DominatorTree *D) { DT = D; }
     uint32_t getNextUnusedValueNumber() { return nextValueNumber; }
     void verifyRemoved(const Value *) const;
   };
 
 private:
   friend class gvn::GVNLegacyPass;
   friend struct DenseMapInfo<Expression>;
 
-  MemoryDependenceResults *MD = nullptr;
   DominatorTree *DT = nullptr;
   const TargetLibraryInfo *TLI = nullptr;
   AssumptionCache *AC = nullptr;
   SetVector<BasicBlock *> DeadBlocks;
   OptimizationRemarkEmitter *ORE = nullptr;
   ImplicitControlFlowTracking *ICF = nullptr;
   LoopInfo *LI = nullptr;
   AAResults *AA = nullptr;
private:
   // of BlockRPONumber prior to accessing the contents of BlockRPONumber.
   bool InvalidBlockRPONumbers = true;
 
   using LoadDepVect = SmallVector<NonLocalDepResult, 64>;
   using AvailValInBlkVect = SmallVector<gvn::AvailableValueInBlock, 64>;
   using UnavailBlkVect = SmallVector<BasicBlock *, 64>;
 
   bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
-               const TargetLibraryInfo &RunTLI, AAResults &RunAA,
-               MemoryDependenceResults *RunMD, LoopInfo *LI,
+               const TargetLibraryInfo &RunTLI, AAResults &RunAA, LoopInfo *LI,
                OptimizationRemarkEmitter *ORE, MemorySSA *MSSA = nullptr);
 
   /// Push a new Value to the LeaderTable onto the list for its value number.
   void addToLeaderTable(uint32_t N, Value *V, const BasicBlock *BB) {
     LeaderTableEntry &Curr = LeaderTable[N];
     if (!Curr.Val) {
       Curr.Val = V;
       Curr.BB = BB;
Optional<ReachingMemVal> findReachingValueForLoadInBlock(
       Instruction *DomLower, Instruction *DomUpper, MemoryAccess *ClobberMA,
       MemorySSA &MSSA, BatchAAResults &AA);
 
   bool findReachingValuesForLoad(LoadInst *Inst, MemorySSA &MSSA, AAResults &AA,
                                  SmallVectorImpl<ReachingMemVal> &Values);
 
   // Helper functions of redundant load elimination
   bool processLoad(LoadInst *L);
-  bool processNonLocalLoad(LoadInst *L);
   bool processNonLocalLoad(LoadInst *L, SmallVectorImpl<ReachingMemVal> &Deps);
   bool processAssumeIntrinsic(AssumeInst *II);
 
   /// Given a local dependency (Def or Clobber) determine if a value is
   /// available for the load.  Returns true if an value is known to be
   /// available and populates Res.  Returns false otherwise.
   bool AnalyzeLoadAvailability(LoadInst *Load, const ReachingMemVal &Dep,
                                Value *Address, gvn::AvailableValue &Res);

llvm/lib/Passes/PassBuilder.cpp

while (!Params.empty()) {
 
     bool Enable = !ParamName.consume_front("no-");
     if (ParamName == "pre") {
       Result.setPRE(Enable);
     } else if (ParamName == "load-pre") {
       Result.setLoadPRE(Enable);
     } else if (ParamName == "split-backedge-load-pre") {
       Result.setLoadPRESplitBackedge(Enable);
-    } else if (ParamName == "memdep") {
-      Result.setMemDep(Enable);
     } else if (ParamName == "memoryssa") {
       Result.setMemorySSA(Enable);
     } else {
       return make_error<StringError>(
           formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
           inconvertibleErrorCode());
     }
   }

llvm/lib/Transforms/Scalar/GVN.cpp

 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/DomTreeUpdater.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InstructionPrecedenceTracking.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
-#include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/Analysis/MemorySSA.h"
 #include "llvm/Analysis/MemorySSAUpdater.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/PHITransAddr.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
void GVNPass::ValueTable::addMemoryStateArg(Instruction *I, Expression &E) {
   assert(MSSA && "Function should not be called without MemorySSA");
   assert(MSSA->getMemoryAccess(I) && "Instruction does not access memory");
   MemoryAccess *MA = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(I);
   E.varargs.push_back(lookupOrAdd(MA));
 }
 
 uint32_t GVNPass::ValueTable::lookupOrAddCall(CallInst *C) {
   if (AA->doesNotAccessMemory(C)) {
-    Expression exp = createCallExpr(C);
-    uint32_t e = assignExpNewValueNum(exp).first;
-    valueNumbering[C] = e;
-    return e;
+    Expression Exp = createCallExpr(C);
+    uint32_t E = assignExpNewValueNum(Exp).first;
+    valueNumbering[C] = E;
+    return E;
   }
 
-  if (MSSA) {
-    if (AA->onlyReadsMemory(C)) {
-      Expression E = createCallExpr(C);
-      addMemoryStateArg(C, E);
-      uint32_t VN = assignExpNewValueNum(E).first;
-      valueNumbering[C] = VN;
-      return VN;
-    }
-    valueNumbering[C] = nextValueNumber;
-    return nextValueNumber++;
-  }
+  if (MSSA && AA->onlyReadsMemory(C)) {
 
-  if (MD && AA->onlyReadsMemory(C)) {
-    Expression exp = createCallExpr(C);
-    auto ValNum = assignExpNewValueNum(exp);
-    if (ValNum.second) {
-      valueNumbering[C] = ValNum.first;
-      return ValNum.first;
-    }
-
-    MemDepResult local_dep = MD->getDependency(C);
-
-    if (!local_dep.isDef() && !local_dep.isNonLocal()) {
-      valueNumbering[C] =  nextValueNumber;
-      return nextValueNumber++;
-    }
-
-    if (local_dep.isDef()) {
-      // For masked load/store intrinsics, the local_dep may actully be
-      // a normal load or store instruction.
-      CallInst *local_cdep = dyn_cast<CallInst>(local_dep.getInst());
-
-      if (!local_cdep || local_cdep->arg_size() != C->arg_size()) {
-        valueNumbering[C] = nextValueNumber;
-        return nextValueNumber++;
-      }
-
-      for (unsigned i = 0, e = C->arg_size(); i < e; ++i) {
-        uint32_t c_vn = lookupOrAdd(C->getArgOperand(i));
-        uint32_t cd_vn = lookupOrAdd(local_cdep->getArgOperand(i));
-        if (c_vn != cd_vn) {
-          valueNumbering[C] = nextValueNumber;
-          return nextValueNumber++;
-        }
-      }
-
-      uint32_t v = lookupOrAdd(local_cdep);
-      valueNumbering[C] = v;
-      return v;
-    }
-
-    // Non-local case.
-    const MemoryDependenceResults::NonLocalDepInfo &deps =
-        MD->getNonLocalCallDependency(C);
-    // FIXME: Move the checking logic to MemDep!
-    CallInst* cdep = nullptr;
-
-    // Check to see if we have a single dominating call instruction that is
-    // identical to C.
-    for (unsigned i = 0, e = deps.size(); i != e; ++i) {
-      const NonLocalDepEntry *I = &deps[i];
-      if (I->getResult().isNonLocal())
-        continue;
-
-      // We don't handle non-definitions.  If we already have a call, reject
-      // instruction dependencies.
-      if (!I->getResult().isDef() || cdep != nullptr) {
-        cdep = nullptr;
-        break;
-      }
-
-      CallInst *NonLocalDepCall = dyn_cast<CallInst>(I->getResult().getInst());
-      // FIXME: All duplicated with non-local case.
-      if (NonLocalDepCall && DT->properlyDominates(I->getBB(), C->getParent())){
-        cdep = NonLocalDepCall;
-        continue;
-      }
-
-      cdep = nullptr;
-      break;
-    }
-
-    if (!cdep) {
-      valueNumbering[C] = nextValueNumber;
-      return nextValueNumber++;
-    }
-
-    if (cdep->arg_size() != C->arg_size()) {
-      valueNumbering[C] = nextValueNumber;
-      return nextValueNumber++;
-    }
-    for (unsigned i = 0, e = C->arg_size(); i < e; ++i) {
-      uint32_t c_vn = lookupOrAdd(C->getArgOperand(i));
-      uint32_t cd_vn = lookupOrAdd(cdep->getArgOperand(i));
-      if (c_vn != cd_vn) {
-        valueNumbering[C] = nextValueNumber;
-        return nextValueNumber++;
-      }
-    }
-
-    uint32_t v = lookupOrAdd(cdep);
-    valueNumbering[C] = v;
-    return v;
-  } else {
-    valueNumbering[C] = nextValueNumber;
-    return nextValueNumber++;
-  }
-}
-
 uint32_t GVNPass::ValueTable::lookupOrAddLoadStore(Instruction *I) {
   if (MSSA == nullptr) {
     valueNumbering[I] = nextValueNumber;
     return nextValueNumber++;
   }
 
   Expression E;
   E.type = I->getType();
bool GVNPass::isLoadInLoopPREEnabled() const {
   return Options.AllowLoadInLoopPRE.value_or(GVNEnableLoadInLoopPRE);
 }
 
 bool GVNPass::isLoadPRESplitBackedgeEnabled() const {
   return Options.AllowLoadPRESplitBackedge.value_or(
       GVNEnableSplitBackedgeInLoadPRE);
 }
 
-bool GVNPass::isMemDepEnabled() const {
-  return Options.AllowMemDep.value_or(GVNEnableMemDep);
-}
-
 bool GVNPass::isMemorySSAEnabled() const {
   return Options.AllowMemorySSA.getValueOr(GVNEnableMemorySSA);
 }
 
 PreservedAnalyses GVNPass::run(Function &F, FunctionAnalysisManager &AM) {
   // FIXME: The order of evaluation of these 'getResult' calls is very
   // significant! Re-ordering these variables will cause GVN when run alone to
   // be less effective! We should fix memdep and basic-aa to not exhibit this
   // behavior, but until then don't change the order here.
   auto &AC = AM.getResult<AssumptionAnalysis>(F);
   auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
   auto &AA = AM.getResult<AAManager>(F);
-  auto *MemDep =
-      isMemDepEnabled() ? &AM.getResult<MemoryDependenceAnalysis>(F) : nullptr;
   auto *LI = AM.getCachedResult<LoopAnalysis>(F);
   auto *MSSA =
       isMemorySSAEnabled() ? &AM.getResult<MemorySSAAnalysis>(F) : nullptr;
   auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);
-  bool Changed = runImpl(F, AC, DT, TLI, AA, MemDep, LI, &ORE,
-                         MSSA ? &MSSA->getMSSA() : nullptr);
+  bool Changed =
+      runImpl(F, AC, DT, TLI, AA, LI, &ORE, MSSA ? &MSSA->getMSSA() : nullptr);
   if (!Changed)
     return PreservedAnalyses::all();
   PreservedAnalyses PA;
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<TargetLibraryAnalysis>();
   if (MSSA)
     PA.preserve<MemorySSAAnalysis>();
   if (LI)
void GVNPass::printPipeline(
   OS << "<";
   if (Options.AllowPRE != None)
     OS << (Options.AllowPRE.getValue() ? "" : "no-") << "pre;";
   if (Options.AllowLoadPRE != None)
     OS << (Options.AllowLoadPRE.getValue() ? "" : "no-") << "load-pre;";
   if (Options.AllowLoadPRESplitBackedge != None)
     OS << (Options.AllowLoadPRESplitBackedge.getValue() ? "" : "no-")
        << "split-backedge-load-pre;";
-  if (Options.AllowMemDep != None)
-    OS << (Options.AllowMemDep.getValue() ? "" : "no-") << "memdep;";
   if (Options.AllowMemorySSA != None)
     OS << (Options.AllowMemorySSA.getValue() ? "" : "no-") << "memoryssa";
   OS << ">";
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void GVNPass::dump(DenseMap<uint32_t, Value *> &d) const {
   errs() << "{\n";
if (CoercedLoad->getType() == LoadTy && Offset == 0) {
       Res = CoercedLoad;
     } else {
       Res = getLoadValueForLoad(CoercedLoad, Offset, LoadTy, InsertPt, DL);
       // We would like to use gvn.markInstructionForDeletion here, but we can't
       // because the load is already memoized into the leader map table that GVN
       // tracks.  It is potentially possible to remove the load from the table,
       // but then there all of the operations based on it would need to be
       // rehashed.  Just leave the dead load around.
-      if (gvn.isMemDepEnabled())
-        gvn.getMemDep().removeInstruction(CoercedLoad);
       LLVM_DEBUG(dbgs() << "GVN COERCED NONLOCAL LOAD:\nOffset: " << Offset
                         << "  " << *getCoercedLoadValue() << '\n'
                         << *Res << '\n'
                         << "\n\n\n");
     }
   } else if (isMemIntrinValue()) {
     Res = getMemInstValueForLoad(getMemIntrinValue(), Offset, LoadTy,
                                  InsertPt, DL);
if (Dep.Kind == DepKind::Clobber) {
     if (LoadInst *DepLoad = dyn_cast<LoadInst>(DepInst)) {
       // If this is a clobber and L is the first instruction in its block, then
       // we have the first instruction in the entry block.
       // Can't forward from non-atomic to atomic without violating memory model.
       if (DepLoad != Load && Address &&
           Load->isAtomic() <= DepLoad->isAtomic()) {
         Type *LoadType = Load->getType();
         int Offset = Dep.Offset;
-        if (MD) {
-          // If MD reported clobber, check it was nested.
-          if (canCoerceMustAliasedValueToLoad(DepLoad, LoadType, DL)) {
-            const auto ClobberOff = MD->getClobberOffset(DepLoad);
-            // GVN has no deal with a negative offset.
-            Offset = (ClobberOff == None || *ClobberOff < 0) ? -1 : *ClobberOff;
-          }
-        } else {
-          if (!canCoerceMustAliasedValueToLoad(DepLoad, LoadType, DL) ||
-              Offset < 0)
-            Offset = -1;
-        }
         if (Offset == -1)
           Offset =
               analyzeLoadFromClobberingLoad(LoadType, Address, DepLoad, DL);
         if (Offset != -1) {
           Res = AvailableValue::getLoad(DepLoad, Offset);
           return true;
         }
       }
for (const auto &AvailableLoad : AvailableLoads) {
     // load now lives in a different BB, and we want to avoid a jumpy line
     // table.
     // FIXME: How do we retain source locations without causing poor debugging
     // behavior?
 
     // Add the newly created load.
     ValuesPerBlock.push_back(
         AvailableValueInBlock::get(UnavailableBlock, NewLoad));
-    if (MD)
-      MD->invalidateCachedPointerInfo(LoadPtr);
     LLVM_DEBUG(dbgs() << "GVN INSERTED " << *NewLoad << '\n');
   }
 
   // Perform PHI construction.
   Value *V = ConstructSSAForLoadSet(Load, ValuesPerBlock, *this);
   Load->replaceAllUsesWith(V);
   if (isa<PHINode>(V))
     V->takeName(Load);
   if (Instruction *I = dyn_cast<Instruction>(V))
     I->setDebugLoc(Load->getDebugLoc());
-  if (MD && V->getType()->isPtrOrPtrVectorTy())
-    MD->invalidateCachedPointerInfo(V);
   markInstructionForDeletion(Load);
   ORE->emit([&]() {
     return OptimizationRemark(DEBUG_TYPE, "LoadPRE", Load)
            << "load eliminated by PRE";
   });
 }
 
 bool GVNPass::PerformLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock,
return OptimizationRemark(DEBUG_TYPE, "LoadElim", Load)
            << "load of type " << NV("Type", Load->getType()) << " eliminated"
            << setExtraArgs() << " in favor of "
            << NV("InfavorOfValue", AvailableValue);
   });
 }
 
 /// Attempt to eliminate a load whose dependencies are
 /// non-local by performing PHI construction.
-bool GVNPass::processNonLocalLoad(LoadInst *Load) {
-  // non-local speculations are not allowed under asan.
-  if (Load->getParent()->getParent()->hasFnAttribute(
-          Attribute::SanitizeAddress) ||
-      Load->getParent()->getParent()->hasFnAttribute(
-          Attribute::SanitizeHWAddress))
-    return false;
-
-  // Find the non-local dependencies of the load.
-  LoadDepVect Deps;
-  MD->getNonLocalPointerDependency(Load, Deps);
-
-  // If we had to process more than one hundred blocks to find the
-  // dependencies, this load isn't worth worrying about.  Optimizing
-  // it will be too expensive.
-  unsigned NumDeps = Deps.size();
-  if (NumDeps > MaxNumDeps)
-    return false;
-
-  SmallVector<ReachingMemVal, 64> MemVals;
-  for (const NonLocalDepResult &Dep : Deps) {
-    Value *Address = Dep.getAddress();
-    BasicBlock *BB = Dep.getBB();
-    Instruction *Inst = Dep.getResult().getInst();
-    if (Dep.getResult().isClobber())
-      MemVals.emplace_back(ReachingMemVal::getClobber(Address, Inst));
-    else if (Dep.getResult().isDef())
-      MemVals.emplace_back(ReachingMemVal::getDef(Address, Inst));
-    else
-      MemVals.emplace_back(ReachingMemVal::getUnknown(BB, Address, Inst));
-  }
-  return processNonLocalLoad(Load, MemVals);
-}
-
-bool GVNPass ::processNonLocalLoad(LoadInst *Load,
-                                   SmallVectorImpl<ReachingMemVal> &Deps) {
+bool GVNPass::processNonLocalLoad(LoadInst *Load,
   // If we had a phi translation failure, we'll have a single entry which is a
   // clobber in the current block.  Reject this early.
   if (Deps.size() == 1 && Deps[0].Kind == DepKind::Other) {
     LLVM_DEBUG(dbgs() << "GVN: non-local load "; Load->printAsOperand(dbgs());
                dbgs() << " has unknown dependencies\n";);
     return false;
   }
 
if (UnavailableBlocks.empty()) {
     if (isa<PHINode>(V))
       V->takeName(Load);
     if (Instruction *I = dyn_cast<Instruction>(V))
       // If instruction I has debug info, then we should not update it.
       // Also, if I has a null DebugLoc, then it is still potentially incorrect
       // to propagate Load's DebugLoc because Load may not post-dominate I.
       if (Load->getDebugLoc() && Load->getParent() == I->getParent())
         I->setDebugLoc(Load->getDebugLoc());
-    if (MD && V->getType()->isPtrOrPtrVectorTy())
-      MD->invalidateCachedPointerInfo(V);
     markInstructionForDeletion(Load);
     ++NumGVNLoad;
     reportLoadElim(Load, V, ORE);
     return true;
   }
 
   // Step 4: Eliminate partial redundancy.
   if (!isPREEnabled() || !isLoadPREEnabled())
bool GVNPass::findReachingValuesForLoad(
   }
 
   return true;
 }
 
 /// Attempt to eliminate a load, first by eliminating it
 /// locally, and then attempting non-local elimination if that fails.
 bool GVNPass::processLoad(LoadInst *L) {
-  if (!MD && !MSSAU)
+  if (!MSSAU)
     return false;
 
   // This code hasn't been audited for ordered or volatile memory access
   if (!L->isUnordered())
     return false;
 
   if (L->use_empty()) {
     markInstructionForDeletion(L);
     return true;
   }
 
-  ReachingMemVal MemVal = ReachingMemVal::getUnknown(nullptr, nullptr);
-  if (MD) {
-    // ... to a pointer that has been loaded from before...
-    MemDepResult Dep = MD->getDependency(L);
-
-    // If it is defined in another block, try harder.
-    if (Dep.isNonLocal())
-      return processNonLocalLoad(L);
-
-    // Only handle the local case below
-    if (Dep.isDef())
-      MemVal = ReachingMemVal::getDef(L->getPointerOperand(), Dep.getInst());
-    else if (Dep.isClobber())
-      MemVal =
-          ReachingMemVal::getClobber(L->getPointerOperand(), Dep.getInst());
-  } else {
-    SmallVector<ReachingMemVal, 8> MemVals;
-    if (!findReachingValuesForLoad(L, *MSSAU->getMemorySSA(), *AA, MemVals))
-      return false; // Too many dependencies.
-    assert(MemVals.size() && "Expected at least an unknown value");
-    if (MemVals.size() > 1 || MemVals[0].Block != L->getParent())
-      return processNonLocalLoad(L, MemVals);
+  SmallVector<ReachingMemVal, 64> MemVals;
 
-    // Only handle the local case below
-    MemVal = MemVals[0];
-  }
-
   Value *Address = L->getPointerOperand();
-  if (MemVal.Kind == DepKind::Other && !isa<SelectInst>(Address)) {
+  if (MemVals[0].Kind == DepKind::Other && !isa<SelectInst>(Address)) {
     LLVM_DEBUG(
         // fast print dep, using operator<< on instruction is too slow.
         dbgs() << "GVN: load "; L->printAsOperand(dbgs());
         dbgs() << " has unknown dependence\n";);
     return false;
   }
 
   AvailableValue AV;
-  if (AnalyzeLoadAvailability(L, MemVal, Address, AV)) {
+  if (AnalyzeLoadAvailability(L, MemVals[0], Address, AV)) {
     Value *AvailableValue = AV.MaterializeAdjustedValue(L, L, *this);
 
     // Replace the load!
     patchAndReplaceAllUsesWith(L, AvailableValue);
     markInstructionForDeletion(L);
     if (MSSAU)
       MSSAU->removeMemoryAccess(L);
     ++NumGVNLoad;
     reportLoadElim(L, AvailableValue, ORE);
-    // Tell MDA to reexamine the reused pointer since we might have more
-    // information after forwarding it.
-    if (MD && AvailableValue->getType()->isPtrOrPtrVectorTy())
-      MD->invalidateCachedPointerInfo(AvailableValue);
     return true;
   }
 
   return false;
 }
 
 /// Return a pair the first field showing the value number of \p Exp and the
 /// second field showing whether it is a value number newly created.
bool GVNPass::ValueTable::areCallValsEqual(uint32_t Num, uint32_t NewNum,
   LeaderTableEntry *Vals = &Gvn.LeaderTable[Num];
   while (Vals) {
     Call = dyn_cast<CallInst>(Vals->Val);
     if (Call && Call->getParent() == PhiBlock)
       break;
     Vals = Vals->Next;
   }
 
-  if (AA->doesNotAccessMemory(Call))
-    return true;
-
-  if (!MD || !AA->onlyReadsMemory(Call))
-    return false;
-
-  MemDepResult local_dep = MD->getDependency(Call);
-  if (!local_dep.isNonLocal())
-    return false;
-
-  const MemoryDependenceResults::NonLocalDepInfo &deps =
-      MD->getNonLocalCallDependency(Call);
-
-  // Check to see if the Call has no function local clobber.
-  for (const NonLocalDepEntry &D : deps) {
-    if (D.getResult().isNonFuncLocal())
-      return true;
-  }
-  return false;
+  return AA->doesNotAccessMemory(Call);
 }
 
 /// Translate value number \p Num using phis, so that it has the values of
 /// the phis in BB.
 uint32_t GVNPass::ValueTable::phiTranslateImpl(const BasicBlock *Pred,
                                                const BasicBlock *PhiBlock,
                                                uint32_t Num, GVNPass &Gvn) {
   if (PHINode *PN = NumberingPhi[Num]) {
while (!Worklist.empty()) {
     if (!LHS->hasOneUse()) {
       unsigned NumReplacements =
           DominatesByEdge
               ? replaceDominatedUsesWith(LHS, RHS, *DT, Root)
               : replaceDominatedUsesWith(LHS, RHS, *DT, Root.getStart());
 
       Changed |= NumReplacements > 0;
       NumGVNEqProp += NumReplacements;
-      // Cached information for anything that uses LHS will be invalid.
-      if (MD)
-        MD->invalidateCachedPointerInfo(LHS);
     }
 
     // Now try to deduce additional equalities from this one. For example, if
     // the known equality was "(A != B)" == "false" then it follows that A and B
     // are equal in the scope. Only boolean equalities with an explicit true or
     // false RHS are currently supported.
     if (!RHS->getType()->isIntegerTy(1))
       // Not a boolean equality - bail out.
if (CmpInst *Cmp = dyn_cast<CmpInst>(LHS)) {
         if (NotCmp && isa<Instruction>(NotCmp)) {
           unsigned NumReplacements =
               DominatesByEdge
                   ? replaceDominatedUsesWith(NotCmp, NotVal, *DT, Root)
                   : replaceDominatedUsesWith(NotCmp, NotVal, *DT,
                                              Root.getStart());
           Changed |= NumReplacements > 0;
           NumGVNEqProp += NumReplacements;
-          // Cached information for anything that uses NotCmp will be invalid.
-          if (MD)
-            MD->invalidateCachedPointerInfo(NotCmp);
         }
       }
       // Ensure that any instruction in scope that gets the "A < B" value number
       // is replaced with false.
       // The leader table only tracks basic blocks, not edges. Only add to if we
       // have the simple case where the edge dominates the end.
       if (RootDominatesEnd)
         addToLeaderTable(Num, NotVal, Root.getEnd());
if (!I->use_empty()) {
       I->replaceAllUsesWith(V);
       Changed = true;
     }
     if (isInstructionTriviallyDead(I, TLI)) {
       markInstructionForDeletion(I);
       Changed = true;
     }
     if (Changed) {
-      if (MD && V->getType()->isPtrOrPtrVectorTy())
-        MD->invalidateCachedPointerInfo(V);
       ++NumGVNSimpl;
       return true;
     }
   }
 
   if (auto *Assume = dyn_cast<AssumeInst>(I))
     return processAssumeIntrinsic(Assume);
 
bool GVNPass::processInstruction(Instruction *I) {
   } else if (Repl == I) {
     // If I was the result of a shortcut PRE, it might already be in the table
     // and the best replacement for itself. Nothing to do.
     return false;
   }
 
   // Remove it!
   patchAndReplaceAllUsesWith(I, Repl);
-  if (MD && Repl->getType()->isPtrOrPtrVectorTy())
-    MD->invalidateCachedPointerInfo(Repl);
   markInstructionForDeletion(I);
   return true;
 }
 
 /// runOnFunction - This is the main transformation entry point for a function.
 bool GVNPass::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
                       const TargetLibraryInfo &RunTLI, AAResults &RunAA,
-                      MemoryDependenceResults *RunMD, LoopInfo *LI,
-                      OptimizationRemarkEmitter *RunORE, MemorySSA *MSSA) {
+                      LoopInfo *LI, OptimizationRemarkEmitter *RunORE,
+                      MemorySSA *MSSA) {
   AC = &RunAC;
   DT = &RunDT;
   VN.setDomTree(DT);
   TLI = &RunTLI;
   AA = &RunAA;
   VN.setAliasAnalysis(&RunAA);
-  MD = RunMD;
   ImplicitControlFlowTracking ImplicitCFT;
   ICF = &ImplicitCFT;
   this->LI = LI;
-  VN.setMemDep(MD);
   VN.setMemorySSA(MSSA);
   ORE = RunORE;
   InvalidBlockRPONumbers = true;
   MemorySSAUpdater Updater(MSSA);
   MSSAU = MSSA ? &Updater : nullptr;
 
   bool Changed = false;
   bool ShouldContinue = true;
 
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
   // Merge unconditional branches, allowing PRE to catch more
   // optimization opportunities.
   for (BasicBlock &BB : llvm::make_early_inc_range(F)) {
-    bool removedBlock = MergeBlockIntoPredecessor(&BB, &DTU, LI, MSSAU, MD);
+    bool removedBlock = MergeBlockIntoPredecessor(&BB, &DTU, LI, MSSAU, nullptr);
     if (removedBlock)
       ++NumGVNBlocks;
 
     Changed |= removedBlock;
   }
 
   unsigned Iteration = 0;
   while (ShouldContinue) {
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();
     if (!AtStart)
       --BI;
 
     for (auto *I : InstrsToErase) {
       assert(I->getParent() == BB && "Removing instruction from wrong block?");
       LLVM_DEBUG(dbgs() << "GVN removed: " << *I << '\n');
       salvageKnowledge(I, AC);
       salvageDebugInfo(*I);
-      if (MD) MD->removeInstruction(I);
       if (MSSAU)
         MSSAU->removeMemoryAccess(I);
       LLVM_DEBUG(verifyRemoved(I));
       ICF->removeInstruction(I);
       I->eraseFromParent();
     }
     InstrsToErase.clear();
 
bool GVNPass::performScalarPRE(Instruction *CurInst) {
 
   VN.add(Phi, ValNo);
   // After creating a new PHI for ValNo, the phi translate result for ValNo will
   // be changed, so erase the related stale entries in phi translate cache.
   VN.eraseTranslateCacheEntry(ValNo, *CurrentBlock);
   addToLeaderTable(ValNo, Phi, CurrentBlock);
   Phi->setDebugLoc(CurInst->getDebugLoc());
   CurInst->replaceAllUsesWith(Phi);
-  if (MD && Phi->getType()->isPtrOrPtrVectorTy())
-    MD->invalidateCachedPointerInfo(Phi);
   VN.erase(CurInst);
   removeFromLeaderTable(ValNo, CurInst, CurrentBlock);
 
   LLVM_DEBUG(dbgs() << "GVN PRE removed: " << *CurInst << '\n');
-  if (MD)
-    MD->removeInstruction(CurInst);
   if (MSSAU)
     MSSAU->removeMemoryAccess(CurInst);
   LLVM_DEBUG(verifyRemoved(CurInst));
   // FIXME: Intended to be markInstructionForDeletion(CurInst), but it causes
   // some assertion failures.
   ICF->removeInstruction(CurInst);
   CurInst->eraseFromParent();
   ++NumGVNInstr;

 /// Split the critical edge connecting the given two blocks, and return
 /// the block inserted to the critical edge.
 BasicBlock *GVNPass::splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ) {
   // GVN does not require loop-simplify, do not try to preserve it if it is not
   // possible.
   BasicBlock *BB = SplitCriticalEdge(
       Pred, Succ,
       CriticalEdgeSplittingOptions(DT, LI, MSSAU).unsetPreserveLoopSimplify());
-  if (BB) {
-    if (MD)
-      MD->invalidateCachedPredecessors();
+  if (BB)
     InvalidBlockRPONumbers = true;
-  }
   return BB;
 }
 
 /// Split critical edges found during the previous
 /// iteration that may enable further optimization.
 bool GVNPass::splitCriticalEdges() {
   if (toSplit.empty())
     return false;
 
   bool Changed = false;
   do {
     std::pair<Instruction *, unsigned> Edge = toSplit.pop_back_val();
     Changed |= SplitCriticalEdge(Edge.first, Edge.second,
                                  CriticalEdgeSplittingOptions(DT, LI, MSSAU)) !=
                nullptr;
   } while (!toSplit.empty());
-  if (Changed) {
-    if (MD)
-      MD->invalidateCachedPredecessors();
+  if (Changed)
     InvalidBlockRPONumbers = true;
-  }
   return Changed;
 }
 
 /// Executes one iteration of GVN
 bool GVNPass::iterateOnFunction(Function &F) {
   cleanupGlobalSets();
 
   // Top-down walk of the dominator tree
for (BasicBlock *P : Preds) {
           DeadBlocks.insert(P = S);
       }
     }
 
     // Now poison the incoming values from the dead predecessors.
     for (BasicBlock *P : predecessors(B)) {
       if (!DeadBlocks.count(P))
         continue;
-      for (PHINode &Phi : B->phis()) {
+      for (PHINode &Phi : B->phis())
         Phi.setIncomingValueForBlock(P, PoisonValue::get(Phi.getType()));
-        if (MD)
-          MD->invalidateCachedPointerInfo(&Phi);
-      }
     }
   }
 }
 
 // If the given branch is recognized as a foldable branch (i.e. conditional
 // branch with constant condition), it will perform following analyses and
 // transformation.
 //  1) If the dead out-coming edge is a critical-edge, split it. Let
for (BasicBlock *BB : DeadBlocks) {
     }
   }
 }
 
 class llvm::gvn::GVNLegacyPass : public FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  explicit GVNLegacyPass(bool MemDepAnalysis = GVNEnableMemDep,
-                         bool MemSSAAnalysis = GVNEnableMemorySSA)
-      : FunctionPass(ID), Impl(GVNOptions()
-                                   .setMemDep(MemDepAnalysis)
-                                   .setMemorySSA(MemSSAAnalysis)) {
+  explicit GVNLegacyPass(bool MemSSAAnalysis = GVNEnableMemorySSA)
+      : FunctionPass(ID), Impl(GVNOptions().setMemorySSA(MemSSAAnalysis)) {
     initializeGVNLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnFunction(Function &F) override {
     if (skipFunction(F))
       return false;
 
     auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
     return Impl.runImpl(
         F, getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F),
         getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
         getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F),
         getAnalysis<AAResultsWrapperPass>().getAAResults(),
-        Impl.isMemDepEnabled()
-            ? &getAnalysis<MemoryDependenceWrapperPass>().getMemDep()
-            : nullptr,
         LIWP ? &LIWP->getLoopInfo() : nullptr,
         &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE(),
         Impl.isMemorySSAEnabled()
             ? &getAnalysis<MemorySSAWrapperPass>().getMSSA()
             : nullptr);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<LoopInfoWrapperPass>();
-    if (Impl.isMemDepEnabled())
-      AU.addRequired<MemoryDependenceWrapperPass>();
     if (Impl.isMemorySSAEnabled())
       AU.addRequired<MemorySSAWrapperPass>();
     AU.addRequired<AAResultsWrapperPass>();
     AU.addPreserved<DominatorTreeWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
     AU.addPreserved<TargetLibraryInfoWrapperPass>();
     AU.addPreserved<LoopInfoWrapperPass>();
     AU.addRequired<OptimizationRemarkEmitterWrapperPass>();
     AU.addPreserved<MemorySSAWrapperPass>();
   }
 
 private:
   GVNPass Impl;
 };
 
 char GVNLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(GVNLegacyPass, "gvn", "Global Value Numbering", false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)
 INITIALIZE_PASS_END(GVNLegacyPass, "gvn", "Global Value Numbering", false, false)
 
 // The public interface to this file...
 FunctionPass *llvm::createGVNPass() { return new GVNLegacyPass(); }

llvm/lib/Transforms/Scalar/GVNHoist.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/IteratedDominanceFrontier.h"
-#include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/Analysis/MemorySSA.h"
 #include "llvm/Analysis/MemorySSAUpdater.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"

 }
 
 // This pass hoists common computations across branches sharing common
 // dominator. The primary goal is to reduce the code size, and in some
 // cases reduce critical path (by exposing more ILP).
 class GVNHoist {
 public:
   GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA,
-           MemoryDependenceResults *MD, MemorySSA *MSSA)
-      : DT(DT), PDT(PDT), AA(AA), MD(MD), MSSA(MSSA),
+           MemorySSA *MSSA)
+      : DT(DT), PDT(PDT), AA(AA), MSSA(MSSA),
         MSSAUpdater(std::make_unique<MemorySSAUpdater>(MSSA)) {
     MSSA->ensureOptimizedUses();
   }
 
   bool run(Function &F);
 
   // Copied from NewGVN.cpp
   // This function provides global ranking of operations so that we can place
   // them in a canonical order.  Note that rank alone is not necessarily enough
   // for a complete ordering, as constants all have the same rank.  However,
   // generally, we will simplify an operation with all constants so that it
   // doesn't matter what order they appear in.
   unsigned int rank(const Value *V) const;
 
 private:
   GVNPass::ValueTable VN;
   DominatorTree *DT;
   PostDominatorTree *PDT;
   AliasAnalysis *AA;
-  MemoryDependenceResults *MD;
   MemorySSA *MSSA;
   std::unique_ptr<MemorySSAUpdater> MSSAUpdater;
   DenseMap<const Value *, unsigned> DFSNumber;
   BBSideEffectsSet BBSideEffects;
   DenseSet<const BasicBlock *> HoistBarrier;
   SmallVector<BasicBlock *, 32> IDFBlocks;
   unsigned NumFuncArgs;
   const bool HoistingGeps = false;
public:
   }
 
   bool runOnFunction(Function &F) override {
     if (skipFunction(F))
       return false;
     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
     auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
-    auto &MD = getAnalysis<MemoryDependenceWrapperPass>().getMemDep();
     auto &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
 
-    GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
+    GVNHoist G(&DT, &PDT, &AA, &MSSA);
     return G.run(F);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<PostDominatorTreeWrapperPass>();
     AU.addRequired<AAResultsWrapperPass>();
-    AU.addRequired<MemoryDependenceWrapperPass>();
     AU.addRequired<MemorySSAWrapperPass>();
     AU.addPreserved<DominatorTreeWrapperPass>();
     AU.addPreserved<MemorySSAWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
   }
 };
 
 bool GVNHoist::run(Function &F) {
   NumFuncArgs = F.arg_size();
   VN.setDomTree(DT);
   VN.setAliasAnalysis(AA);
-  VN.setMemDep(MD);
   bool Res = false;
   // Perform DFS Numbering of instructions.
   unsigned BBI = 0;
   for (const BasicBlock *BB : depth_first(&F.getEntryBlock())) {
     DFSNumber[BB] = ++BBI;
     unsigned I = 0;
     for (auto &Inst : *BB)
       DFSNumber[&Inst] = ++I;
if (I != Repl) {
         MemoryAccess *OldMA = MSSA->getMemoryAccess(I);
         OldMA->replaceAllUsesWith(NewMemAcc);
         MSSAUpdater->removeMemoryAccess(OldMA);
       }
 
       Repl->andIRFlags(I);
       combineKnownMetadata(Repl, I);
       I->replaceAllUsesWith(Repl);
-      // Also invalidate the Alias Analysis cache.
-      MD->removeInstruction(I);
       I->eraseFromParent();
     }
   }
   return NR;
 }
 
 void GVNHoist::raMPHIuw(MemoryUseOrDef *NewMemAcc) {
   SmallPtrSet<MemoryPhi *, 4> UsePhis;
if (Repl) {
 
         // When not HoistingGeps we need to copy the GEPs.
         if (!makeGepOperandsAvailable(Repl, DestBB, InstructionsToHoist))
           continue;
       }
 
       // Move the instruction at the end of HoistPt.
       Instruction *Last = DestBB->getTerminator();
-      MD->removeInstruction(Repl);
       Repl->moveBefore(Last);
 
       DFSNumber[Repl] = DFSNumber[Last]++;
     }
 
     // Drop debug location as per debug info update guide.
     Repl->dropLocation();
     NR += removeAndReplace(InstructionsToHoist, Repl, DestBB, MoveAccess);

 }
 
 } // end namespace llvm
 
 PreservedAnalyses GVNHoistPass::run(Function &F, FunctionAnalysisManager &AM) {
   DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
   PostDominatorTree &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
   AliasAnalysis &AA = AM.getResult<AAManager>(F);
-  MemoryDependenceResults &MD = AM.getResult<MemoryDependenceAnalysis>(F);
   MemorySSA &MSSA = AM.getResult<MemorySSAAnalysis>(F).getMSSA();
-  GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
+  GVNHoist G(&DT, &PDT, &AA, &MSSA);
   if (!G.run(F))
     return PreservedAnalyses::all();
 
   PreservedAnalyses PA;
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<MemorySSAAnalysis>();
   return PA;
 }
 
 char GVNHoistLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(GVNHoistLegacyPass, "gvn-hoist",
                       "Early GVN Hoisting of Expressions", false, false)
-INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_END(GVNHoistLegacyPass, "gvn-hoist",
                     "Early GVN Hoisting of Expressions", false, false)
 
 FunctionPass *llvm::createGVNHoistPass() { return new GVNHoistLegacyPass(); }