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 24 using namespace llvm; 25 26 namespace 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. 34 class InheritanceHierarchyWriter { 35 ASTContext& Context; 36 raw_ostream &Out; 37 std::map<QualType, int, QualTypeOrdering> DirectBaseCount; 38 std::set<QualType, QualTypeOrdering> KnownVirtualBases; 39 40 public: 41 InheritanceHierarchyWriter(ASTContext& Context, 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 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 61 void 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->getAs<RecordType>()->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. 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 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(), 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
