[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

 
 namespace llvm {
 
+/// Default traits class for extracting a graph from an analysis pass.
+///
+/// This assumes that 'GraphT' is 'AnalysisT::Result *', and get it through
+/// FunctionAnalysisManager.
+template <typename Result, typename GraphT = Result &>
+struct DefaultAnalysisGraphTraits {
+  static GraphT getGraph(Result &R) { return R; }
+};
+
+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);
+    std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
+    Twine Title = GraphName + " for '" + F.getName() + "' function";
+
+    ViewGraph(Graph, Name, IsSimple, Title);
+
+    return PreservedAnalyses::all();
+  };
+
+private:
+  StringRef Name;
+};
+
+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);
+    Twine Filename = Name + "." + F.getName() + ".dot";
+    std::error_code EC;
+
+    errs() << "Writing '" << Filename << "'...";
+
+    raw_fd_ostream File(Filename.str(), EC, sys::fs::OF_TextWithCRLF);
+    std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
+    Twine Title = GraphName + " for '" + F.getName() + "' function";
+
+    if (!EC)
+      WriteGraph(File, Graph, IsSimple, Title);
+    else
+      errs() << "  error opening file for writing!";
+    errs() << "\n";
+
+    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 LegacyDOTGraphTraitsViewer : public FunctionPass {
 public:
-  DOTGraphTraitsViewer(StringRef GraphName, char &ID)
+  LegacyDOTGraphTraitsViewer(StringRef GraphName, char &ID)
       : FunctionPass(ID), Name(GraphName) {}
 
   /// Return true if this function should be processed.

   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 LegacyDOTGraphTraitsPrinter : public FunctionPass {
 public:
-  DOTGraphTraitsPrinter(StringRef GraphName, char &ID)
+  LegacyDOTGraphTraitsPrinter(StringRef GraphName, char &ID)
       : FunctionPass(ID), Name(GraphName) {}
 
   /// Return true if this function should be processed.

   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 LegacyDOTGraphTraitsModuleViewer : public ModulePass {
 public:
-  DOTGraphTraitsModuleViewer(StringRef GraphName, char &ID)
+  LegacyDOTGraphTraitsModuleViewer(StringRef GraphName, char &ID)
       : ModulePass(ID), Name(GraphName) {}
 
   bool runOnModule(Module &M) override {

   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 LegacyDOTGraphTraitsModulePrinter : public ModulePass {
 public:
-  DOTGraphTraitsModulePrinter(StringRef GraphName, char &ID)
+  LegacyDOTGraphTraitsModulePrinter(StringRef GraphName, char &ID)
       : ModulePass(ID), Name(GraphName) {}
 
   bool runOnModule(Module &M) override {

llvm/lib/Analysis/DomPrinter.cpp

   }
 };
 
-struct DomViewer : public DOTGraphTraitsViewer<
+struct DomViewer : public LegacyDOTGraphTraitsViewer<
                        DominatorTreeWrapperPass, false, DominatorTree *,
                        DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomViewer()
-      : DOTGraphTraitsViewer<DominatorTreeWrapperPass, false, DominatorTree *,
-                             DominatorTreeWrapperPassAnalysisGraphTraits>(
+      : LegacyDOTGraphTraitsViewer<DominatorTreeWrapperPass, false,
+                                   DominatorTree *,
+                                   DominatorTreeWrapperPassAnalysisGraphTraits>(
             "dom", ID) {
     initializeDomViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 
-struct DomOnlyViewer : public DOTGraphTraitsViewer<
+struct DomOnlyViewer : public LegacyDOTGraphTraitsViewer<
                            DominatorTreeWrapperPass, true, DominatorTree *,
                            DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomOnlyViewer()
-      : DOTGraphTraitsViewer<DominatorTreeWrapperPass, true, DominatorTree *,
-                             DominatorTreeWrapperPassAnalysisGraphTraits>(
+      : LegacyDOTGraphTraitsViewer<DominatorTreeWrapperPass, true,
+                                   DominatorTree *,
+                                   DominatorTreeWrapperPassAnalysisGraphTraits>(
             "domonly", ID) {
     initializeDomOnlyViewerPass(*PassRegistry::getPassRegistry());
   }

   }
 };
 
-struct PostDomViewer : public DOTGraphTraitsViewer<
-                          PostDominatorTreeWrapperPass, false,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+struct PostDomViewer
+    : public LegacyDOTGraphTraitsViewer<
+          PostDominatorTreeWrapperPass, false, PostDominatorTree *,
   static char ID;
-  PostDomViewer() :
-    DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, false,
-                         PostDominatorTree *,
-                         PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdom", ID){
-      initializePostDomViewerPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomViewer()
+      : LegacyDOTGraphTraitsViewer<
+            PostDominatorTreeWrapperPass, false, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdom", ID) {
+    initializePostDomViewerPass(*PassRegistry::getPassRegistry());
+  }
 };
 
-struct PostDomOnlyViewer : public DOTGraphTraitsViewer<
-                            PostDominatorTreeWrapperPass, true,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+struct PostDomOnlyViewer
+    : public LegacyDOTGraphTraitsViewer<
+          PostDominatorTreeWrapperPass, true, PostDominatorTree *,
   static char ID;
-  PostDomOnlyViewer() :
-    DOTGraphTraitsViewer<PostDominatorTreeWrapperPass, true,
-                         PostDominatorTree *,
-                         PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdomonly", ID){
-      initializePostDomOnlyViewerPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomOnlyViewer()
+      : LegacyDOTGraphTraitsViewer<
+            PostDominatorTreeWrapperPass, true, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdomonly",
+                                                             ID) {
 };
 } // end anonymous namespace
 

                 false, false)
 
 namespace {
-struct DomPrinter : public DOTGraphTraitsPrinter<
+struct DomPrinter : public LegacyDOTGraphTraitsPrinter<
                         DominatorTreeWrapperPass, false, DominatorTree *,
                         DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomPrinter()
-      : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, false, DominatorTree *,
-                              DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "dom", ID) {
+      : LegacyDOTGraphTraitsPrinter<
+            DominatorTreeWrapperPass, false, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("dom", ID) {
     initializeDomPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 
-struct DomOnlyPrinter : public DOTGraphTraitsPrinter<
+struct DomOnlyPrinter : public LegacyDOTGraphTraitsPrinter<
                             DominatorTreeWrapperPass, true, DominatorTree *,
                             DominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
   DomOnlyPrinter()
-      : DOTGraphTraitsPrinter<DominatorTreeWrapperPass, true, DominatorTree *,
-                              DominatorTreeWrapperPassAnalysisGraphTraits>(
-            "domonly", ID) {
+      : LegacyDOTGraphTraitsPrinter<
+            DominatorTreeWrapperPass, true, DominatorTree *,
+            DominatorTreeWrapperPassAnalysisGraphTraits>("domonly", ID) {
     initializeDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 
 struct PostDomPrinter
-  : public DOTGraphTraitsPrinter<
-                            PostDominatorTreeWrapperPass, false,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+    : public LegacyDOTGraphTraitsPrinter<
+          PostDominatorTreeWrapperPass, false, PostDominatorTree *,
+          PostDominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
-  PostDomPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, false,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdom", ID) {
-      initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomPrinter()
+      : LegacyDOTGraphTraitsPrinter<
+            PostDominatorTreeWrapperPass, false, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdom", ID) {
+    initializePostDomPrinterPass(*PassRegistry::getPassRegistry());
+  }
 };
 
 struct PostDomOnlyPrinter
-  : public DOTGraphTraitsPrinter<
-                            PostDominatorTreeWrapperPass, true,
-                            PostDominatorTree *,
-                            PostDominatorTreeWrapperPassAnalysisGraphTraits> {
+    : public LegacyDOTGraphTraitsPrinter<
+          PostDominatorTreeWrapperPass, true, PostDominatorTree *,
+          PostDominatorTreeWrapperPassAnalysisGraphTraits> {
   static char ID;
-  PostDomOnlyPrinter() :
-    DOTGraphTraitsPrinter<PostDominatorTreeWrapperPass, true,
-                          PostDominatorTree *,
-                          PostDominatorTreeWrapperPassAnalysisGraphTraits>(
-        "postdomonly", ID) {
-      initializePostDomOnlyPrinterPass(*PassRegistry::getPassRegistry());
-    }
+  PostDomOnlyPrinter()
+      : LegacyDOTGraphTraitsPrinter<
+            PostDominatorTreeWrapperPass, true, PostDominatorTree *,
+            PostDominatorTreeWrapperPassAnalysisGraphTraits>("postdomonly",
+                                                             ID) {
 };
 } // end anonymous namespace
 

llvm/lib/Analysis/RegionPrinter.cpp

 };
 
 struct RegionPrinter
-    : public DOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
+    : public LegacyDOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
                                          RegionInfoPassGraphTraits> {
   static char ID;
   RegionPrinter()
-      : DOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
+      : LegacyDOTGraphTraitsPrinter<RegionInfoPass, false, RegionInfo *,
                                     RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionPrinter::ID = 0;
 
 struct RegionOnlyPrinter
-    : public DOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
+    : public LegacyDOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
                                          RegionInfoPassGraphTraits> {
   static char ID;
   RegionOnlyPrinter()
-      : DOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
+      : LegacyDOTGraphTraitsPrinter<RegionInfoPass, true, RegionInfo *,
                                     RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionOnlyPrinterPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionOnlyPrinter::ID = 0;
 
 struct RegionViewer
-    : public DOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
+    : public LegacyDOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
                                         RegionInfoPassGraphTraits> {
   static char ID;
   RegionViewer()
-      : DOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
+      : LegacyDOTGraphTraitsViewer<RegionInfoPass, false, RegionInfo *,
                                    RegionInfoPassGraphTraits>("reg", ID) {
     initializeRegionViewerPass(*PassRegistry::getPassRegistry());
   }
 };
 char RegionViewer::ID = 0;
 
 struct RegionOnlyViewer
-    : public DOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
+    : public LegacyDOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
                                         RegionInfoPassGraphTraits> {
   static char ID;
   RegionOnlyViewer()
-      : DOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
+      : LegacyDOTGraphTraitsViewer<RegionInfoPass, true, RegionInfo *,
                                    RegionInfoPassGraphTraits>("regonly", ID) {
     initializeRegionOnlyViewerPass(*PassRegistry::getPassRegistry());
   }
 };

polly/lib/Analysis/ScopGraphPrinter.cpp

 } // end namespace llvm
 
 struct ScopViewer
-    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, false> {
+    : public LegacyDOTGraphTraitsViewer<ScopDetectionWrapperPass, false> {
   static char ID;
   ScopViewer()
-      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, false>("scops", ID) {}
+      : LegacyDOTGraphTraitsViewer<ScopDetectionWrapperPass, false>("scops",
+                                                                    ID) {}
   bool processFunction(Function &F, ScopDetectionWrapperPass &SD) override {
     if (ViewFilter != "" && !F.getName().count(ViewFilter))
       return false;

 char ScopViewer::ID = 0;
 
 struct ScopOnlyViewer
-    : public DOTGraphTraitsViewer<ScopDetectionWrapperPass, true> {
+    : public LegacyDOTGraphTraitsViewer<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyViewer()
-      : DOTGraphTraitsViewer<ScopDetectionWrapperPass, true>("scopsonly", ID) {}
+      : LegacyDOTGraphTraitsViewer<ScopDetectionWrapperPass, true>("scopsonly",
+                                                                   ID) {}
 };
 char ScopOnlyViewer::ID = 0;
 
 struct ScopPrinter
-    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false> {
+    : public LegacyDOTGraphTraitsPrinter<ScopDetectionWrapperPass, false> {
   static char ID;
   ScopPrinter()
-      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, false>("scops", ID) {}
+      : LegacyDOTGraphTraitsPrinter<ScopDetectionWrapperPass, false>("scops",
+                                                                     ID) {}
 };
 char ScopPrinter::ID = 0;
 
 struct ScopOnlyPrinter
-    : public DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true> {
+    : public LegacyDOTGraphTraitsPrinter<ScopDetectionWrapperPass, true> {
   static char ID;
   ScopOnlyPrinter()
-      : DOTGraphTraitsPrinter<ScopDetectionWrapperPass, true>("scopsonly", ID) {
-  }
+      : LegacyDOTGraphTraitsPrinter<ScopDetectionWrapperPass, true>("scopsonly",
+                                                                    ID) {}
 };
 char ScopOnlyPrinter::ID = 0;