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
169
170
171
172
173
|
#include "clang/AST/AST.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
#include "clang/Frontend/ASTConsumers.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Rewrite/Core/Rewriter.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include <sstream>
#include <string>
using namespace clang;
using namespace clang::driver;
using namespace clang::tooling;
static llvm::cl::OptionCategory InstrCategory("LLDB Instrumentation Generator");
class SBVisitor : public RecursiveASTVisitor<SBVisitor> {
public:
SBVisitor(Rewriter &R, ASTContext &Context)
: MyRewriter(R), Context(Context) {}
bool VisitCXXMethodDecl(CXXMethodDecl *Decl) {
// Not all decls should be registered. Please refer to that method's
// comment for details.
if (ShouldSkip(Decl))
return false;
// Print 'bool' instead of '_Bool'.
PrintingPolicy Policy(Context.getLangOpts());
Policy.Bool = true;
// Collect the functions parameter types and names.
std::vector<std::string> ParamNames;
if (!Decl->isStatic())
ParamNames.push_back("this");
for (auto *P : Decl->parameters())
ParamNames.push_back(P->getNameAsString());
// Construct the macros.
std::string Buffer;
llvm::raw_string_ostream Macro(Buffer);
if (ParamNames.empty()) {
Macro << "LLDB_INSTRUMENT()";
} else {
Macro << "LLDB_INSTRUMENT_VA(" << llvm::join(ParamNames, ", ") << ")";
}
Stmt *Body = Decl->getBody();
for (auto &C : Body->children()) {
if (C->getBeginLoc().isMacroID()) {
CharSourceRange Range =
MyRewriter.getSourceMgr().getExpansionRange(C->getSourceRange());
MyRewriter.ReplaceText(Range, Macro.str());
} else {
Macro << ";";
SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
Body->getBeginLoc(), 0, MyRewriter.getSourceMgr(),
MyRewriter.getLangOpts());
MyRewriter.InsertTextAfter(InsertLoc, Macro.str());
}
break;
}
return true;
}
private:
/// Determine whether we need to consider the given CXXMethodDecl.
///
/// Currently we skip the following cases:
/// 1. Decls outside the main source file,
/// 2. Decls that are only present in the source file,
/// 3. Decls that are not definitions,
/// 4. Non-public methods,
/// 5. Variadic methods.
/// 6. Destructors.
bool ShouldSkip(CXXMethodDecl *Decl) {
// Skip anything outside the main file.
if (!MyRewriter.getSourceMgr().isInMainFile(Decl->getBeginLoc()))
return true;
// Skip if the canonical decl in the current decl. It means that the method
// is declared in the implementation and is therefore not exposed as part
// of the API.
if (Decl == Decl->getCanonicalDecl())
return true;
// Skip decls that have no body, i.e. are just declarations.
Stmt *Body = Decl->getBody();
if (!Body)
return true;
// Skip non-public methods.
AccessSpecifier AS = Decl->getAccess();
if (AS != AccessSpecifier::AS_public)
return true;
// Skip variadic methods.
if (Decl->isVariadic())
return true;
// Skip destructors.
if (isa<CXXDestructorDecl>(Decl))
return true;
return false;
}
Rewriter &MyRewriter;
ASTContext &Context;
};
class SBConsumer : public ASTConsumer {
public:
SBConsumer(Rewriter &R, ASTContext &Context) : Visitor(R, Context) {}
// Override the method that gets called for each parsed top-level
// declaration.
bool HandleTopLevelDecl(DeclGroupRef DR) override {
for (DeclGroupRef::iterator b = DR.begin(), e = DR.end(); b != e; ++b) {
Visitor.TraverseDecl(*b);
}
return true;
}
private:
SBVisitor Visitor;
};
class SBAction : public ASTFrontendAction {
public:
SBAction() = default;
bool BeginSourceFileAction(CompilerInstance &CI) override { return true; }
void EndSourceFileAction() override { MyRewriter.overwriteChangedFiles(); }
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef File) override {
MyRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
return std::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
}
private:
Rewriter MyRewriter;
};
int main(int argc, const char **argv) {
auto ExpectedParser = CommonOptionsParser::create(
argc, argv, InstrCategory, llvm::cl::OneOrMore,
"Utility for generating the macros for LLDB's "
"instrumentation framework.");
if (!ExpectedParser) {
llvm::errs() << ExpectedParser.takeError();
return 1;
}
CommonOptionsParser &OP = ExpectedParser.get();
auto PCHOpts = std::make_shared<PCHContainerOperations>();
PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
ClangTool T(OP.getCompilations(), OP.getSourcePathList(), PCHOpts);
return T.run(newFrontendActionFactory<SBAction>().get());
}
|
