clang/lib/AST/InheritViz.cpp

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