[Analysis] Avoid virtual dtor. NFC.

[Meinersbur]

Summary

Replace virtual destructor by a protected non-virtual one. Additionally also making derived structs as virtual avoids the warning from reappearing.

Also see the mailing list discussion: https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20220516/1038290.html

[dblaikie]

Awesome, thanks!

[YangKeao]

Thanks.

llvm/include/llvm/Analysis/DOTGraphTraitsPass.h

 template <typename AnalysisT, bool IsSimple,
           typename GraphT = typename AnalysisT::Result *,
           typename AnalysisGraphTraitsT =
               DefaultAnalysisGraphTraits<typename AnalysisT::Result &, GraphT>>
 struct DOTGraphTraitsViewer
     : PassInfoMixin<DOTGraphTraitsViewer<AnalysisT, IsSimple, GraphT,
                                          AnalysisGraphTraitsT>> {
   DOTGraphTraitsViewer(StringRef GraphName) : Name(GraphName) {}
-  virtual ~DOTGraphTraitsViewer() {}
 
   /// 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();
   };
 
+protected:
+  /// Avoid compiler warning "has virtual functions but non-virtual destructor
+  /// [-Wnon-virtual-dtor]" in derived classes.
+  ///
+  /// DOTGraphTraitsViewer is also used as a mixin for avoiding repeated
+  /// implementation of viewer passes, ie there should be no
+  /// runtime-polymorphisms/downcasting involving this class and hence no
+  /// virtual destructor needed. Making this dtor protected stops accidental
+  /// invocation when the derived class destructor should have been called.
+  /// Those derived classes sould be marked final to avoid the warning.
+  ~DOTGraphTraitsViewer() {}
+
 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";

 template <typename AnalysisT, bool IsSimple,
           typename GraphT = typename AnalysisT::Result *,
           typename AnalysisGraphTraitsT =
               DefaultAnalysisGraphTraits<typename AnalysisT::Result &, GraphT>>
 struct DOTGraphTraitsPrinter
     : PassInfoMixin<DOTGraphTraitsPrinter<AnalysisT, IsSimple, GraphT,
                                           AnalysisGraphTraitsT>> {
   DOTGraphTraitsPrinter(StringRef GraphName) : Name(GraphName) {}
-  virtual ~DOTGraphTraitsPrinter() {}
 
   /// 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();
   };
 
+protected:
+  /// Avoid compiler warning "has virtual functions but non-virtual destructor
+  /// [-Wnon-virtual-dtor]" in derived classes.
+  ///
+  /// DOTGraphTraitsViewer is also used as a mixin for avoiding repeated
+  /// implementation of viewer passes, ie there should be no
+  /// runtime-polymorphisms/downcasting involving this class and hence no
+  /// virtual destructor needed. Making this dtor protected stops accidental
+  /// invocation when the derived class destructor should have been called.
+  /// Those derived classes sould be marked final to avoid the warning.
+  ~DOTGraphTraitsPrinter() {}
+
 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 *>

llvm/include/llvm/Analysis/DomPrinter.h

struct DOTGraphTraits<PostDominatorTree *>
   }
 
   std::string getNodeLabel(DomTreeNode *Node,
                            PostDominatorTree *G) {
     return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
   }
 };
 
-struct DomViewer : public DOTGraphTraitsViewer<DominatorTreeAnalysis, false> {
+struct DomViewer final : DOTGraphTraitsViewer<DominatorTreeAnalysis, false> {
   DomViewer() : DOTGraphTraitsViewer<DominatorTreeAnalysis, false>("dom") {}
 };
 
-struct DomOnlyViewer
-    : public DOTGraphTraitsViewer<DominatorTreeAnalysis, true> {
+struct DomOnlyViewer final : DOTGraphTraitsViewer<DominatorTreeAnalysis, true> {
   DomOnlyViewer()
       : DOTGraphTraitsViewer<DominatorTreeAnalysis, true>("domonly") {}
 };
 
-struct PostDomViewer
-    : public DOTGraphTraitsViewer<PostDominatorTreeAnalysis, false> {
+struct PostDomViewer final
+    : DOTGraphTraitsViewer<PostDominatorTreeAnalysis, false> {
   PostDomViewer()
       : DOTGraphTraitsViewer<PostDominatorTreeAnalysis, false>("postdom") {}
 };
 
-struct PostDomOnlyViewer
-    : public DOTGraphTraitsViewer<PostDominatorTreeAnalysis, true> {
+struct PostDomOnlyViewer final
+    : DOTGraphTraitsViewer<PostDominatorTreeAnalysis, true> {
   PostDomOnlyViewer()
       : DOTGraphTraitsViewer<PostDominatorTreeAnalysis, true>("postdomonly") {}
 };
 
-struct DomPrinter : public DOTGraphTraitsPrinter<DominatorTreeAnalysis, false> {
+struct DomPrinter final : DOTGraphTraitsPrinter<DominatorTreeAnalysis, false> {
   DomPrinter() : DOTGraphTraitsPrinter<DominatorTreeAnalysis, false>("dom") {}
 };
 
-struct DomOnlyPrinter
-    : public DOTGraphTraitsPrinter<DominatorTreeAnalysis, true> {
+struct DomOnlyPrinter final
+    : DOTGraphTraitsPrinter<DominatorTreeAnalysis, true> {
   DomOnlyPrinter()
       : DOTGraphTraitsPrinter<DominatorTreeAnalysis, true>("domonly") {}
 };
 
-struct PostDomPrinter
-    : public DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, false> {
+struct PostDomPrinter final
+    : DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, false> {
   PostDomPrinter()
       : DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, false>("postdom") {}
 };
 
-struct PostDomOnlyPrinter
-    : public DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, true> {
+struct PostDomOnlyPrinter final
+    : DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, true> {
   PostDomOnlyPrinter()
       : DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, true>("postdomonly") {}
 };
 } // namespace llvm
 
 namespace llvm {
   class FunctionPass;
   FunctionPass *createDomPrinterWrapperPassPass();