| 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 |
} |