[PassManager] Implement DOTGraphTraitsViewer under NPM

[YangKeao]

Summary

Rename the legacy DOTGraphTraits{Module,}{Viewer,Printer} to the corresponding DOTGraphTraits...WrapperPass, and implement a new DOTGraphTraitsViewer with new pass manager.

[myhsu]

I understand that most of the code was copied from the original (LegacyPM) implementation, but I feel like it's also a good time to fix some of the minor issues as highlighted by my inline comments.

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

77

could we use struct and remove this?

91

the "llvm::" is redundant since we're already enclosed in namespace llvm

104

Please use Twine here. Also, F.getName() is sufficient, no need to create another std::string (via str())

116

Is there any specific reason we want to own the string? Is it possible to replace it with StringRef?

[YangKeao]

Fix according to comments

[Meinersbur]

The usual scheme for legacy pass names is usually to append either WrapperPass (such as DominatorTreeWrapperPass) or LegacyPass (such as CFGPrinterLegacyPass). Could you use one of those conventions?

Could you upload the patch with context (git diff -U999999, see https://www.llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface)

DOTGraphTraitsPrinter is not used in this patch. Do you plan to also introduce NPM passes for DomPrinter etc that derive from DOTGraphTraitsViewer?

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

92–112

The function is now duplicated with LegacyDOTGraphTraitsPrinter::runOnFunction. You could either move it out into a common function, are call this NPM run function from the legacy passes' runOnFunction. See e.g. InstSimplifyLegacyPass::runOnFunction how this was was done.

[YangKeao]

1. Modify the name from Legacy* to *LegacyPass
2. Upload the diff with git diff -U999999

[YangKeao]

@Meinersbur

DOTGraphTraitsPrinter is not used in this patch.

It is actually used in the D123678 , by ScopPrinter

Do you plan to also introduce NPM passes for DomPrinter etc that derive from DOTGraphTraitsViewer?

I'll try 😄 .

[YangKeao]

Add runViewerImpl and runPrinterImpl to store the common implementation of the new and legacy pass.

[myhsu]

Thanks for the patch, lgtm for most of the parts. Please address my comment though (especially the static one)

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

32

I think static is redundant in this case.
Also, in LLVM, "XXXImpl" sounds more like a name for internal / implementation-specific code, but this function is global. I would recommend changing this (and runPrinterImpl) into something more general, like "viewGraphForFunction".

[YangKeao]

Modify name from run*Impl to *GraphForFunction

[Meinersbur]

In D123677#3458779, @YangKeao wrote:

DOTGraphTraitsPrinter is not used in this patch.

It is actually used in the D123678 , by ScopPrinter

Usually patches organized self-contained units of changes, which includes not introducing dead code. If you need the code only in D123678, introduce the code there. There is a possibility to have a refactoring/NFC patch to make the diff of a followup patch more readable, but those also do not introduce dead code.

A possibility to not introduce dead code would be to use the code in NPM versions of DomPrinter etc, which is why I was suggesting it.

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

32

I don't see static being redundant here, it changes it to internal linkage. A template function is implicitly inline. Without static, every TU including this file will have to emit it, influencing compilation time.

[Meinersbur]

No need to reorganize your patches now, but please keep it in mind for your next contributions.

LG too commit, or update it to introduce NPM passes.

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

32

This actually isn't a change request, just wanted to point out that static has an effect. Inline non-static allows the linker to select just one of the definitions whereas static inline there might be multiple identical definitions the the final artifact. No opinion on which is better.

[YangKeao]

@Meinersbur Could you help me to commit this? 🍻

[Meinersbur]

In D123677#3464388, @YangKeao wrote:

@Meinersbur Could you help me to commit this? 🍻

Sure, I can commit this together with D123678 for having a use of DOTGraphTraitsPrinter. Seems you still want to make a change to D123678?

[YangKeao]

Fix wrong Twine usage

[YangKeao]

format codes

[Meinersbur]

In D123677#3488134, @YangKeao wrote:

Fix wrong Twine usage

Right. I should have noticed this too.

[YangKeao]

Use pointer specialization by default, e.g. GraphTraits<ScopDetection *> but not GraphTraits<ScopDetection>

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/GraphWriter.h"
 
 namespace llvm {
 
 /// Default traits class for extracting a graph from an analysis pass.
 ///
+/// This assumes that 'GraphT' is 'AnalysisT::Result *', and pass it through
+template <typename Result, typename GraphT = Result *>
+struct DefaultAnalysisGraphTraits {
+  static GraphT getGraph(Result R) { return &R; }
+};
+
+template <typename GraphT>
+void viewGraphForFunction(Function &F, GraphT Graph, StringRef Name,
+                          bool IsSimple) {
+  std::string GraphName = DOTGraphTraits<GraphT *>::getGraphName(&Graph);
+
+  ViewGraph(Graph, Name, IsSimple,
+            GraphName + " for '" + F.getName() + "' function");
+}
+
+template <typename AnalysisT, bool IsSimple,
+          typename GraphT = typename AnalysisT::Result *,
+          typename AnalysisGraphTraitsT =
+              DefaultAnalysisGraphTraits<typename AnalysisT::Result &, GraphT>>
+struct DOTGraphTraitsViewer
+    : public PassInfoMixin<DOTGraphTraitsViewer<AnalysisT, IsSimple, GraphT,
+                                                AnalysisGraphTraitsT>> {
+  DOTGraphTraitsViewer(StringRef GraphName) : Name(GraphName) {}
+
+  /// Return true if this function should be processed.
+  ///
+  /// An implementation of this class my override this function to indicate that
+  /// only certain functions should be viewed.
+  ///
+  /// @param Result The current analysis result for this function.
+  virtual bool processFunction(Function &F,
+                               const typename AnalysisT::Result &Result) {
+    return true;
+  }
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM) {
+    auto &Result = FAM.getResult<AnalysisT>(F);
+    if (!processFunction(F, Result))
+      return PreservedAnalyses::all();
+
+    GraphT Graph = AnalysisGraphTraitsT::getGraph(Result);
+    viewGraphForFunction(F, Graph, Name, IsSimple);
+
+    return PreservedAnalyses::all();
+  };
+
+private:
+  StringRef Name;
+};
+
+template <typename GraphT>
+void printGraphForFunction(Function &F, GraphT Graph, StringRef Name,
+                           bool IsSimple) {
+  std::string Filename = Name.str() + "." + F.getName().str() + ".dot";
+  std::error_code EC;
+
+  errs() << "Writing '" << Filename << "'...";
+
+  raw_fd_ostream File(Filename, EC, sys::fs::OF_TextWithCRLF);
+  std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
+
+  if (!EC)
+    WriteGraph(File, Graph, IsSimple,
+               GraphName + " for '" + F.getName() + "' function");
+  else
+    errs() << "  error opening file for writing!";
+  errs() << "\n";
+}
+
+template <typename AnalysisT, bool IsSimple,
+          typename GraphT = typename AnalysisT::Result *,
+          typename AnalysisGraphTraitsT =
+              DefaultAnalysisGraphTraits<typename AnalysisT::Result &, GraphT>>
+struct DOTGraphTraitsPrinter
+    : public PassInfoMixin<DOTGraphTraitsPrinter<AnalysisT, IsSimple, GraphT,
+                                                 AnalysisGraphTraitsT>> {
+  DOTGraphTraitsPrinter(StringRef GraphName) : Name(GraphName) {}
+
+  /// Return true if this function should be processed.
+  ///
+  /// An implementation of this class my override this function to indicate that
+  /// only certain functions should be viewed.
+  ///
+  /// @param Analysis The current analysis result for this function.
+  virtual bool processFunction(Function &F,
+                               const typename AnalysisT::Result &Result) {
+    return true;
+  }
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM) {
+    auto &Result = FAM.getResult<AnalysisT>(F);
+    if (!processFunction(F, Result))
+      return PreservedAnalyses::all();
+
+    GraphT Graph = AnalysisGraphTraitsT::getGraph(Result);
+
+    printGraphForFunction(F, Graph, Name, IsSimple);
+
+    return PreservedAnalyses::all();
+  };
+
+private:
+  StringRef Name;
+};
+
+/// Default traits class for extracting a graph from an analysis pass.
+///
 /// This assumes that 'GraphT' is 'AnalysisT *' and so just passes it through.
 template <typename AnalysisT, typename GraphT = AnalysisT *>
