InheritViz.cpp revision 263508 
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
26using namespace llvm;
27
28namespace 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.
36class InheritanceHierarchyWriter {
37  ASTContext& Context;
38  raw_ostream &Out;
39  std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
40  std::set<QualType, QualTypeOrdering> KnownVirtualBases;
41
42public:
43  InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
44    : Context(Context), Out(Out) { }
45
46  void WriteGraph(QualType Type) {
47    Out << "digraph \"" << DOT::EscapeString(Type.getAsString()) << "\" {\n";
48    WriteNode(Type, false);
49    Out << "}\n";
50  }
51
52protected:
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
63void 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.
125raw_ostream&
126InheritanceHierarchyWriter::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.
138void 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