1//===-- clang-import-test.cpp - ASTImporter/ExternalASTSource testbed -----===//
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#include "clang/AST/ASTContext.h"
10#include "clang/AST/ASTImporter.h"
11#include "clang/AST/DeclObjC.h"
12#include "clang/AST/ExternalASTMerger.h"
13#include "clang/Basic/Builtins.h"
14#include "clang/Basic/FileManager.h"
15#include "clang/Basic/IdentifierTable.h"
16#include "clang/Basic/SourceLocation.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/Basic/TargetOptions.h"
19#include "clang/CodeGen/ModuleBuilder.h"
20#include "clang/Driver/Types.h"
21#include "clang/Frontend/ASTConsumers.h"
22#include "clang/Frontend/CompilerInstance.h"
23#include "clang/Frontend/MultiplexConsumer.h"
24#include "clang/Frontend/TextDiagnosticBuffer.h"
25#include "clang/Lex/Lexer.h"
26#include "clang/Lex/Preprocessor.h"
27#include "clang/Parse/ParseAST.h"
28
29#include "llvm/IR/LLVMContext.h"
30#include "llvm/IR/Module.h"
31#include "llvm/Support/CommandLine.h"
32#include "llvm/Support/Error.h"
33#include "llvm/Support/Signals.h"
34#include "llvm/Support/VirtualFileSystem.h"
35#include "llvm/TargetParser/Host.h"
36
37#include <memory>
38#include <string>
39
40using namespace clang;
41
42static llvm::cl::opt<std::string> Expression(
43 "expression", llvm::cl::Required,
44 llvm::cl::desc("Path to a file containing the expression to parse"));
45
46static llvm::cl::list<std::string>
47 Imports("import",
48 llvm::cl::desc("Path to a file containing declarations to import"));
49
50static llvm::cl::opt<bool>
51 Direct("direct", llvm::cl::Optional,
52 llvm::cl::desc("Use the parsed declarations without indirection"));
53
54static llvm::cl::opt<bool> UseOrigins(
55 "use-origins", llvm::cl::Optional,
56 llvm::cl::desc(
57 "Use DeclContext origin information for more accurate lookups"));
58
59static llvm::cl::list<std::string>
60 ClangArgs("Xcc",
61 llvm::cl::desc("Argument to pass to the CompilerInvocation"),
62 llvm::cl::CommaSeparated);
63
64static llvm::cl::opt<std::string>
65 Input("x", llvm::cl::Optional,
66 llvm::cl::desc("The language to parse (default: c++)"),
67 llvm::cl::init(Val: "c++"));
68
69static llvm::cl::opt<bool> ObjCARC("objc-arc", llvm::cl::init(Val: false),
70 llvm::cl::desc("Emable ObjC ARC"));
71
72static llvm::cl::opt<bool> DumpAST("dump-ast", llvm::cl::init(Val: false),
73 llvm::cl::desc("Dump combined AST"));
74
75static llvm::cl::opt<bool> DumpIR("dump-ir", llvm::cl::init(Val: false),
76 llvm::cl::desc("Dump IR from final parse"));
77
78namespace init_convenience {
79class TestDiagnosticConsumer : public DiagnosticConsumer {
80private:
81 std::unique_ptr<TextDiagnosticBuffer> Passthrough;
82 const LangOptions *LangOpts = nullptr;
83
84public:
85 TestDiagnosticConsumer()
86 : Passthrough(std::make_unique<TextDiagnosticBuffer>()) {}
87
88 void BeginSourceFile(const LangOptions &LangOpts,
89 const Preprocessor *PP = nullptr) override {
90 this->LangOpts = &LangOpts;
91 return Passthrough->BeginSourceFile(LangOpts, PP);
92 }
93
94 void EndSourceFile() override {
95 this->LangOpts = nullptr;
96 Passthrough->EndSourceFile();
97 }
98
99 bool IncludeInDiagnosticCounts() const override {
100 return Passthrough->IncludeInDiagnosticCounts();
101 }
102
103private:
104 static void PrintSourceForLocation(const SourceLocation &Loc,
105 SourceManager &SM) {
106 const char *LocData = SM.getCharacterData(SL: Loc, /*Invalid=*/nullptr);
107 unsigned LocColumn =
108 SM.getSpellingColumnNumber(Loc, /*Invalid=*/nullptr) - 1;
109 FileID FID = SM.getFileID(SpellingLoc: Loc);
110 llvm::MemoryBufferRef Buffer = SM.getBufferOrFake(FID, Loc);
111
112 assert(LocData >= Buffer.getBufferStart() &&
113 LocData < Buffer.getBufferEnd());
114
115 const char *LineBegin = LocData - LocColumn;
116
117 assert(LineBegin >= Buffer.getBufferStart());
118
119 const char *LineEnd = nullptr;
120
121 for (LineEnd = LineBegin; *LineEnd != '\n' && *LineEnd != '\r' &&
122 LineEnd < Buffer.getBufferEnd();
123 ++LineEnd)
124 ;
125
126 llvm::StringRef LineString(LineBegin, LineEnd - LineBegin);
127
128 llvm::errs() << LineString << '\n';
129 llvm::errs().indent(NumSpaces: LocColumn);
130 llvm::errs() << '^';
131 llvm::errs() << '\n';
132 }
133
134 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
135 const Diagnostic &Info) override {
136 if (Info.hasSourceManager() && LangOpts) {
137 SourceManager &SM = Info.getSourceManager();
138
139 if (Info.getLocation().isValid()) {
140 Info.getLocation().print(OS&: llvm::errs(), SM);
141 llvm::errs() << ": ";
142 }
143
144 SmallString<16> DiagText;
145 Info.FormatDiagnostic(OutStr&: DiagText);
146 llvm::errs() << DiagText << '\n';
147
148 if (Info.getLocation().isValid()) {
149 PrintSourceForLocation(Loc: Info.getLocation(), SM);
150 }
151
152 for (const CharSourceRange &Range : Info.getRanges()) {
153 bool Invalid = true;
154 StringRef Ref = Lexer::getSourceText(Range, SM, LangOpts: *LangOpts, Invalid: &Invalid);
155 if (!Invalid) {
156 llvm::errs() << Ref << '\n';
157 }
158 }
159 }
160 DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
161 }
162};
163
164std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
165 DiagnosticOptions DiagOpts;
166 auto DC = std::make_unique<TestDiagnosticConsumer>();
167 auto Diags = CompilerInstance::createDiagnostics(
168 VFS&: *llvm::vfs::getRealFileSystem(), Opts&: DiagOpts, Client: DC.get(),
169 /*ShouldOwnClient=*/false);
170
171 auto Inv = std::make_unique<CompilerInvocation>();
172
173 std::vector<const char *> ClangArgv(ClangArgs.size());
174 std::transform(first: ClangArgs.begin(), last: ClangArgs.end(), result: ClangArgv.begin(),
175 unary_op: [](const std::string &s) -> const char * { return s.data(); });
176 CompilerInvocation::CreateFromArgs(Res&: *Inv, CommandLineArgs: ClangArgv, Diags&: *Diags);
177
178 {
179 using namespace driver::types;
180 ID Id = lookupTypeForTypeSpecifier(Name: Input.c_str());
181 assert(Id != TY_INVALID);
182 if (isCXX(Id)) {
183 Inv->getLangOpts().CPlusPlus = true;
184 Inv->getLangOpts().CPlusPlus11 = true;
185 Inv->getHeaderSearchOpts().UseLibcxx = true;
186 }
187 if (isObjC(Id)) {
188 Inv->getLangOpts().ObjC = 1;
189 }
190 }
191 Inv->getLangOpts().ObjCAutoRefCount = ObjCARC;
192
193 Inv->getLangOpts().Bool = true;
194 Inv->getLangOpts().WChar = true;
195 Inv->getLangOpts().Blocks = true;
196 Inv->getLangOpts().DebuggerSupport = true;
197 Inv->getLangOpts().SpellChecking = false;
198 Inv->getLangOpts().ThreadsafeStatics = false;
199 Inv->getLangOpts().AccessControl = false;
200 Inv->getLangOpts().DollarIdents = true;
201 Inv->getLangOpts().Exceptions = true;
202 Inv->getLangOpts().CXXExceptions = true;
203 // Needed for testing dynamic_cast.
204 Inv->getLangOpts().RTTI = true;
205 Inv->getCodeGenOpts().setDebugInfo(llvm::codegenoptions::FullDebugInfo);
206 Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
207
208 auto Ins = std::make_unique<CompilerInstance>(args: std::move(Inv));
209
210 Ins->createDiagnostics(VFS&: *llvm::vfs::getRealFileSystem(), Client: DC.release(),
211 /*ShouldOwnClient=*/true);
212
213 TargetInfo *TI = TargetInfo::CreateTargetInfo(
214 Diags&: Ins->getDiagnostics(), Opts&: Ins->getInvocation().getTargetOpts());
215 Ins->setTarget(TI);
216 Ins->getTarget().adjust(Diags&: Ins->getDiagnostics(), Opts&: Ins->getLangOpts(),
217 /*AuxTarget=*/Aux: nullptr);
218 Ins->createFileManager();
219 Ins->createSourceManager(FileMgr&: Ins->getFileManager());
220 Ins->createPreprocessor(TUKind: TU_Complete);
221
222 return Ins;
223}
224
225std::unique_ptr<ASTContext>
226BuildASTContext(CompilerInstance &CI, SelectorTable &ST, Builtin::Context &BC) {
227 auto &PP = CI.getPreprocessor();
228 auto AST = std::make_unique<ASTContext>(
229 args&: CI.getLangOpts(), args&: CI.getSourceManager(),
230 args&: PP.getIdentifierTable(), args&: ST, args&: BC, args: PP.TUKind);
231 AST->InitBuiltinTypes(Target: CI.getTarget());
232 return AST;
233}
234
235std::unique_ptr<CodeGenerator> BuildCodeGen(CompilerInstance &CI,
236 llvm::LLVMContext &LLVMCtx) {
237 StringRef ModuleName("$__module");
238 return std::unique_ptr<CodeGenerator>(CreateLLVMCodeGen(
239 Diags&: CI.getDiagnostics(), ModuleName, FS: &CI.getVirtualFileSystem(),
240 HeaderSearchOpts: CI.getHeaderSearchOpts(), PreprocessorOpts: CI.getPreprocessorOpts(), CGO: CI.getCodeGenOpts(),
241 C&: LLVMCtx));
242}
243} // namespace init_convenience
244
245namespace {
246
247/// A container for a CompilerInstance (possibly with an ExternalASTMerger
248/// attached to its ASTContext).
249///
250/// Provides an accessor for the DeclContext origins associated with the
251/// ExternalASTMerger (or an empty list of origins if no ExternalASTMerger is
252/// attached).
253///
254/// This is the main unit of parsed source code maintained by clang-import-test.
255struct CIAndOrigins {
256 using OriginMap = clang::ExternalASTMerger::OriginMap;
257 std::unique_ptr<CompilerInstance> CI;
258
259 ASTContext &getASTContext() { return CI->getASTContext(); }
260 FileManager &getFileManager() { return CI->getFileManager(); }
261 const OriginMap &getOriginMap() {
262 static const OriginMap EmptyOriginMap{};
263 if (ExternalASTSource *Source = CI->getASTContext().getExternalSource())
264 return static_cast<ExternalASTMerger *>(Source)->GetOrigins();
265 return EmptyOriginMap;
266 }
267 DiagnosticConsumer &getDiagnosticClient() {
268 return CI->getDiagnosticClient();
269 }
270 CompilerInstance &getCompilerInstance() { return *CI; }
271};
272
273void AddExternalSource(CIAndOrigins &CI,
274 llvm::MutableArrayRef<CIAndOrigins> Imports) {
275 ExternalASTMerger::ImporterTarget Target(
276 {.AST: CI.getASTContext(), .FM: CI.getFileManager()});
277 llvm::SmallVector<ExternalASTMerger::ImporterSource, 3> Sources;
278 for (CIAndOrigins &Import : Imports)
279 Sources.emplace_back(Args&: Import.getASTContext(), Args&: Import.getFileManager(),
280 Args: Import.getOriginMap());
281 auto ES = std::make_unique<ExternalASTMerger>(args&: Target, args&: Sources);
282 CI.getASTContext().setExternalSource(ES.release());
283 CI.getASTContext().getTranslationUnitDecl()->setHasExternalVisibleStorage();
284}
285
286CIAndOrigins BuildIndirect(CIAndOrigins &CI) {
287 CIAndOrigins IndirectCI{.CI: init_convenience::BuildCompilerInstance()};
288 auto ST = std::make_unique<SelectorTable>();
289 auto BC = std::make_unique<Builtin::Context>();
290 std::unique_ptr<ASTContext> AST = init_convenience::BuildASTContext(
291 CI&: IndirectCI.getCompilerInstance(), ST&: *ST, BC&: *BC);
292 IndirectCI.getCompilerInstance().setASTContext(AST.release());
293 AddExternalSource(CI&: IndirectCI, Imports: CI);
294 return IndirectCI;
295}
296
297llvm::Error ParseSource(const std::string &Path, CompilerInstance &CI,
298 ASTConsumer &Consumer) {
299 SourceManager &SM = CI.getSourceManager();
300 auto FE = CI.getFileManager().getFileRef(Filename: Path);
301 if (!FE) {
302 llvm::consumeError(Err: FE.takeError());
303 return llvm::make_error<llvm::StringError>(
304 Args: llvm::Twine("No such file or directory: ", Path), Args: std::error_code());
305 }
306 SM.setMainFileID(SM.createFileID(SourceFile: *FE, IncludePos: SourceLocation(), FileCharacter: SrcMgr::C_User));
307 ParseAST(pp&: CI.getPreprocessor(), C: &Consumer, Ctx&: CI.getASTContext());
308 return llvm::Error::success();
309}
310
311llvm::Expected<CIAndOrigins> Parse(const std::string &Path,
312 llvm::MutableArrayRef<CIAndOrigins> Imports,
313 bool ShouldDumpAST, bool ShouldDumpIR) {
314 CIAndOrigins CI{.CI: init_convenience::BuildCompilerInstance()};
315 auto ST = std::make_unique<SelectorTable>();
316 auto BC = std::make_unique<Builtin::Context>();
317 std::unique_ptr<ASTContext> AST =
318 init_convenience::BuildASTContext(CI&: CI.getCompilerInstance(), ST&: *ST, BC&: *BC);
319 CI.getCompilerInstance().setASTContext(AST.release());
320 if (Imports.size())
321 AddExternalSource(CI, Imports);
322
323 std::vector<std::unique_ptr<ASTConsumer>> ASTConsumers;
324
325 auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
326 ASTConsumers.push_back(
327 x: init_convenience::BuildCodeGen(CI&: CI.getCompilerInstance(), LLVMCtx&: *LLVMCtx));
328 auto &CG = *static_cast<CodeGenerator *>(ASTConsumers.back().get());
329
330 if (ShouldDumpAST)
331 ASTConsumers.push_back(x: CreateASTDumper(OS: nullptr /*Dump to stdout.*/, FilterString: "",
332 DumpDecls: true, Deserialize: false, DumpLookups: false, DumpDeclTypes: false,
333 Format: clang::ADOF_Default));
334
335 CI.getDiagnosticClient().BeginSourceFile(
336 LangOpts: CI.getCompilerInstance().getLangOpts(),
337 PP: &CI.getCompilerInstance().getPreprocessor());
338 MultiplexConsumer Consumers(std::move(ASTConsumers));
339 Consumers.Initialize(Context&: CI.getASTContext());
340
341 if (llvm::Error PE = ParseSource(Path, CI&: CI.getCompilerInstance(), Consumer&: Consumers))
342 return std::move(PE);
343 CI.getDiagnosticClient().EndSourceFile();
344 if (ShouldDumpIR)
345 CG.GetModule()->print(OS&: llvm::outs(), AAW: nullptr);
346 if (CI.getDiagnosticClient().getNumErrors())
347 return llvm::make_error<llvm::StringError>(
348 Args: "Errors occurred while parsing the expression.", Args: std::error_code());
349 return std::move(CI);
350}
351
352void Forget(CIAndOrigins &CI, llvm::MutableArrayRef<CIAndOrigins> Imports) {
353 llvm::SmallVector<ExternalASTMerger::ImporterSource, 3> Sources;
354 for (CIAndOrigins &Import : Imports)
355 Sources.push_back(Elt: {Import.getASTContext(), Import.getFileManager(),
356 Import.getOriginMap()});
357 ExternalASTSource *Source = CI.CI->getASTContext().getExternalSource();
358 auto *Merger = static_cast<ExternalASTMerger *>(Source);
359 Merger->RemoveSources(Sources);
360}
361
362} // end namespace
363
364int main(int argc, const char **argv) {
365 const bool DisableCrashReporting = true;
366 llvm::sys::PrintStackTraceOnErrorSignal(Argv0: argv[0], DisableCrashReporting);
367 llvm::cl::ParseCommandLineOptions(argc, argv);
368 std::vector<CIAndOrigins> ImportCIs;
369 for (auto I : Imports) {
370 llvm::Expected<CIAndOrigins> ImportCI = Parse(Path: I, Imports: {}, ShouldDumpAST: false, ShouldDumpIR: false);
371 if (auto E = ImportCI.takeError()) {
372 llvm::errs() << "error: " << llvm::toString(E: std::move(E)) << "\n";
373 exit(status: -1);
374 }
375 ImportCIs.push_back(x: std::move(*ImportCI));
376 }
377 std::vector<CIAndOrigins> IndirectCIs;
378 if (!Direct || UseOrigins) {
379 for (auto &ImportCI : ImportCIs) {
380 CIAndOrigins IndirectCI = BuildIndirect(CI&: ImportCI);
381 IndirectCIs.push_back(x: std::move(IndirectCI));
382 }
383 }
384 if (UseOrigins)
385 for (auto &ImportCI : ImportCIs)
386 IndirectCIs.push_back(x: std::move(ImportCI));
387 llvm::Expected<CIAndOrigins> ExpressionCI =
388 Parse(Path: Expression, Imports: (Direct && !UseOrigins) ? ImportCIs : IndirectCIs,
389 ShouldDumpAST: DumpAST, ShouldDumpIR: DumpIR);
390 if (auto E = ExpressionCI.takeError()) {
391 llvm::errs() << "error: " << llvm::toString(E: std::move(E)) << "\n";
392 exit(status: -1);
393 }
394 Forget(CI&: *ExpressionCI, Imports: (Direct && !UseOrigins) ? ImportCIs : IndirectCIs);
395 return 0;
396}
397

source code of clang/tools/clang-import-test/clang-import-test.cpp