LCOV - code coverage report
Current view: top level - include/llvm/Analysis - DOTGraphTraitsPass.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 72 31.9 %
Date: 2017-09-14 15:23:50 Functions: 4 88 4.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- DOTGraphTraitsPass.h - Print/View dotty graphs-----------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // Templates to create dotty viewer and printer passes for GraphTraits graphs.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_ANALYSIS_DOTGRAPHTRAITSPASS_H
      15             : #define LLVM_ANALYSIS_DOTGRAPHTRAITSPASS_H
      16             : 
      17             : #include "llvm/Analysis/CFGPrinter.h"
      18             : #include "llvm/Pass.h"
      19             : #include "llvm/Support/FileSystem.h"
      20             : 
      21             : namespace llvm {
      22             : 
      23             : /// \brief Default traits class for extracting a graph from an analysis pass.
      24             : ///
      25             : /// This assumes that 'GraphT' is 'AnalysisT *' and so just passes it through.
      26             : template <typename AnalysisT, typename GraphT = AnalysisT *>
      27             : struct DefaultAnalysisGraphTraits {
      28             :   static GraphT getGraph(AnalysisT *A) { return A; }
      29             : };
      30             : 
      31             : template <
      32             :     typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
      33             :     typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
      34           0 : class DOTGraphTraitsViewer : public FunctionPass {
      35             : public:
      36           0 :   DOTGraphTraitsViewer(StringRef GraphName, char &ID)
      37           0 :       : FunctionPass(ID), Name(GraphName) {}
      38             : 
      39             :   /// @brief Return true if this function should be processed.
      40             :   ///
      41             :   /// An implementation of this class my override this function to indicate that
      42             :   /// only certain functions should be viewed.
      43             :   ///
      44             :   /// @param Analysis The current analysis result for this function.
      45           0 :   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
      46           0 :     return true;
      47             :   }
      48             : 
      49           0 :   bool runOnFunction(Function &F) override {
      50           0 :     auto &Analysis = getAnalysis<AnalysisT>();
      51             : 
      52           0 :     if (!processFunction(F, Analysis))
      53             :       return false;
      54             : 
      55           0 :     GraphT Graph = AnalysisGraphTraitsT::getGraph(&Analysis);
      56           0 :     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
      57           0 :     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
      58             : 
      59           0 :     ViewGraph(Graph, Name, IsSimple, Title);
      60             : 
      61           0 :     return false;
      62             :   }
      63             : 
      64           0 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
      65           0 :     AU.setPreservesAll();
      66           0 :     AU.addRequired<AnalysisT>();
      67           0 :   }
      68             : 
      69             : private:
      70             :   std::string Name;
      71             : };
      72             : 
      73             : template <
      74             :     typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
      75             :     typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
      76           6 : class DOTGraphTraitsPrinter : public FunctionPass {
      77             : public:
      78           2 :   DOTGraphTraitsPrinter(StringRef GraphName, char &ID)
      79           6 :       : FunctionPass(ID), Name(GraphName) {}
      80             : 
      81             :   /// @brief Return true if this function should be processed.
      82             :   ///
      83             :   /// An implementation of this class my override this function to indicate that
      84             :   /// only certain functions should be printed.
      85             :   ///
      86             :   /// @param Analysis The current analysis result for this function.
      87           2 :   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
      88           2 :     return true;
      89             :   }
      90             : 
      91           2 :   bool runOnFunction(Function &F) override {
      92           2 :     auto &Analysis = getAnalysis<AnalysisT>();
      93             : 
      94           2 :     if (!processFunction(F, Analysis))
      95             :       return false;
      96             : 
      97           2 :     GraphT Graph = AnalysisGraphTraitsT::getGraph(&Analysis);
      98          10 :     std::string Filename = Name + "." + F.getName().str() + ".dot";
      99           2 :     std::error_code EC;
     100             : 
     101           4 :     errs() << "Writing '" << Filename << "'...";
     102             : 
     103           4 :     raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
     104           4 :     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
     105          12 :     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
     106             : 
     107           2 :     if (!EC)
     108           2 :       WriteGraph(File, Graph, IsSimple, Title);
     109             :     else
     110           0 :       errs() << "  error opening file for writing!";
     111           2 :     errs() << "\n";
     112             : 
     113           2 :     return false;
     114             :   }
     115             : 
     116           2 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     117           4 :     AU.setPreservesAll();
     118           2 :     AU.addRequired<AnalysisT>();
     119           2 :   }
     120             : 
     121             : private:
     122             :   std::string Name;
     123             : };
     124             : 
     125             : template <
     126             :     typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
     127             :     typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
     128           0 : class DOTGraphTraitsModuleViewer : public ModulePass {
     129             : public:
     130           0 :   DOTGraphTraitsModuleViewer(StringRef GraphName, char &ID)
     131           0 :       : ModulePass(ID), Name(GraphName) {}
     132             : 
     133           0 :   bool runOnModule(Module &M) override {
     134           0 :     GraphT Graph = AnalysisGraphTraitsT::getGraph(&getAnalysis<AnalysisT>());
     135           0 :     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
     136             : 
     137           0 :     ViewGraph(Graph, Name, IsSimple, Title);
     138             : 
     139           0 :     return false;
     140             :   }
     141             : 
     142           0 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     143           0 :     AU.setPreservesAll();
     144           0 :     AU.addRequired<AnalysisT>();
     145           0 :   }
     146             : 
     147             : private:
     148             :   std::string Name;
     149             : };
     150             : 
     151             : template <
     152             :     typename AnalysisT, bool IsSimple, typename GraphT = AnalysisT *,
     153             :     typename AnalysisGraphTraitsT = DefaultAnalysisGraphTraits<AnalysisT, GraphT> >
     154           0 : class DOTGraphTraitsModulePrinter : public ModulePass {
     155             : public:
     156           0 :   DOTGraphTraitsModulePrinter(StringRef GraphName, char &ID)
     157           0 :       : ModulePass(ID), Name(GraphName) {}
     158             : 
     159           0 :   bool runOnModule(Module &M) override {
     160           0 :     GraphT Graph = AnalysisGraphTraitsT::getGraph(&getAnalysis<AnalysisT>());
     161           0 :     std::string Filename = Name + ".dot";
     162           0 :     std::error_code EC;
     163             : 
     164           0 :     errs() << "Writing '" << Filename << "'...";
     165             : 
     166           0 :     raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
     167           0 :     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
     168             : 
     169           0 :     if (!EC)
     170           0 :       WriteGraph(File, Graph, IsSimple, Title);
     171             :     else
     172           0 :       errs() << "  error opening file for writing!";
     173           0 :     errs() << "\n";
     174             : 
     175           0 :     return false;
     176             :   }
     177             : 
     178           0 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     179           0 :     AU.setPreservesAll();
     180           0 :     AU.addRequired<AnalysisT>();
     181           0 :   }
     182             : 
     183             : private:
     184             :   std::string Name;
     185             : };
     186             : 
     187             : } // end namespace llvm
     188             : 
     189             : #endif

Generated by: LCOV version 1.13