-struct DefaultAnalysisGraphTraits {
+struct LegacyDefaultAnalysisGraphTraits {
   static GraphT getGraph(AnalysisT *A) { return A; }
 };
 
-template <
-    typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
-    typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
-class DOTGraphTraitsViewer : public FunctionPass {
+template <typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
+          typename AnalysisGraphTraitsT =
+              LegacyDefaultAnalysisGraphTraits<AnalysisT, GraphT>>
+class DOTGraphTraitsViewerWrapperPass : public FunctionPass {
 public:
-  DOTGraphTraitsViewer(StringRef GraphName, char &ID)
+  DOTGraphTraitsViewerWrapperPass(StringRef GraphName, char &ID)
       : FunctionPass(ID), Name(GraphName) {}
 
   /// Return true if this function should be processed.
   ///
   /// An implementation of this class my override this function to indicate that
   /// only certain functions should be viewed.
   ///
   /// @param Analysis The current analysis result for this function.
   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
     return true;
   }
 
   bool runOnFunction(Function &F) override {
     auto &Analysis = getAnalysis<AnalysisT>();
 
     if (!processFunction(F, Analysis))
       return false;
 
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&Analysis);
-    std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
-    std::string Title = GraphName + " for '" + F.getName().str() + "' function";
-
-    ViewGraph(Graph, Name, IsSimple, Title);
+    viewGraphForFunction(F, Graph, Name, IsSimple);
 
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<AnalysisT>();
   }
 
 private:
   std::string Name;
 };
 
