InheritViz.cpp revision 35366a67baa970c287c714c957cf78a4131cf60d 
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/GraphWriter.h"
21#include "llvm/Support/raw_ostream.h"
22#include <map>
23
24using namespace llvm;
25
26namespace clang {
27
28/// InheritanceHierarchyWriter - Helper class that writes out a
29/// GraphViz file that diagrams the inheritance hierarchy starting at
30/// a given C++ class type. Note that we do not use LLVM's
31/// GraphWriter, because the interface does not permit us to properly
32/// differentiate between uses of types as virtual bases
33/// vs. non-virtual bases.
34class InheritanceHierarchyWriter {
35  ASTContext& Context;
36  llvm::raw_ostream &Out;
37  std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
38  std::set<QualType, QualTypeOrdering> KnownVirtualBases;
39
40public:
41  InheritanceHierarchyWriter(ASTContext& Context, llvm::raw_ostream& Out)
42    : Context(Context), Out(Out) { }
43
44  void WriteGraph(QualType Type) {
45    Out << "digraph \"" << DOT::EscapeString(Type.getAsString()) << "\" {\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  llvm::raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
59};
60
61void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) {
62  QualType CanonType = Context.getCanonicalType(Type);
63
64  if (FromVirtual) {
65    if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end())
66      return;
67
68    // We haven't seen this virtual base before, so display it and
69    // its bases.
70    KnownVirtualBases.insert(CanonType);
71  }
72
73  // Declare the node itself.
74  Out << "  ";
75  WriteNodeReference(Type, FromVirtual);
76
77  // Give the node a label based on the name of the class.
78  std::string TypeName = Type.getAsString();
79  Out << " [ shape=\"box\", label=\"" << DOT::EscapeString(TypeName);
80
81  // If the name of the class was a typedef or something different
82  // from the "real" class name, show the real class name in
83  // parentheses so we don't confuse ourselves.
84  if (TypeName != CanonType.getAsString()) {
85    Out << "\\n(" << CanonType.getAsString() << ")";
86  }
87
88  // Finished describing the node.
89  Out << " \"];\n";
90
91  // Display the base classes.
92  const CXXRecordDecl *Decl
93    = static_cast<const CXXRecordDecl *>(Type->getAsRecordType()->getDecl());
94  for (CXXRecordDecl::base_class_const_iterator Base = Decl->bases_begin();
95       Base != Decl->bases_end(); ++Base) {
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.
123llvm::raw_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(const_cast<CXXRecordDecl *>(this));
138  std::string ErrMsg;
139  sys::Path Filename = sys::Path::GetTemporaryDirectory(&ErrMsg);
140  if (Filename.isEmpty()) {
141    llvm::errs() << "Error: " << ErrMsg << "\n";
142    return;
143  }
144  Filename.appendComponent(Self.getAsString() + ".dot");
145  if (Filename.makeUnique(true,&ErrMsg)) {
146    llvm::errs() << "Error: " << ErrMsg << "\n";
147    return;
148  }
149
150  llvm::errs() << "Writing '" << Filename.c_str() << "'... ";
151
152  llvm::raw_fd_ostream O(Filename.c_str(), false, /*Force=*/true, ErrMsg);
153
154  if (ErrMsg.empty()) {
155    InheritanceHierarchyWriter Writer(Context, O);
156    Writer.WriteGraph(Self);
157    llvm::errs() << " done. \n";
158
159    O.close();
160
161    // Display the graph
162    DisplayGraph(Filename);
163  } else {
164    llvm::errs() << "error opening file for writing!\n";
165  }
166}
167
168}
169