1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
| //===--- tools/pp-trace/PPTrace.cpp - Clang preprocessor tracer -----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements pp-trace, a tool for displaying a textual trace
// of the Clang preprocessor activity. It's based on a derivation of the
// PPCallbacks class, that once registerd with Clang, receives callback calls
// to its virtual members, and outputs the information passed to the callbacks
// in a high-level YAML format.
//
// The pp-trace tool also serves as the basis for a test of the PPCallbacks
// mechanism.
//
// The pp-trace tool supports the following general command line format:
//
// pp-trace [options] file... [-- compiler options]
//
// Basically you put the pp-trace options first, then the source file or files,
// and then -- followed by any options you want to pass to the compiler.
//
//===----------------------------------------------------------------------===//
#include "PPCallbacksTracker.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Driver/Options.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendAction.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/Execution.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Option/OptTable.h"
#include "llvm/Option/Option.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/GlobPattern.h"
#include "llvm/Support/InitLLVM.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ToolOutputFile.h"
#include "llvm/Support/WithColor.h"
#include <string>
#include <vector>
using namespace llvm;
namespace clang {
namespace pp_trace {
static cl::OptionCategory Cat("pp-trace options");
static cl::opt<std::string> Callbacks(
"callbacks", cl::init("*"),
cl::desc("Comma-separated list of globs describing the list of callbacks "
"to output. Globs are processed in order of appearance. Globs "
"with the '-' prefix remove callbacks from the set. e.g. "
"'*,-Macro*'."),
cl::cat(Cat));
static cl::opt<std::string> OutputFileName(
"output", cl::init("-"),
cl::desc("Output trace to the given file name or '-' for stdout."),
cl::cat(Cat));
LLVM_ATTRIBUTE_NORETURN static void error(Twine Message) {
WithColor::error() << Message << '\n';
exit(1);
}
namespace {
class PPTraceAction : public ASTFrontendAction {
public:
PPTraceAction(const FilterType &Filters, raw_ostream &OS)
: Filters(Filters), OS(OS) {}
protected:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
Preprocessor &PP = CI.getPreprocessor();
PP.addPPCallbacks(
std::make_unique<PPCallbacksTracker>(Filters, CallbackCalls, PP));
return std::make_unique<ASTConsumer>();
}
void EndSourceFileAction() override {
OS << "---\n";
for (const CallbackCall &Callback : CallbackCalls) {
OS << "- Callback: " << Callback.Name << "\n";
for (const Argument &Arg : Callback.Arguments)
OS << " " << Arg.Name << ": " << Arg.Value << "\n";
}
OS << "...\n";
CallbackCalls.clear();
}
private:
const FilterType &Filters;
raw_ostream &OS;
std::vector<CallbackCall> CallbackCalls;
};
class PPTraceFrontendActionFactory : public tooling::FrontendActionFactory {
public:
PPTraceFrontendActionFactory(const FilterType &Filters, raw_ostream &OS)
: Filters(Filters), OS(OS) {}
std::unique_ptr<FrontendAction> create() override {
return std::make_unique<PPTraceAction>(Filters, OS);
}
private:
const FilterType &Filters;
raw_ostream &OS;
};
} // namespace
} // namespace pp_trace
} // namespace clang
int main(int argc, const char **argv) {
using namespace clang::pp_trace;
InitLLVM X(argc, argv);
auto OptionsParser = clang::tooling::CommonOptionsParser::create(
argc, argv, Cat, llvm::cl::ZeroOrMore);
if (!OptionsParser)
error(toString(OptionsParser.takeError()));
// Parse the IgnoreCallbacks list into strings.
SmallVector<StringRef, 32> Patterns;
FilterType Filters;
StringRef(Callbacks).split(Patterns, ",",
/*MaxSplit=*/-1, /*KeepEmpty=*/false);
for (StringRef Pattern : Patterns) {
Pattern = Pattern.trim();
bool Enabled = !Pattern.consume_front("-");
Expected<GlobPattern> Pat = GlobPattern::create(Pattern);
if (Pat)
Filters.emplace_back(std::move(*Pat), Enabled);
else
error(toString(Pat.takeError()));
}
// Create the tool and run the compilation.
clang::tooling::ClangTool Tool(OptionsParser->getCompilations(),
OptionsParser->getSourcePathList());
std::error_code EC;
llvm::ToolOutputFile Out(OutputFileName, EC, llvm::sys::fs::OF_Text);
if (EC)
error(EC.message());
PPTraceFrontendActionFactory Factory(Filters, Out.os());
int HadErrors = Tool.run(&Factory);
// If we had errors, exit early.
if (HadErrors)
return HadErrors;
Out.keep();
return 0;
}
|