-template <
-    typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
-    typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
-class DOTGraphTraitsPrinter : public FunctionPass {
+template <typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
+          typename AnalysisGraphTraitsT =
+              LegacyDefaultAnalysisGraphTraits<AnalysisT, GraphT>>
+class DOTGraphTraitsPrinterWrapperPass : public FunctionPass {
 public:
-  DOTGraphTraitsPrinter(StringRef GraphName, char &ID)
+  DOTGraphTraitsPrinterWrapperPass(StringRef GraphName, char &ID)
       : FunctionPass(ID), Name(GraphName) {}
 
   /// Return true if this function should be processed.
   ///
   /// An implementation of this class my override this function to indicate that
   /// only certain functions should be printed.
   ///
   /// @param Analysis The current analysis result for this function.
   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
     return true;
   }
 
   bool runOnFunction(Function &F) override {
     auto &Analysis = getAnalysis<AnalysisT>();
 
     if (!processFunction(F, Analysis))
       return false;
 
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&Analysis);
-    std::string Filename = Name + "." + F.getName().str() + ".dot";
-    std::error_code EC;
-
-    errs() << "Writing '" << Filename << "'...";
-
-    raw_fd_ostream File(Filename, EC, sys::fs::OF_TextWithCRLF);
-    std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
-    std::string Title = GraphName + " for '" + F.getName().str() + "' function";
-
-    if (!EC)
-      WriteGraph(File, Graph, IsSimple, Title);
-    else
-      errs() << "  error opening file for writing!";
-    errs() << "\n";
+    printGraphForFunction(F, Graph, Name, IsSimple);
 
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<AnalysisT>();
   }
 
 private:
   std::string Name;
 };
 
