Use Module Pass

Author: V-FEXrt

llvm/include/llvm/Analysis/DXILResource.h

@@ -20,7 +20,6 @@
 
 #include <algorithm>
 #include <cstdint>
-#include <unordered_map>
 
 namespace llvm {
 class CallInst;
@@ -411,77 +410,6 @@ class DXILResourceTypeMap {
   }
 };
 
-enum ResourceCounterDirection {
-  Increment,
-  Decrement,
-  Unknown,
-};
-
-class DXILResourceCounterDirectionMap {
-  std::vector<std::pair<dxil::ResourceBindingInfo, ResourceCounterDirection>>
-      CounterDirections;
-
-public:
-  bool invalidate(Module &M, const PreservedAnalyses &PA,
-                  ModuleAnalysisManager::Invalidator &Inv);
-
-  void populate(Module &M, ModuleAnalysisManager &AM);
-
-  ResourceCounterDirection
-  operator[](const dxil::ResourceBindingInfo &Info) const {
-    auto Lower = std::lower_bound(
-        CounterDirections.begin(), CounterDirections.end(),
-        std::pair{Info, ResourceCounterDirection::Unknown},
-        [](auto lhs, auto rhs) { return lhs.first < rhs.first; });
-
-    if (Lower == CounterDirections.end()) {
-      return ResourceCounterDirection::Unknown;
-    }
-
-    if (Lower->first != Info) {
-      return ResourceCounterDirection::Unknown;
-    }
-
-    return Lower->second;
-  }
-};
-
-class DXILResourceCounterDirectionAnalysis
-    : public AnalysisInfoMixin<DXILResourceCounterDirectionAnalysis> {
-  friend AnalysisInfoMixin<DXILResourceCounterDirectionAnalysis>;
-
-  static AnalysisKey Key;
-
-public:
-  using Result = DXILResourceCounterDirectionMap;
-
-  DXILResourceCounterDirectionMap run(Module &M, ModuleAnalysisManager &AM) {
-    DXILResourceCounterDirectionMap DRCDM{};
-    DRCDM.populate(M, AM);
-    return DRCDM;
-  }
-};
-
-class DXILResourceCounterDirectionWrapperPass : public ImmutablePass {
-  DXILResourceCounterDirectionMap DRCDM;
-
-  virtual void anchor();
-
-public:
-  static char ID;
-  DXILResourceCounterDirectionWrapperPass();
-
-  DXILResourceCounterDirectionMap &getResourceCounterDirectionMap() {
-    return DRCDM;
-  }
-  const DXILResourceCounterDirectionMap &
-  getResourceCounterDirectionMap() const {
-    return DRCDM;
-  }
-};
-
-ModulePass *createDXILResourceCounterDirectionWrapperPassPass();
-
 class DXILResourceTypeAnalysis
     : public AnalysisInfoMixin<DXILResourceTypeAnalysis> {
   friend AnalysisInfoMixin<DXILResourceTypeAnalysis>;
@@ -649,6 +577,81 @@ class DXILResourceBindingWrapperPass : public ModulePass {
 
 ModulePass *createDXILResourceBindingWrapperPassPass();
 
+enum ResourceCounterDirection {
+  Increment,
+  Decrement,
+  Unknown,
+};
+
+class DXILResourceCounterDirectionMap {
+  std::vector<std::pair<dxil::ResourceBindingInfo, ResourceCounterDirection>>
+      CounterDirections;
+
+public:
+  void populate(Module &M, DXILBindingMap &DBM);
+
+  ResourceCounterDirection
+  operator[](const dxil::ResourceBindingInfo &Info) const {
+    auto Lower = std::lower_bound(
+        CounterDirections.begin(), CounterDirections.end(),
+        std::pair{Info, ResourceCounterDirection::Unknown},
+        [](auto LHS, auto RHS) { return LHS.first < RHS.first; });
+
+    if (Lower == CounterDirections.end()) {
+      return ResourceCounterDirection::Unknown;
+    }
+
+    if (Lower->first != Info) {
+      return ResourceCounterDirection::Unknown;
+    }
+
+    return Lower->second;
+  }
+};
+
+class DXILResourceCounterDirectionAnalysis
+    : public AnalysisInfoMixin<DXILResourceCounterDirectionAnalysis> {
+  friend AnalysisInfoMixin<DXILResourceCounterDirectionAnalysis>;
+
+  static AnalysisKey Key;
+
+public:
+  using Result = DXILResourceCounterDirectionMap;
+
+  DXILResourceCounterDirectionMap run(Module &M, ModuleAnalysisManager &AM) {
+    DXILResourceCounterDirectionMap DRCDM{};
+    DXILBindingMap &DBM = AM.getResult<DXILResourceBindingAnalysis>(M);
+    DRCDM.populate(M, DBM);
+    return DRCDM;
+  }
+};
+
+class DXILResourceCounterDirectionWrapperPass : public ModulePass {
+  std::unique_ptr<DXILResourceCounterDirectionMap> Map;
+
+public:
+  static char ID;
+  DXILResourceCounterDirectionWrapperPass();
+  ~DXILResourceCounterDirectionWrapperPass() override = default;
+
+  DXILResourceCounterDirectionMap &getResourceCounterDirectionMap() {
+    return *Map;
+  }
+  const DXILResourceCounterDirectionMap &
+  getResourceCounterDirectionMap() const {
+    return *Map;
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnModule(Module &M) override;
+  void releaseMemory() override;
+
+  void print(raw_ostream &OS, const Module *M) const override;
+};
+
+ModulePass *createDXILResourceCounterDirectionWrapperPassPass();
+
+
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_DXILRESOURCE_H

llvm/lib/Analysis/DXILResource.cpp

@@ -830,8 +830,7 @@ static bool isUpdateCounterIntrinsic(Function &F) {
 }
 
 void DXILResourceCounterDirectionMap::populate(Module &M,
-                                               ModuleAnalysisManager &AM) {
-  DXILBindingMap &DBM = AM.getResult<DXILResourceBindingAnalysis>(M);
+                                               DXILBindingMap &DBM) {
   CounterDirections.clear();
 
   for (Function &F : M.functions()) {
@@ -895,17 +894,36 @@ void DXILResourceCounterDirectionMap::populate(Module &M,
   M.getContext().diagnose(DiagnosticInfoGeneric(Message));
 }
 
-bool DXILResourceCounterDirectionMap::invalidate(
-    Module &M, const PreservedAnalyses &PA,
-    ModuleAnalysisManager::Invalidator &Inv) {
-  // Passes that introduce resource types must explicitly invalidate this pass.
-  // auto PAC = PA.getChecker<DXILResourceTypeAnalysis>();
-  // return !PAC.preservedWhenStateless();
+void DXILResourceCounterDirectionWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequiredTransitive<DXILResourceBindingWrapperPass>();
+  AU.setPreservesAll();
+}
+
+bool DXILResourceCounterDirectionWrapperPass::runOnModule(Module &M) {
+  Map.reset(new DXILResourceCounterDirectionMap());
+
+  auto DBM = getAnalysis<DXILResourceBindingWrapperPass>().getBindingMap();
+  Map->populate(M, DBM);
+
   return false;
 }
 
-void DXILResourceCounterDirectionWrapperPass::anchor() {}
+void DXILResourceCounterDirectionWrapperPass::releaseMemory() { Map.reset(); }
+
+void DXILResourceCounterDirectionWrapperPass::print(raw_ostream &OS,
+                                           const Module *M) const {
+  if (!Map) {
+    OS << "No resource directions have been built!\n";
+    return;
+  }
+  //Map->print(OS, *DRTM, M->getDataLayout());
+}
+
 
+//#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+//LLVM_DUMP_METHOD
+//void DXILResourceCounterDirectionWrapperPass::dump() const { print(dbgs(), nullptr); }
+//#endif
 //===----------------------------------------------------------------------===//
 
 AnalysisKey DXILResourceTypeAnalysis::Key;
@@ -935,8 +953,8 @@ INITIALIZE_PASS(DXILResourceCounterDirectionWrapperPass,
 
 DXILResourceCounterDirectionWrapperPass::
     DXILResourceCounterDirectionWrapperPass()
-    : ImmutablePass(ID) {
-  initializeDXILResourceTypeWrapperPassPass(*PassRegistry::getPassRegistry());
+    : ModulePass(ID) {
+  initializeDXILResourceCounterDirectionWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 void DXILResourceTypeWrapperPass::anchor() {}