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
26 using namespace llvm;
27
28 namespace clang {
29
30 /// InheritanceHierarchyWriter - Helper class that writes out a
31 /// GraphViz file that diagrams the inheritance hierarchy starting at
32 /// a given C++ class type. Note that we do not use LLVM's
33 /// GraphWriter, because the interface does not permit us to properly
34 /// differentiate between uses of types as virtual bases
35 /// vs. non-virtual bases.
36 class InheritanceHierarchyWriter {
37 ASTContext& Context;
38 raw_ostream &Out;
39 std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
40 std::set<QualType, QualTypeOrdering> KnownVirtualBases;
41
42 public:
InheritanceHierarchyWriter(ASTContext & Context,raw_ostream & Out)43 InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
44 : Context(Context), Out(Out) { }
45
WriteGraph(QualType Type)46 void WriteGraph(QualType Type) {
47 Out << "digraph \"" << DOT::EscapeString(Type.getAsString()) << "\" {\n";
48 WriteNode(Type, false);
49 Out << "}\n";
50 }
51
52 protected:
53 /// WriteNode - Write out the description of node in the inheritance
54 /// diagram, which may be a base class or it may be the root node.
55 void WriteNode(QualType Type, bool FromVirtual);
56
57 /// WriteNodeReference - Write out a reference to the given node,
58 /// using a unique identifier for each direct base and for the
59 /// (only) virtual base.
60 raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
61 };
62
WriteNode(QualType Type,bool FromVirtual)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=\"" << 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 (CXXRecordDecl::base_class_const_iterator Base = Decl->bases_begin();
97 Base != Decl->bases_end(); ++Base) {
98 QualType CanonBaseType = Context.getCanonicalType(Base->getType());
99
100 // If this is not virtual inheritance, bump the direct base
101 // count for the type.
102 if (!Base->isVirtual())
103 ++DirectBaseCount[CanonBaseType];
104
105 // Write out the node (if we need to).
106 WriteNode(Base->getType(), Base->isVirtual());
107
108 // Write out the edge.
109 Out << " ";
110 WriteNodeReference(Type, FromVirtual);
111 Out << " -> ";
112 WriteNodeReference(Base->getType(), Base->isVirtual());
113
114 // Write out edge attributes to show the kind of inheritance.
115 if (Base->isVirtual()) {
116 Out << " [ style=\"dashed\" ]";
117 }
118 Out << ";";
119 }
120 }
121
122 /// WriteNodeReference - Write out a reference to the given node,
123 /// using a unique identifier for each direct base and for the
124 /// (only) virtual base.
125 raw_ostream&
WriteNodeReference(QualType Type,bool FromVirtual)126 InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
127 bool FromVirtual) {
128 QualType CanonType = Context.getCanonicalType(Type);
129
130 Out << "Class_" << CanonType.getAsOpaquePtr();
131 if (!FromVirtual)
132 Out << "_" << DirectBaseCount[CanonType];
133 return Out;
134 }
135
136 /// viewInheritance - Display the inheritance hierarchy of this C++
137 /// class using GraphViz.
viewInheritance(ASTContext & Context) const138 void CXXRecordDecl::viewInheritance(ASTContext& Context) const {
139 QualType Self = Context.getTypeDeclType(this);
140
141 int FD;
142 SmallString<128> Filename;
143 error_code EC =
144 sys::fs::createTemporaryFile(Self.getAsString(), "dot", FD, Filename);
145 if (EC) {
146 llvm::errs() << "Error: " << EC.message() << "\n";
147 return;
148 }
149
150 llvm::errs() << "Writing '" << Filename << "'... ";
151
152 llvm::raw_fd_ostream O(FD, true);
153
154 InheritanceHierarchyWriter Writer(Context, O);
155 Writer.WriteGraph(Self);
156 llvm::errs() << " done. \n";
157
158 O.close();
159
160 // Display the graph
161 DisplayGraph(Filename);
162 }
163
164 }
165