2008-10-23 05:13:31 +08:00
|
|
|
//===- InheritViz.cpp - Graphviz visualization for inheritance --*- C++ -*-===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2008-10-23 05:13:31 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements CXXRecordDecl::viewInheritance, which
|
|
|
|
// generates a GraphViz DOT file that depicts the class inheritance
|
|
|
|
// diagram and then calls Graphviz/dot+gv on it.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
#include "clang/AST/Decl.h"
|
|
|
|
#include "clang/AST/DeclCXX.h"
|
|
|
|
#include "clang/AST/TypeOrdering.h"
|
2013-06-24 23:00:11 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2008-10-23 05:13:31 +08:00
|
|
|
#include "llvm/Support/GraphWriter.h"
|
2008-10-24 07:51:23 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2008-10-23 05:13:31 +08:00
|
|
|
#include <map>
|
2013-06-19 23:31:27 +08:00
|
|
|
#include <set>
|
2015-03-09 23:03:20 +08:00
|
|
|
using namespace clang;
|
2008-10-23 05:13:31 +08:00
|
|
|
|
2015-03-09 23:03:20 +08:00
|
|
|
namespace {
|
2008-10-23 05:13:31 +08:00
|
|
|
/// InheritanceHierarchyWriter - Helper class that writes out a
|
|
|
|
/// GraphViz file that diagrams the inheritance hierarchy starting at
|
|
|
|
/// a given C++ class type. Note that we do not use LLVM's
|
|
|
|
/// GraphWriter, because the interface does not permit us to properly
|
|
|
|
/// differentiate between uses of types as virtual bases
|
|
|
|
/// vs. non-virtual bases.
|
|
|
|
class InheritanceHierarchyWriter {
|
|
|
|
ASTContext& Context;
|
2011-07-23 18:55:15 +08:00
|
|
|
raw_ostream &Out;
|
2008-10-23 05:13:31 +08:00
|
|
|
std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
|
|
|
|
std::set<QualType, QualTypeOrdering> KnownVirtualBases;
|
|
|
|
|
|
|
|
public:
|
2011-07-23 18:55:15 +08:00
|
|
|
InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
|
2008-10-23 05:13:31 +08:00
|
|
|
: Context(Context), Out(Out) { }
|
|
|
|
|
|
|
|
void WriteGraph(QualType Type) {
|
2015-03-09 23:03:20 +08:00
|
|
|
Out << "digraph \"" << llvm::DOT::EscapeString(Type.getAsString())
|
|
|
|
<< "\" {\n";
|
2008-10-23 05:13:31 +08:00
|
|
|
WriteNode(Type, false);
|
|
|
|
Out << "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
/// WriteNode - Write out the description of node in the inheritance
|
|
|
|
/// diagram, which may be a base class or it may be the root node.
|
|
|
|
void WriteNode(QualType Type, bool FromVirtual);
|
|
|
|
|
|
|
|
/// WriteNodeReference - Write out a reference to the given node,
|
|
|
|
/// using a unique identifier for each direct base and for the
|
|
|
|
/// (only) virtual base.
|
2011-07-23 18:55:15 +08:00
|
|
|
raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
|
2008-10-23 05:13:31 +08:00
|
|
|
};
|
2015-03-09 23:03:20 +08:00
|
|
|
} // namespace
|
2008-10-23 05:13:31 +08:00
|
|
|
|
|
|
|
void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) {
|
|
|
|
QualType CanonType = Context.getCanonicalType(Type);
|
|
|
|
|
|
|
|
if (FromVirtual) {
|
|
|
|
if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// We haven't seen this virtual base before, so display it and
|
|
|
|
// its bases.
|
|
|
|
KnownVirtualBases.insert(CanonType);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Declare the node itself.
|
|
|
|
Out << " ";
|
|
|
|
WriteNodeReference(Type, FromVirtual);
|
|
|
|
|
|
|
|
// Give the node a label based on the name of the class.
|
|
|
|
std::string TypeName = Type.getAsString();
|
2015-03-09 23:03:20 +08:00
|
|
|
Out << " [ shape=\"box\", label=\"" << llvm::DOT::EscapeString(TypeName);
|
2008-10-23 05:13:31 +08:00
|
|
|
|
|
|
|
// If the name of the class was a typedef or something different
|
|
|
|
// from the "real" class name, show the real class name in
|
|
|
|
// parentheses so we don't confuse ourselves.
|
|
|
|
if (TypeName != CanonType.getAsString()) {
|
|
|
|
Out << "\\n(" << CanonType.getAsString() << ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finished describing the node.
|
|
|
|
Out << " \"];\n";
|
|
|
|
|
|
|
|
// Display the base classes.
|
2009-09-09 23:08:12 +08:00
|
|
|
const CXXRecordDecl *Decl
|
2009-07-30 05:53:49 +08:00
|
|
|
= static_cast<const CXXRecordDecl *>(Type->getAs<RecordType>()->getDecl());
|
2014-03-13 23:41:46 +08:00
|
|
|
for (const auto &Base : Decl->bases()) {
|
|
|
|
QualType CanonBaseType = Context.getCanonicalType(Base.getType());
|
2008-10-23 05:13:31 +08:00
|
|
|
|
|
|
|
// If this is not virtual inheritance, bump the direct base
|
|
|
|
// count for the type.
|
2014-03-13 23:41:46 +08:00
|
|
|
if (!Base.isVirtual())
|
2008-10-23 05:13:31 +08:00
|
|
|
++DirectBaseCount[CanonBaseType];
|
|
|
|
|
|
|
|
// Write out the node (if we need to).
|
2014-03-13 23:41:46 +08:00
|
|
|
WriteNode(Base.getType(), Base.isVirtual());
|
2008-10-23 05:13:31 +08:00
|
|
|
|
|
|
|
// Write out the edge.
|
|
|
|
Out << " ";
|
|
|
|
WriteNodeReference(Type, FromVirtual);
|
|
|
|
Out << " -> ";
|
2014-03-13 23:41:46 +08:00
|
|
|
WriteNodeReference(Base.getType(), Base.isVirtual());
|
2008-10-23 05:13:31 +08:00
|
|
|
|
|
|
|
// Write out edge attributes to show the kind of inheritance.
|
2014-03-13 23:41:46 +08:00
|
|
|
if (Base.isVirtual()) {
|
2008-10-23 05:13:31 +08:00
|
|
|
Out << " [ style=\"dashed\" ]";
|
|
|
|
}
|
|
|
|
Out << ";";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// WriteNodeReference - Write out a reference to the given node,
|
|
|
|
/// using a unique identifier for each direct base and for the
|
|
|
|
/// (only) virtual base.
|
2011-07-23 18:55:15 +08:00
|
|
|
raw_ostream&
|
2009-09-09 23:08:12 +08:00
|
|
|
InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
|
2008-10-23 05:13:31 +08:00
|
|
|
bool FromVirtual) {
|
|
|
|
QualType CanonType = Context.getCanonicalType(Type);
|
|
|
|
|
|
|
|
Out << "Class_" << CanonType.getAsOpaquePtr();
|
|
|
|
if (!FromVirtual)
|
|
|
|
Out << "_" << DirectBaseCount[CanonType];
|
|
|
|
return Out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// viewInheritance - Display the inheritance hierarchy of this C++
|
|
|
|
/// class using GraphViz.
|
2008-10-25 03:53:54 +08:00
|
|
|
void CXXRecordDecl::viewInheritance(ASTContext& Context) const {
|
2013-01-14 08:25:25 +08:00
|
|
|
QualType Self = Context.getTypeDeclType(this);
|
2013-06-24 23:00:11 +08:00
|
|
|
|
|
|
|
int FD;
|
|
|
|
SmallString<128> Filename;
|
2015-03-09 23:03:20 +08:00
|
|
|
if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
|
|
|
|
Self.getAsString(), "dot", FD, Filename)) {
|
2013-06-24 23:00:11 +08:00
|
|
|
llvm::errs() << "Error: " << EC.message() << "\n";
|
2008-10-23 05:13:31 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-24 23:00:11 +08:00
|
|
|
llvm::errs() << "Writing '" << Filename << "'... ";
|
2008-10-23 05:13:31 +08:00
|
|
|
|
2013-06-24 23:00:11 +08:00
|
|
|
llvm::raw_fd_ostream O(FD, true);
|
2008-10-23 05:13:31 +08:00
|
|
|
|
2013-06-24 23:00:11 +08:00
|
|
|
InheritanceHierarchyWriter Writer(Context, O);
|
|
|
|
Writer.WriteGraph(Self);
|
|
|
|
llvm::errs() << " done. \n";
|
2008-10-23 05:13:31 +08:00
|
|
|
|
2013-06-24 23:00:11 +08:00
|
|
|
O.close();
|
2011-03-02 03:50:49 +08:00
|
|
|
|
2013-06-24 23:00:11 +08:00
|
|
|
// Display the graph
|
|
|
|
DisplayGraph(Filename);
|
2008-10-23 05:13:31 +08:00
|
|
|
}
|