Home | History | Annotate | Download | only in AST 
      1 //===- InheritViz.cpp - Graphviz visualization for inheritance --*- 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 //  This file implements CXXRecordDecl::viewInheritance, which
     11 //  generates a GraphViz DOT file that depicts the class inheritance
     12 //  diagram and then calls Graphviz/dot+gv on it.
     13 //
     14 //===----------------------------------------------------------------------===//
     15 
     16 #include "clang/AST/ASTContext.h"
     17 #include "clang/AST/Decl.h"
     18 #include "clang/AST/DeclCXX.h"
     19 #include "clang/AST/TypeOrdering.h"
     20 #include "llvm/Support/FileSystem.h"
     21 #include "llvm/Support/GraphWriter.h"
     22 #include "llvm/Support/raw_ostream.h"
     23 #include <map>
     24 #include <set>
     25 using namespace clang;
     26 
     27 namespace {
     28 /// InheritanceHierarchyWriter - Helper class that writes out a
     29 /// GraphViz file that diagrams the inheritance hierarchy starting at
     30 /// a given C++ class type. Note that we do not use LLVM's
     31 /// GraphWriter, because the interface does not permit us to properly
     32 /// differentiate between uses of types as virtual bases
     33 /// vs. non-virtual bases.
     34 class InheritanceHierarchyWriter {
     35   ASTContext& Context;
     36   raw_ostream &Out;
     37   std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
     38   std::set<QualType, QualTypeOrdering> KnownVirtualBases;
     39 
     40 public:
     41   InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
     42     : Context(Context), Out(Out) { }
     43 
     44   void WriteGraph(QualType Type) {
     45     Out << "digraph \"" << llvm::DOT::EscapeString(Type.getAsString())
     46         << "\" {\n";
     47     WriteNode(Type, false);
     48     Out << "}\n";
     49   }
     50 
     51 protected:
     52   /// WriteNode - Write out the description of node in the inheritance
     53   /// diagram, which may be a base class or it may be the root node.
     54   void WriteNode(QualType Type, bool FromVirtual);
     55 
     56   /// WriteNodeReference - Write out a reference to the given node,
     57   /// using a unique identifier for each direct base and for the
     58   /// (only) virtual base.
     59   raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
     60 };
     61 } // namespace
     62 
     63 void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) {
     64   QualType CanonType = Context.getCanonicalType(Type);
     65 
     66   if (FromVirtual) {
     67     if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end())
     68       return;
     69 
     70     // We haven't seen this virtual base before, so display it and
     71     // its bases.
     72     KnownVirtualBases.insert(CanonType);
     73   }
     74 
     75   // Declare the node itself.
     76   Out << "  ";
     77   WriteNodeReference(Type, FromVirtual);
     78 
     79   // Give the node a label based on the name of the class.
     80   std::string TypeName = Type.getAsString();
     81   Out << " [ shape=\"box\", label=\"" << llvm::DOT::EscapeString(TypeName);
     82 
     83   // If the name of the class was a typedef or something different
     84   // from the "real" class name, show the real class name in
     85   // parentheses so we don't confuse ourselves.
     86   if (TypeName != CanonType.getAsString()) {
     87     Out << "\\n(" << CanonType.getAsString() << ")";
     88   }
     89 
     90   // Finished describing the node.
     91   Out << " \"];\n";
     92 
     93   // Display the base classes.
     94   const CXXRecordDecl *Decl
     95     = static_cast<const CXXRecordDecl *>(Type->getAs<RecordType>()->getDecl());
     96   for (const auto &Base : Decl->bases()) {
     97     QualType CanonBaseType = Context.getCanonicalType(Base.getType());
     98 
     99     // If this is not virtual inheritance, bump the direct base
    100     // count for the type.
    101     if (!Base.isVirtual())
    102       ++DirectBaseCount[CanonBaseType];
    103 
    104     // Write out the node (if we need to).
    105     WriteNode(Base.getType(), Base.isVirtual());
    106 
    107     // Write out the edge.
    108     Out << "  ";
    109     WriteNodeReference(Type, FromVirtual);
    110     Out << " -> ";
    111     WriteNodeReference(Base.getType(), Base.isVirtual());
    112 
    113     // Write out edge attributes to show the kind of inheritance.
    114     if (Base.isVirtual()) {
    115       Out << " [ style=\"dashed\" ]";
    116     }
    117     Out << ";";
    118   }
    119 }
    120 
    121 /// WriteNodeReference - Write out a reference to the given node,
    122 /// using a unique identifier for each direct base and for the
    123 /// (only) virtual base.
    124 raw_ostream&
    125 InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
    126                                                bool FromVirtual) {
    127   QualType CanonType = Context.getCanonicalType(Type);
    128 
    129   Out << "Class_" << CanonType.getAsOpaquePtr();
    130   if (!FromVirtual)
    131     Out << "_" << DirectBaseCount[CanonType];
    132   return Out;
    133 }
    134 
    135 /// viewInheritance - Display the inheritance hierarchy of this C++
    136 /// class using GraphViz.
    137 void CXXRecordDecl::viewInheritance(ASTContext& Context) const {
    138   QualType Self = Context.getTypeDeclType(this);
    139 
    140   int FD;
    141   SmallString<128> Filename;
    142   if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
    143           Self.getAsString(), "dot", FD, Filename)) {
    144     llvm::errs() << "Error: " << EC.message() << "\n";
    145     return;
    146   }
    147 
    148   llvm::errs() << "Writing '" << Filename << "'... ";
    149 
    150   llvm::raw_fd_ostream O(FD, true);
    151 
    152   InheritanceHierarchyWriter Writer(Context, O);
    153   Writer.WriteGraph(Self);
    154   llvm::errs() << " done. \n";
    155 
    156   O.close();
    157 
    158   // Display the graph
    159   DisplayGraph(Filename);
    160 }
    161