-template <
-    typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
-    typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
-class DOTGraphTraitsModuleViewer : public ModulePass {
+template <typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
+          typename AnalysisGraphTraitsT =
+              LegacyDefaultAnalysisGraphTraits<AnalysisT, GraphT>>
+class DOTGraphTraitsModuleViewerWrapperPass : public ModulePass {
 public:
-  DOTGraphTraitsModuleViewer(StringRef GraphName, char &ID)
+  DOTGraphTraitsModuleViewerWrapperPass(StringRef GraphName, char &ID)
       : ModulePass(ID), Name(GraphName) {}
 
   bool runOnModule(Module &M) override {
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&getAnalysis<AnalysisT>());
     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
 
     ViewGraph(Graph, Name, IsSimple, Title);
 
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<AnalysisT>();
   }
 
 private:
   std::string Name;
 };
 
-template <
-    typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
-    typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
-class DOTGraphTraitsModulePrinter : public ModulePass {
+template <typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
+          typename AnalysisGraphTraitsT =
+              LegacyDefaultAnalysisGraphTraits<AnalysisT, GraphT>>
+class DOTGraphTraitsModulePrinterWrapperPass : public ModulePass {
 public:
-  DOTGraphTraitsModulePrinter(StringRef GraphName, char &ID)
+  DOTGraphTraitsModulePrinterWrapperPass(StringRef GraphName, char &ID)
       : ModulePass(ID), Name(GraphName) {}
 
   bool runOnModule(Module &M) override {
     GraphT Graph = AnalysisGraphTraitsT::getGraph(&getAnalysis<AnalysisT>());
     std::string Filename = Name + ".dot";
     std::error_code EC;
 
     errs() << "Writing '" << Filename << "'...";

llvm/lib/Analysis/DomPrinter.cpp

 
 namespace {
 struct DominatorTreeWrapperPassAnalysisGraphTraits {
   static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
     return &DTWP->getDomTree();
   }
 };
 
-struct DomViewer : public DOTGraphTraitsViewer<
+struct DomViewer : public DOTGraphTraitsViewerWrapperPass<
                        DominatorTreeWrapperPass, false, DominatorTree *,
                        DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomViewer()
-      : DOTGraphTraitsViewer<DominatorTreeWrapperPass, false, DominatorTree *,
-                             DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "dom", ID) {
+      : DOTGraphTraitsViewerWrapperPass<
+            DominatorTreeWrapperPass, false, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("dom", ID) {
     initializeDomViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 
-struct DomOnlyViewer : public DOTGraphTraitsViewer<
+struct DomOnlyViewer : public DOTGraphTraitsViewerWrapperPass<
                            DominatorTreeWrapperPass, true, DominatorTree *,
                            DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomOnlyViewer()
-      : DOTGraphTraitsViewer<DominatorTreeWrapperPass, true, DominatorTree *,
-                             DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "domonly", ID) {
+      : DOTGraphTraitsViewerWrapperPass<
+            DominatorTreeWrapperPass, true, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("domonly", ID) {
     initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 
 struct PostDominatorTreeWrapperPassAnalysisGraphTraits {
   static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
     return &PDTWP->getPostDomTree();
   }
 };
 
-struct PostDomViewer : public DOTGraphTraitsViewer<
-                          PostDominatorTreeWrapperPass, false,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+struct PostDomViewer
+    : public DOTGraphTraitsViewerWrapperPass<
+          PostDominatorTreeWrapperPass, false, PostDominatorTree *,
   static char ID;
-  PostDomViewer() :
-    DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false,
-                         PostDominatorTree *,
-                         PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdom", ID){
-      initializePostDomViewerPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomViewer()
+      : DOTGraphTraitsViewerWrapperPass<
+            PostDominatorTreeWrapperPass, false, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdom", ID) {
 };
 
-struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
-                            PostDominatorTreeWrapperPass, true,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+struct PostDomOnlyViewer
+    : public DOTGraphTraitsViewerWrapperPass<
+          PostDominatorTreeWrapperPass, true, PostDominatorTree *,
   static char ID;
-  PostDomOnlyViewer() :
-    DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true,
-                         PostDominatorTree *,
-                         PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdomonly", ID){
-      initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomOnlyViewer()
+      : DOTGraphTraitsViewerWrapperPass<
+            PostDominatorTreeWrapperPass, true, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdomonly",
+                                                             ID) {
 };
 } // end anonymous namespace
 
 char DomViewer::ID = 0;
 INITIALIZE_PASS(DomViewer, "view-dom",
                 "View dominance tree of function", false, false)
 
 char DomOnlyViewer::ID = 0;
 INITIALIZE_PASS(DomOnlyViewer, "view-dom-only",
                 "View dominance tree of function (with no function bodies)",
                 false, false)
 
 char PostDomViewer::ID = 0;
 INITIALIZE_PASS(PostDomViewer, "view-postdom",
                 "View postdominance tree of function", false, false)
 
 char PostDomOnlyViewer::ID = 0;
 INITIALIZE_PASS(PostDomOnlyViewer, "view-postdom-only",
                 "View postdominance tree of function "
                 "(with no function bodies)",
                 false, false)
 
 namespace {
-struct DomPrinter : public DOTGraphTraitsPrinter<
+struct DomPrinter : public DOTGraphTraitsPrinterWrapperPass<
                         DominatorTreeWrapperPass, false, DominatorTree *,
                         DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomPrinter()
-      : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, false, DominatorTree *,
-                              DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "dom", ID) {
+      : DOTGraphTraitsPrinterWrapperPass<
+            DominatorTreeWrapperPass, false, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("dom", ID) {
     initializeDomPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 
-struct DomOnlyPrinter : public DOTGraphTraitsPrinter<
+struct DomOnlyPrinter : public DOTGraphTraitsPrinterWrapperPass<
                             DominatorTreeWrapperPass, true, DominatorTree *,
                             DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomOnlyPrinter()
-      : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, true, DominatorTree *,
-                              DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "domonly", ID) {
+      : DOTGraphTraitsPrinterWrapperPass<
+            DominatorTreeWrapperPass, true, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("domonly", ID) {
     initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 
 struct PostDomPrinter
-  : public DOTGraphTraitsPrinter<
-                            PostDominatorTreeWrapperPass, false,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+    : public DOTGraphTraitsPrinterWrapperPass<
+          PostDominatorTreeWrapperPass, false, PostDominatorTree *,
   static char ID;
-  PostDomPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdom", ID) {
-      initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomPrinter()
+      : DOTGraphTraitsPrinterWrapperPass<
+            PostDominatorTreeWrapperPass, false, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdom", ID) {
 };
 
 struct PostDomOnlyPrinter
-  : public DOTGraphTraitsPrinter<
-                            PostDominatorTreeWrapperPass, true,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+    : public DOTGraphTraitsPrinterWrapperPass<
+          PostDominatorTreeWrapperPass, true, PostDominatorTree *,
   static char ID;
-  PostDomOnlyPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdomonly", ID) {
-      initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomOnlyPrinter()
+      : DOTGraphTraitsPrinterWrapperPass<
+            PostDominatorTreeWrapperPass, true, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdomonly",
+                                                             ID) {
 };
 } // end anonymous namespace
 
 
 
 char DomPrinter::ID = 0;
 INITIALIZE_PASS(DomPrinter, "dot-dom",
                 "Print dominance tree of function to 'dot' file",

llvm/lib/Analysis/RegionPrinter.cpp

 
 struct RegionInfoPassGraphTraits {
   static RegionInfo *getGraph(RegionInfoPass *RIP) {
     return &RIP->getRegionInfo();
   }
 };
 
 struct RegionPrinter
-    : public DOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
-                                   RegionInfoPassGraphTraits> {
+    : public DOTGraphTraitsPrinterWrapperPass<
+          RegionInfoPass, false, RegionInfo *, RegionInfoPassGraphTraits> {
   static char ID;
   RegionPrinter()
-      : DOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
+      : DOTGraphTraitsPrinterWrapperPass<RegionInfoPass, false, RegionInfo *,
                                          RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionPrinter::ID = 0;
 
 struct RegionOnlyPrinter
-    : public DOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
-                                   RegionInfoPassGraphTraits> {
+    : public DOTGraphTraitsPrinterWrapperPass<
+          RegionInfoPass, true, RegionInfo *, RegionInfoPassGraphTraits> {
   static char ID;
   RegionOnlyPrinter()
-      : DOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
+      : DOTGraphTraitsPrinterWrapperPass<RegionInfoPass, true, RegionInfo *,
                                          RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionOnlyPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionOnlyPrinter::ID = 0;
 
 struct RegionViewer
-    : public DOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
-                                  RegionInfoPassGraphTraits> {
+    : public DOTGraphTraitsViewerWrapperPass<
+          RegionInfoPass, false, RegionInfo *, RegionInfoPassGraphTraits> {
   static char ID;
   RegionViewer()
-      : DOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
+      : DOTGraphTraitsViewerWrapperPass<RegionInfoPass, false, RegionInfo *,
                                         RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionViewer::ID = 0;
 
 struct RegionOnlyViewer
-    : public DOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
+    : public DOTGraphTraitsViewerWrapperPass<RegionInfoPass, true, RegionInfo *,
                                              RegionInfoPassGraphTraits> {
   static char ID;
   RegionOnlyViewer()
-      : DOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
-                             RegionInfoPassGraphTraits>("regonly", ID) {
+      : DOTGraphTraitsViewerWrapperPass<RegionInfoPass, true, RegionInfo *,
+                                        RegionInfoPassGraphTraits>("regonly",
+                                                                   ID) {
     initializeRegionOnlyViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionOnlyViewer::ID = 0;
 
 } //end anonymous namespace
 
 INITIALIZE_PASS(RegionPrinter, "dot-regions",

polly/lib/Analysis/ScopGraphPrinter.cpp

addCustomGraphFeatures(const ScopDetectionWrapperPass *SD,
     O << "\tcolorscheme = \"paired12\"\n";
     printRegionCluster(&SD->getSD(), SD->getSD().getRI()->getTopLevelRegion(),
                        O, 4);
   }
 };
 } // end namespace llvm
 
 struct ScopViewer
-    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, false> {
+    : public DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false> {
   static char ID;
   ScopViewer()
-      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, false>("scops", ID) {}
+      : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false>(
+            "scops", ID) {}
   bool processFunction(Function &F, ScopDetectionWrapperPass &SD) override {
     if (ViewFilter != "" && !F.getName().count(ViewFilter))
       return false;
 
     if (ViewAll)
       return true;
 
     // Check that at least one scop was detected.
     return std::distance(SD.getSD().begin(), SD.getSD().end()) > 0;
   }
 };
 char ScopViewer::ID = 0;
 
 struct ScopOnlyViewer
-    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, true> {
+    : public DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyViewer()
-      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, true>("scopsonly", ID) {}
+      : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, true>(
+            "scopsonly", ID) {}
 };
 char ScopOnlyViewer::ID = 0;
 
 struct ScopPrinter
-    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false> {
+    : public DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, false> {
   static char ID;
   ScopPrinter()
-      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false>("scops", ID) {}
+      : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, false>(
+            "scops", ID) {}
 };
 char ScopPrinter::ID = 0;
 
 struct ScopOnlyPrinter
-    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true> {
+    : public DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyPrinter()
-      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true>("scopsonly", ID) {
-  }
+      : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, true>(
+            "scopsonly", ID) {}
 };
 char ScopOnlyPrinter::ID = 0;
 
 static RegisterPass<ScopViewer> X("view-scops",
                                   "Polly - View Scops of function");
 
 static RegisterPass<ScopOnlyViewer>
     Y("view-scops-only",