[NFC] MemoryDependenceAnalysis cleanup.

[dfukalov]

Summary

1. Removed redundant includes,
2. Removed never defined and used releaseMemory().
3. Fixed member functions names first letter case.
4. Renamed duplicate (in nested struct NonLocalPointerInfo) name NonLocalDeps to NonLocalDepsMap.

[dfukalov]

Gentle ping...

[nikic]

LGTM

[dfukalov]

Rebased, ping.

[nikic]

In D102358#2789036, @dfukalov wrote:

Rebased, ping.

It's already approved? ^^

[dfukalov]

In D102358#2789473, @nikic wrote:

It's already approved? ^^

Ooops, sorry for pinging.

llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerSumType.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/MemoryLocation.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Metadata.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PredIteratorCache.h"
 #include "llvm/IR/ValueHandle.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/ErrorHandling.h"
-#include <cassert>
-#include <cstdint>
-#include <utility>
-#include <vector>
 
 namespace llvm {
 
 class AAResults;
 class AssumptionCache;
 class BatchAAResults;
 class DominatorTree;
-class Function;
-class Instruction;
-class LoadInst;
 class PHITransAddr;
-class TargetLibraryInfo;
 class PhiValues;
-class Value;
 
 /// A memory dependence query can return one of three different answers.
 class MemDepResult {
   enum DepType {
     /// Clients of MemDep never see this.
     ///
     /// Entries with this marker occur in a LocalDeps map or NonLocalDeps map
     /// when the instruction they previously referenced was removed from
private:
   ///
   /// The pointer is an owning pointer and the bool indicates whether we have
   /// any dirty bits in the set.
   using PerInstNLInfo = std::pair<NonLocalDepInfo, bool>;
 
   // A map from instructions to their non-local dependencies.
   using NonLocalDepMapType = DenseMap<Instruction *, PerInstNLInfo>;
 
-  NonLocalDepMapType NonLocalDeps;
+  NonLocalDepMapType NonLocalDepsMap;
 
   // A reverse mapping from dependencies to the dependees.  This is
   // used when removing instructions to keep the cache coherent.
   using ReverseDepMapType =
       DenseMap<Instruction *, SmallPtrSet<Instruction *, 4>>;
   ReverseDepMapType ReverseLocalDeps;
 
   // A reverse mapping from dependencies to the non-local dependees.
private:
   bool getNonLocalPointerDepFromBB(Instruction *QueryInst,
                                    const PHITransAddr &Pointer,
                                    const MemoryLocation &Loc, bool isLoad,
                                    BasicBlock *BB,
                                    SmallVectorImpl<NonLocalDepResult> &Result,
                                    DenseMap<BasicBlock *, Value *> &Visited,
                                    bool SkipFirstBlock = false,
                                    bool IsIncomplete = false);
-  MemDepResult GetNonLocalInfoForBlock(Instruction *QueryInst,
+  MemDepResult getNonLocalInfoForBlock(Instruction *QueryInst,
                                        const MemoryLocation &Loc, bool isLoad,
                                        BasicBlock *BB, NonLocalDepInfo *Cache,
                                        unsigned NumSortedEntries,
                                        BatchAAResults &BatchAA);
 
-  void RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair P);
+  void removeCachedNonLocalPointerDependencies(ValueIsLoadPair P);
 
   void verifyRemoved(Instruction *Inst) const;
 };
 
 /// An analysis that produces \c MemoryDependenceResults for a function.
 ///
 /// This is essentially a no-op because the results are computed entirely
 /// lazily.

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

 #define LLVM_TRANSFORMS_SCALAR_GVN_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/InstructionPrecedenceTracking.h"
-#include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <utility>

 class CallInst;
 class Constant;
 class ExtractValueInst;
 class Function;
 class FunctionPass;
 class IntrinsicInst;
 class LoadInst;
 class LoopInfo;
+class MemDepResult;
+class MemoryDependenceResults;
 class MemorySSA;
 class MemorySSAUpdater;
+class NonLocalDepResult;
 class OptimizationRemarkEmitter;
 class PHINode;
 class TargetLibraryInfo;
 class Value;
 /// A private "module" namespace for types and utilities used by GVN. These
 /// are implementation details and should not be used by clients.
 namespace gvn LLVM_LIBRARY_VISIBILITY {
 

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

 }
 #endif
 
 const MemoryDependenceResults::NonLocalDepInfo &
 MemoryDependenceResults::getNonLocalCallDependency(CallBase *QueryCall) {
   assert(getDependency(QueryCall).isNonLocal() &&
          "getNonLocalCallDependency should only be used on calls with "
          "non-local deps!");
-  PerInstNLInfo &CacheP = NonLocalDeps[QueryCall];
+  PerInstNLInfo &CacheP = NonLocalDepsMap[QueryCall];
   NonLocalDepInfo &Cache = CacheP.first;
 
   // This is the set of blocks that need to be recomputed.  In the cached case,
   // this can happen due to instructions being deleted etc. In the uncached
   // case, this starts out as the set of predecessors we care about.
   SmallVector<BasicBlock *, 32> DirtyBlocks;
 
   if (!Cache.empty()) {
Result.push_back(NonLocalDepResult(FromBB, MemDepResult::getUnknown(),
                                      const_cast<Value *>(Loc.Ptr)));
 }
 
 /// Compute the memdep value for BB with Pointer/PointeeSize using either
 /// cached information in Cache or by doing a lookup (which may use dirty cache
 /// info if available).
 ///
 /// If we do a lookup, add the result to the cache.
-MemDepResult MemoryDependenceResults::GetNonLocalInfoForBlock(
+MemDepResult MemoryDependenceResults::getNonLocalInfoForBlock(
     Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad,
     BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries,
     BatchAAResults &BatchAA) {
 
   bool isInvariantLoad = false;
 
   if (LoadInst *LI = dyn_cast_or_null<LoadInst>(QueryInst))
     isInvariantLoad = LI->getMetadata(LLVMContext::MD_invariant_load);
while (!Worklist.empty()) {
     if (!SkipFirstBlock) {
       // Analyze the dependency of *Pointer in FromBB.  See if we already have
       // been here.
       assert(Visited.count(BB) && "Should check 'visited' before adding to WL");
 
       // Get the dependency info for Pointer in BB.  If we have cached
       // information, we will use it, otherwise we compute it.
       LLVM_DEBUG(AssertSorted(*Cache, NumSortedEntries));
-      MemDepResult Dep = GetNonLocalInfoForBlock(QueryInst, Loc, isLoad, BB,
-                                                 Cache, NumSortedEntries,
-                                                 BatchAA);
+      MemDepResult Dep = getNonLocalInfoForBlock(
+          QueryInst, Loc, isLoad, BB, Cache, NumSortedEntries, BatchAA);
 
       // If we got a Def or Clobber, add this to the list of results.
       if (!Dep.isNonLocal()) {
         if (DT.isReachableFromEntry(BB)) {
           Result.push_back(NonLocalDepResult(BB, Dep, Pointer.getAddr()));
           continue;
         }
       }
bool MemoryDependenceResults::getNonLocalPointerDepFromBB(
 
   // Okay, we're done now.  If we added new values to the cache, re-sort it.
   SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
   LLVM_DEBUG(AssertSorted(*Cache));
   return true;
 }
 
 /// If P exists in CachedNonLocalPointerInfo or NonLocalDefsCache, remove it.
-void MemoryDependenceResults::RemoveCachedNonLocalPointerDependencies(
+void MemoryDependenceResults::removeCachedNonLocalPointerDependencies(
     ValueIsLoadPair P) {
 
   // Most of the time this cache is empty.
   if (!NonLocalDefsCache.empty()) {
     auto it = NonLocalDefsCache.find(P.getPointer());
     if (it != NonLocalDefsCache.end()) {
       RemoveFromReverseMap(ReverseNonLocalDefsCache,
                            it->second.getResult().getInst(), P.getPointer());
void MemoryDependenceResults::removeCachedNonLocalPointerDependencies(
   NonLocalPointerDeps.erase(It);
 }
 
 void MemoryDependenceResults::invalidateCachedPointerInfo(Value *Ptr) {
   // If Ptr isn't really a pointer, just ignore it.
   if (!Ptr->getType()->isPointerTy())
     return;
   // Flush store info for the pointer.
-  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, false));
+  removeCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, false));
   // Flush load info for the pointer.
-  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, true));
+  removeCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, true));
   // Invalidate phis that use the pointer.
   PV.invalidateValue(Ptr);
 }
 
 void MemoryDependenceResults::invalidateCachedPredecessors() {
   PredCache.clear();
 }
 
 void MemoryDependenceResults::removeInstruction(Instruction *RemInst) {
   // Walk through the Non-local dependencies, removing this one as the value
   // for any cached queries.
-  NonLocalDepMapType::iterator NLDI = NonLocalDeps.find(RemInst);
-  if (NLDI != NonLocalDeps.end()) {
+  NonLocalDepMapType::iterator NLDI = NonLocalDepsMap.find(RemInst);
+  if (NLDI != NonLocalDepsMap.end()) {
     NonLocalDepInfo &BlockMap = NLDI->second.first;
     for (auto &Entry : BlockMap)
       if (Instruction *Inst = Entry.getResult().getInst())
         RemoveFromReverseMap(ReverseNonLocalDeps, Inst, RemInst);
-    NonLocalDeps.erase(NLDI);
+    NonLocalDepsMap.erase(NLDI);
   }
 
   // If we have a cached local dependence query for this instruction, remove it.
   LocalDepMapType::iterator LocalDepEntry = LocalDeps.find(RemInst);
   if (LocalDepEntry != LocalDeps.end()) {
     // Remove us from DepInst's reverse set now that the local dep info is gone.
     if (Instruction *Inst = LocalDepEntry->second.getInst())
       RemoveFromReverseMap(ReverseLocalDeps, Inst, RemInst);
 
     // Remove this local dependency info.
     LocalDeps.erase(LocalDepEntry);
   }
 
   // If we have any cached dependencies on this instruction, remove
   // them.
 
   // If the instruction is a pointer, remove it from both the load info and the
   // store info.
   if (RemInst->getType()->isPointerTy()) {
-    RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, false));
-    RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, true));
+    removeCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, false));
+    removeCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, true));
   } else {
     // Otherwise, if the instructions is in the map directly, it must be a load.
     // Remove it.
     auto toRemoveIt = NonLocalDefsCache.find(RemInst);
     if (toRemoveIt != NonLocalDefsCache.end()) {
       assert(isa<LoadInst>(RemInst) &&
              "only load instructions should be added directly");
       const Instruction *DepV = toRemoveIt->second.getResult().getInst();
if (ReverseDepIt != ReverseLocalDeps.end()) {
     }
   }
 
   ReverseDepIt = ReverseNonLocalDeps.find(RemInst);
   if (ReverseDepIt != ReverseNonLocalDeps.end()) {
     for (Instruction *I : ReverseDepIt->second) {
       assert(I != RemInst && "Already removed NonLocalDep info for RemInst");
 
-      PerInstNLInfo &INLD = NonLocalDeps[I];
+      PerInstNLInfo &INLD = NonLocalDepsMap[I];
       // The information is now dirty!
       INLD.second = true;
 
       for (auto &Entry : INLD.first) {
         if (Entry.getResult().getInst() != RemInst)
           continue;
 
         // Convert to a dirty entry for the subsequent instruction.
while (!ReversePtrDepsToAdd.empty()) {
           ReversePtrDepsToAdd.back().second);
       ReversePtrDepsToAdd.pop_back();
     }
   }
 
   // Invalidate phis that use the removed instruction.
   PV.invalidateValue(RemInst);
 
-  assert(!NonLocalDeps.count(RemInst) && "RemInst got reinserted?");
+  assert(!NonLocalDepsMap.count(RemInst) && "RemInst got reinserted?");
   LLVM_DEBUG(verifyRemoved(RemInst));
 }
 
 /// Verify that the specified instruction does not occur in our internal data
 /// structures.
 ///
 /// This function verifies by asserting in debug builds.
 void MemoryDependenceResults::verifyRemoved(Instruction *D) const {
 #ifndef NDEBUG
   for (const auto &DepKV : LocalDeps) {
     assert(DepKV.first != D && "Inst occurs in data structures");
     assert(DepKV.second.getInst() != D && "Inst occurs in data structures");
   }
 
   for (const auto &DepKV : NonLocalPointerDeps) {
     assert(DepKV.first.getPointer() != D && "Inst occurs in NLPD map key");
     for (const auto &Entry : DepKV.second.NonLocalDeps)
       assert(Entry.getResult().getInst() != D && "Inst occurs as NLPD value");
   }
 
-  for (const auto &DepKV : NonLocalDeps) {
+  for (const auto &DepKV : NonLocalDepsMap) {
     assert(DepKV.first != D && "Inst occurs in data structures");
     const PerInstNLInfo &INLD = DepKV.second;
     for (const auto &Entry : INLD.first)
       assert(Entry.getResult().getInst() != D &&
              "Inst occurs in data structures");
   }
 
   for (const auto &DepKV : ReverseLocalDeps) {