InheritViz.cpp revision 360784 
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>
24using namespace clang;
25
26namespace {
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.
33class InheritanceHierarchyWriter {
34  ASTContext& Context;
35  raw_ostream &Out;
36  std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
37  std::set<QualType, QualTypeOrdering> KnownVirtualBases;
38
39public:
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
50protected:
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
62void 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.
123raw_ostream&
124InheritanceHierarchyWriter::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.
136void 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}
160