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