1//===--- DependencyGraph.cpp - Generate dependency file -------------------===//
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 code generates a header dependency graph in DOT format, for use
11// with, e.g., GraphViz.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Frontend/Utils.h"
16#include "clang/Basic/FileManager.h"
17#include "clang/Basic/SourceManager.h"
18#include "clang/Frontend/FrontendDiagnostic.h"
19#include "clang/Lex/PPCallbacks.h"
20#include "clang/Lex/Preprocessor.h"
21#include "llvm/ADT/SetVector.h"
22#include "llvm/Support/GraphWriter.h"
23#include "llvm/Support/raw_ostream.h"
24
25using namespace clang;
26namespace DOT = llvm::DOT;
27
28namespace {
29class DependencyGraphCallback : public PPCallbacks {
30  const Preprocessor *PP;
31  std::string OutputFile;
32  std::string SysRoot;
33  llvm::SetVector<const FileEntry *> AllFiles;
34  typedef llvm::DenseMap<const FileEntry *,
35                         SmallVector<const FileEntry *, 2> > DependencyMap;
36
37  DependencyMap Dependencies;
38
39private:
40  raw_ostream &writeNodeReference(raw_ostream &OS,
41                                  const FileEntry *Node);
42  void OutputGraphFile();
43
44public:
45  DependencyGraphCallback(const Preprocessor *_PP, StringRef OutputFile,
46                          StringRef SysRoot)
47    : PP(_PP), OutputFile(OutputFile.str()), SysRoot(SysRoot.str()) { }
48
49  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
50                          StringRef FileName, bool IsAngled,
51                          CharSourceRange FilenameRange, const FileEntry *File,
52                          StringRef SearchPath, StringRef RelativePath,
53                          const Module *Imported) override;
54
55  void EndOfMainFile() override {
56    OutputGraphFile();
57  }
58
59};
60}
61
62void clang::AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,
63                                     StringRef SysRoot) {
64  PP.addPPCallbacks(llvm::make_unique<DependencyGraphCallback>(&PP, OutputFile,
65                                                               SysRoot));
66}
67
68void DependencyGraphCallback::InclusionDirective(SourceLocation HashLoc,
69                                                 const Token &IncludeTok,
70                                                 StringRef FileName,
71                                                 bool IsAngled,
72                                                 CharSourceRange FilenameRange,
73                                                 const FileEntry *File,
74                                                 StringRef SearchPath,
75                                                 StringRef RelativePath,
76                                                 const Module *Imported) {
77  if (!File)
78    return;
79
80  SourceManager &SM = PP->getSourceManager();
81  const FileEntry *FromFile
82    = SM.getFileEntryForID(SM.getFileID(SM.getExpansionLoc(HashLoc)));
83  if (!FromFile)
84    return;
85
86  Dependencies[FromFile].push_back(File);
87
88  AllFiles.insert(File);
89  AllFiles.insert(FromFile);
90}
91
92raw_ostream &
93DependencyGraphCallback::writeNodeReference(raw_ostream &OS,
94                                            const FileEntry *Node) {
95  OS << "header_" << Node->getUID();
96  return OS;
97}
98
99void DependencyGraphCallback::OutputGraphFile() {
100  std::error_code EC;
101  llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::F_Text);
102  if (EC) {
103    PP->getDiagnostics().Report(diag::err_fe_error_opening) << OutputFile
104                                                            << EC.message();
105    return;
106  }
107
108  OS << "digraph \"dependencies\" {\n";
109
110  // Write the nodes
111  for (unsigned I = 0, N = AllFiles.size(); I != N; ++I) {
112    // Write the node itself.
113    OS.indent(2);
114    writeNodeReference(OS, AllFiles[I]);
115    OS << " [ shape=\"box\", label=\"";
116    StringRef FileName = AllFiles[I]->getName();
117    if (FileName.startswith(SysRoot))
118      FileName = FileName.substr(SysRoot.size());
119
120    OS << DOT::EscapeString(FileName)
121    << "\"];\n";
122  }
123
124  // Write the edges
125  for (DependencyMap::iterator F = Dependencies.begin(),
126                            FEnd = Dependencies.end();
127       F != FEnd; ++F) {
128    for (unsigned I = 0, N = F->second.size(); I != N; ++I) {
129      OS.indent(2);
130      writeNodeReference(OS, F->first);
131      OS << " -> ";
132      writeNodeReference(OS, F->second[I]);
133      OS << ";\n";
134    }
135  }
136  OS << "}\n";
137}
138
139