1//===--- FrontendAction.cpp -----------------------------------------------===//
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/Frontend/FrontendAction.h"
10#include "clang/AST/ASTConsumer.h"
11#include "clang/AST/ASTContext.h"
12#include "clang/AST/Decl.h"
13#include "clang/AST/DeclGroup.h"
14#include "clang/Basic/Builtins.h"
15#include "clang/Basic/DiagnosticFrontend.h"
16#include "clang/Basic/DiagnosticOptions.h"
17#include "clang/Basic/FileEntry.h"
18#include "clang/Basic/LangOptions.h"
19#include "clang/Basic/LangStandard.h"
20#include "clang/Basic/Sarif.h"
21#include "clang/Basic/SourceLocation.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Basic/Stack.h"
24#include "clang/Basic/TokenKinds.h"
25#include "clang/Frontend/ASTUnit.h"
26#include "clang/Frontend/CompilerInstance.h"
27#include "clang/Frontend/FrontendPluginRegistry.h"
28#include "clang/Frontend/LayoutOverrideSource.h"
29#include "clang/Frontend/MultiplexConsumer.h"
30#include "clang/Frontend/SARIFDiagnosticPrinter.h"
31#include "clang/Frontend/Utils.h"
32#include "clang/Lex/HeaderSearch.h"
33#include "clang/Lex/LiteralSupport.h"
34#include "clang/Lex/Preprocessor.h"
35#include "clang/Lex/PreprocessorOptions.h"
36#include "clang/Parse/ParseAST.h"
37#include "clang/Sema/HLSLExternalSemaSource.h"
38#include "clang/Sema/MultiplexExternalSemaSource.h"
39#include "clang/Serialization/ASTDeserializationListener.h"
40#include "clang/Serialization/ASTReader.h"
41#include "clang/Serialization/GlobalModuleIndex.h"
42#include "llvm/ADT/ScopeExit.h"
43#include "llvm/ADT/SmallPtrSet.h"
44#include "llvm/ADT/StringRef.h"
45#include "llvm/Support/BuryPointer.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/FileSystem.h"
48#include "llvm/Support/Path.h"
49#include "llvm/Support/Timer.h"
50#include "llvm/Support/raw_ostream.h"
51#include <memory>
52#include <system_error>
53using namespace clang;
54
55LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry)
56
57namespace {
58
59/// DeserializedDeclsLineRangePrinter dumps ranges of deserialized declarations
60/// to aid debugging and bug minimization. It implements ASTConsumer and
61/// ASTDeserializationListener, so that an object of
62/// DeserializedDeclsLineRangePrinter registers as its own listener. The
63/// ASTDeserializationListener interface provides the DeclRead callback that we
64/// use to collect the deserialized Decls. Note that printing or otherwise
65/// processing them as this point is dangerous, since that could trigger
66/// additional deserialization and crash compilation. Therefore, we process the
67/// collected Decls in HandleTranslationUnit method of ASTConsumer. This is a
68/// safe point, since we know that by this point all the Decls needed by the
69/// compiler frontend have been deserialized. In case our processing causes
70/// further deserialization, DeclRead from the listener might be called again.
71/// However, at that point we don't accept any more Decls for processing.
72class DeserializedDeclsSourceRangePrinter : public ASTConsumer,
73 ASTDeserializationListener {
74public:
75 explicit DeserializedDeclsSourceRangePrinter(
76 SourceManager &SM, std::unique_ptr<llvm::raw_fd_ostream> OS)
77 : ASTDeserializationListener(), SM(SM), OS(std::move(OS)) {}
78
79 ASTDeserializationListener *GetASTDeserializationListener() override {
80 return this;
81 }
82
83 void DeclRead(GlobalDeclID ID, const Decl *D) override {
84 if (!IsCollectingDecls)
85 return;
86 if (!D || isa<TranslationUnitDecl>(Val: D) || isa<LinkageSpecDecl>(Val: D) ||
87 isa<NamespaceDecl>(Val: D) || isa<ExportDecl>(Val: D)) {
88 // These decls cover a lot of nested declarations that might not be used,
89 // reducing the granularity and making the output less useful.
90 return;
91 }
92 if (isa<ParmVarDecl>(Val: D)) {
93 // Parameters are covered by their functions.
94 return;
95 }
96 auto *DC = D->getLexicalDeclContext();
97 if (!DC || !shouldIncludeDeclsIn(DC))
98 return;
99
100 PendingDecls.push_back(x: D);
101 for (; (isa<ExportDecl>(Val: DC) || isa<NamespaceDecl>(Val: DC)) &&
102 ProcessedDeclContexts.insert(Ptr: DC).second;
103 DC = DC->getLexicalParent()) {
104 // Add any interesting decl contexts that we have not seen before.
105 // Note that we filter them out from DeclRead as that would include all
106 // redeclarations of namespaces, potentially those that do not have any
107 // imported declarations.
108 PendingDecls.push_back(x: cast<Decl>(Val: DC));
109 }
110 }
111
112 struct Position {
113 unsigned Line;
114 unsigned Column;
115
116 bool operator<(const Position &other) const {
117 return std::tie(args: Line, args: Column) < std::tie(args: other.Line, args: other.Column);
118 }
119
120 static Position GetBeginSpelling(const SourceManager &SM,
121 const CharSourceRange &R) {
122 SourceLocation Begin = R.getBegin();
123 return {.Line: SM.getSpellingLineNumber(Loc: Begin),
124 .Column: SM.getSpellingColumnNumber(Loc: Begin)};
125 }
126
127 static Position GetEndSpelling(const SourceManager &SM,
128 const CharSourceRange &Range,
129 const LangOptions &LangOpts) {
130 // For token ranges, compute end location for end character of the range.
131 CharSourceRange R = Lexer::getAsCharRange(Range, SM, LangOpts);
132 SourceLocation End = R.getEnd();
133 // Relex the token past the end location of the last token in the source
134 // range. If it's a semicolon, advance the location by one token.
135 Token PossiblySemi;
136 Lexer::getRawToken(Loc: End, Result&: PossiblySemi, SM, LangOpts, IgnoreWhiteSpace: true);
137 if (PossiblySemi.is(K: tok::semi))
138 End = End.getLocWithOffset(Offset: 1);
139 // Column number of the returned end position is exclusive.
140 return {.Line: SM.getSpellingLineNumber(Loc: End), .Column: SM.getSpellingColumnNumber(Loc: End)};
141 }
142 };
143
144 struct RequiredRanges {
145 StringRef Filename;
146 std::vector<std::pair<Position, Position>> FromTo;
147 };
148 void HandleTranslationUnit(ASTContext &Context) override {
149 assert(IsCollectingDecls && "HandleTranslationUnit called twice?");
150 IsCollectingDecls = false;
151
152 // Merge ranges in each of the files.
153 struct FileData {
154 std::vector<std::pair<Position, Position>> FromTo;
155 OptionalFileEntryRef Ref;
156 };
157 llvm::DenseMap<const FileEntry *, FileData> FileToRanges;
158
159 for (const Decl *D : PendingDecls) {
160 for (CharSourceRange R : getRangesToMark(D)) {
161 if (!R.isValid())
162 continue;
163
164 auto *F = SM.getFileEntryForID(FID: SM.getFileID(SpellingLoc: R.getBegin()));
165 if (F != SM.getFileEntryForID(FID: SM.getFileID(SpellingLoc: R.getEnd()))) {
166 // Such cases are rare and difficult to handle.
167 continue;
168 }
169
170 auto &Data = FileToRanges[F];
171 if (!Data.Ref)
172 Data.Ref = SM.getFileEntryRefForID(FID: SM.getFileID(SpellingLoc: R.getBegin()));
173 Data.FromTo.push_back(
174 x: {Position::GetBeginSpelling(SM, R),
175 Position::GetEndSpelling(SM, Range: R, LangOpts: D->getLangOpts())});
176 }
177 }
178
179 // To simplify output, merge consecutive and intersecting ranges.
180 std::vector<RequiredRanges> Result;
181 for (auto &[F, Data] : FileToRanges) {
182 auto &FromTo = Data.FromTo;
183 assert(!FromTo.empty());
184
185 if (!Data.Ref)
186 continue;
187
188 llvm::sort(C&: FromTo);
189
190 std::vector<std::pair<Position, Position>> MergedRanges;
191 MergedRanges.push_back(x: FromTo.front());
192 for (auto It = FromTo.begin() + 1; It < FromTo.end(); ++It) {
193 if (MergedRanges.back().second < It->first) {
194 MergedRanges.push_back(x: *It);
195 continue;
196 }
197 if (MergedRanges.back().second < It->second)
198 MergedRanges.back().second = It->second;
199 }
200 Result.push_back(x: {.Filename: Data.Ref->getName(), .FromTo: std::move(MergedRanges)});
201 }
202 printJson(Result);
203 }
204
205private:
206 std::vector<const Decl *> PendingDecls;
207 llvm::SmallPtrSet<const DeclContext *, 0> ProcessedDeclContexts;
208 bool IsCollectingDecls = true;
209 const SourceManager &SM;
210 std::unique_ptr<llvm::raw_ostream> OS;
211
212 static bool shouldIncludeDeclsIn(const DeclContext *DC) {
213 assert(DC && "DC is null");
214 // We choose to work at namespace level to reduce complexity and the number
215 // of cases we care about.
216 // We still need to carefully handle composite declarations like
217 // `ExportDecl`.
218 for (; DC; DC = DC->getLexicalParent()) {
219 if (DC->isFileContext())
220 return true;
221 if (isa<ExportDecl>(Val: DC))
222 continue; // Depends on the parent.
223 return false;
224 }
225 llvm_unreachable("DeclContext chain must end with a translation unit");
226 }
227
228 llvm::SmallVector<CharSourceRange, 2> getRangesToMark(const Decl *D) {
229 if (auto *ED = dyn_cast<ExportDecl>(Val: D)) {
230 if (!ED->hasBraces())
231 return {SM.getExpansionRange(Loc: ED->getExportLoc())};
232
233 return {SM.getExpansionRange(Range: SourceRange(
234 ED->getExportLoc(),
235 lexForLBrace(TokenBeforeLBrace: ED->getExportLoc(), LangOpts: D->getLangOpts()))),
236 SM.getExpansionRange(Loc: ED->getRBraceLoc())};
237 }
238
239 auto *NS = dyn_cast<NamespaceDecl>(Val: D);
240 if (!NS)
241 return {SM.getExpansionRange(Range: D->getSourceRange())};
242
243 SourceLocation LBraceLoc;
244 if (NS->isAnonymousNamespace()) {
245 LBraceLoc = NS->getLocation();
246 } else {
247 // Start with the location of the identifier.
248 SourceLocation TokenBeforeLBrace = NS->getLocation();
249 if (NS->hasAttrs()) {
250 for (auto *A : NS->getAttrs()) {
251 // But attributes may go after it.
252 if (SM.isBeforeInTranslationUnit(LHS: TokenBeforeLBrace,
253 RHS: A->getRange().getEnd())) {
254 // Give up, the attributes are often coming from macros and we
255 // cannot skip them reliably.
256 return {};
257 }
258 }
259 }
260 LBraceLoc = lexForLBrace(TokenBeforeLBrace, LangOpts: D->getLangOpts());
261 }
262 return {SM.getExpansionRange(Range: SourceRange(NS->getBeginLoc(), LBraceLoc)),
263 SM.getExpansionRange(Loc: NS->getRBraceLoc())};
264 }
265
266 void printJson(llvm::ArrayRef<RequiredRanges> Result) {
267 *OS << "{\n";
268 *OS << R"( "required_ranges": [)" << "\n";
269 for (size_t I = 0; I < Result.size(); ++I) {
270 auto &F = Result[I].Filename;
271 auto &MergedRanges = Result[I].FromTo;
272 *OS << R"( {)" << "\n";
273 *OS << R"( "file": ")" << F << "\"," << "\n";
274 *OS << R"( "range": [)" << "\n";
275 for (size_t J = 0; J < MergedRanges.size(); ++J) {
276 auto &From = MergedRanges[J].first;
277 auto &To = MergedRanges[J].second;
278 *OS << R"( {)" << "\n";
279 *OS << R"( "from": {)" << "\n";
280 *OS << R"( "line": )" << From.Line << ",\n";
281 *OS << R"( "column": )" << From.Column << "\n"
282 << R"( },)" << "\n";
283 *OS << R"( "to": {)" << "\n";
284 *OS << R"( "line": )" << To.Line << ",\n";
285 *OS << R"( "column": )" << To.Column << "\n"
286 << R"( })" << "\n";
287 *OS << R"( })";
288 if (J < MergedRanges.size() - 1) {
289 *OS << ",";
290 }
291 *OS << "\n";
292 }
293 *OS << " ]" << "\n" << " }";
294 if (I < Result.size() - 1)
295 *OS << ",";
296 *OS << "\n";
297 }
298 *OS << " ]\n";
299 *OS << "}\n";
300
301 OS->flush();
302 }
303
304 SourceLocation lexForLBrace(SourceLocation TokenBeforeLBrace,
305 const LangOptions &LangOpts) {
306 // Now skip one token, the next should be the lbrace.
307 Token Tok;
308 if (Lexer::getRawToken(Loc: TokenBeforeLBrace, Result&: Tok, SM, LangOpts, IgnoreWhiteSpace: true) ||
309 Lexer::getRawToken(Loc: Tok.getEndLoc(), Result&: Tok, SM, LangOpts, IgnoreWhiteSpace: true) ||
310 Tok.getKind() != tok::l_brace) {
311 // On error or if we did not find the token we expected, avoid marking
312 // everything inside the namespace as used.
313 return SourceLocation();
314 }
315 return Tok.getLocation();
316 }
317};
318
319/// Dumps deserialized declarations.
320class DeserializedDeclsDumper : public DelegatingDeserializationListener {
321public:
322 explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
323 bool DeletePrevious)
324 : DelegatingDeserializationListener(Previous, DeletePrevious) {}
325
326 void DeclRead(GlobalDeclID ID, const Decl *D) override {
327 llvm::outs() << "PCH DECL: " << D->getDeclKindName();
328 if (const NamedDecl *ND = dyn_cast<NamedDecl>(Val: D)) {
329 llvm::outs() << " - ";
330 ND->printQualifiedName(OS&: llvm::outs());
331 }
332 llvm::outs() << "\n";
333
334 DelegatingDeserializationListener::DeclRead(ID, D);
335 }
336};
337
338/// Checks deserialized declarations and emits error if a name
339/// matches one given in command-line using -error-on-deserialized-decl.
340class DeserializedDeclsChecker : public DelegatingDeserializationListener {
341 ASTContext &Ctx;
342 std::set<std::string> NamesToCheck;
343
344public:
345 DeserializedDeclsChecker(ASTContext &Ctx,
346 const std::set<std::string> &NamesToCheck,
347 ASTDeserializationListener *Previous,
348 bool DeletePrevious)
349 : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
350 NamesToCheck(NamesToCheck) {}
351
352 void DeclRead(GlobalDeclID ID, const Decl *D) override {
353 if (const NamedDecl *ND = dyn_cast<NamedDecl>(Val: D))
354 if (NamesToCheck.find(x: ND->getNameAsString()) != NamesToCheck.end()) {
355 unsigned DiagID
356 = Ctx.getDiagnostics().getCustomDiagID(L: DiagnosticsEngine::Error,
357 FormatString: "%0 was deserialized");
358 Ctx.getDiagnostics().Report(Loc: Ctx.getFullLoc(Loc: D->getLocation()), DiagID)
359 << ND;
360 }
361
362 DelegatingDeserializationListener::DeclRead(ID, D);
363 }
364};
365
366} // end anonymous namespace
367
368FrontendAction::FrontendAction() : Instance(nullptr) {}
369
370FrontendAction::~FrontendAction() {}
371
372void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
373 std::unique_ptr<ASTUnit> AST) {
374 this->CurrentInput = CurrentInput;
375 CurrentASTUnit = std::move(AST);
376}
377
378Module *FrontendAction::getCurrentModule() const {
379 CompilerInstance &CI = getCompilerInstance();
380 return CI.getPreprocessor().getHeaderSearchInfo().lookupModule(
381 ModuleName: CI.getLangOpts().CurrentModule, ImportLoc: SourceLocation(), /*AllowSearch*/false);
382}
383
384std::unique_ptr<ASTConsumer>
385FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
386 StringRef InFile) {
387 std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
388 if (!Consumer)
389 return nullptr;
390
391 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
392 llvm::StringRef DumpDeserializedDeclarationRangesPath =
393 CI.getFrontendOpts().DumpMinimizationHintsPath;
394 if (!DumpDeserializedDeclarationRangesPath.empty()) {
395 std::error_code ErrorCode;
396 auto FileStream = std::make_unique<llvm::raw_fd_ostream>(
397 args&: DumpDeserializedDeclarationRangesPath, args&: ErrorCode,
398 args: llvm::sys::fs::OF_TextWithCRLF);
399 if (!ErrorCode) {
400 Consumers.push_back(x: std::make_unique<DeserializedDeclsSourceRangePrinter>(
401 args&: CI.getSourceManager(), args: std::move(FileStream)));
402 } else {
403 llvm::errs() << "Failed to create output file for "
404 "-dump-minimization-hints flag, file path: "
405 << DumpDeserializedDeclarationRangesPath
406 << ", error: " << ErrorCode.message() << "\n";
407 }
408 }
409
410 // Validate -add-plugin args.
411 bool FoundAllPlugins = true;
412 for (const std::string &Arg : CI.getFrontendOpts().AddPluginActions) {
413 bool Found = false;
414 for (const FrontendPluginRegistry::entry &Plugin :
415 FrontendPluginRegistry::entries()) {
416 if (Plugin.getName() == Arg)
417 Found = true;
418 }
419 if (!Found) {
420 CI.getDiagnostics().Report(DiagID: diag::err_fe_invalid_plugin_name) << Arg;
421 FoundAllPlugins = false;
422 }
423 }
424 if (!FoundAllPlugins)
425 return nullptr;
426
427 // If this is a code completion run, avoid invoking the plugin consumers
428 if (CI.hasCodeCompletionConsumer())
429 return Consumer;
430
431 // Collect the list of plugins that go before the main action (in Consumers)
432 // or after it (in AfterConsumers)
433 std::vector<std::unique_ptr<ASTConsumer>> AfterConsumers;
434 for (const FrontendPluginRegistry::entry &Plugin :
435 FrontendPluginRegistry::entries()) {
436 std::unique_ptr<PluginASTAction> P = Plugin.instantiate();
437 PluginASTAction::ActionType ActionType = P->getActionType();
438 if (ActionType == PluginASTAction::CmdlineAfterMainAction ||
439 ActionType == PluginASTAction::CmdlineBeforeMainAction) {
440 // This is O(|plugins| * |add_plugins|), but since both numbers are
441 // way below 50 in practice, that's ok.
442 if (llvm::is_contained(Range&: CI.getFrontendOpts().AddPluginActions,
443 Element: Plugin.getName())) {
444 if (ActionType == PluginASTAction::CmdlineBeforeMainAction)
445 ActionType = PluginASTAction::AddBeforeMainAction;
446 else
447 ActionType = PluginASTAction::AddAfterMainAction;
448 }
449 }
450 if ((ActionType == PluginASTAction::AddBeforeMainAction ||
451 ActionType == PluginASTAction::AddAfterMainAction) &&
452 P->ParseArgs(
453 CI,
454 arg: CI.getFrontendOpts().PluginArgs[std::string(Plugin.getName())])) {
455 std::unique_ptr<ASTConsumer> PluginConsumer = P->CreateASTConsumer(CI, InFile);
456 if (ActionType == PluginASTAction::AddBeforeMainAction) {
457 Consumers.push_back(x: std::move(PluginConsumer));
458 } else {
459 AfterConsumers.push_back(x: std::move(PluginConsumer));
460 }
461 }
462 }
463
464 // Add to Consumers the main consumer, then all the plugins that go after it
465 Consumers.push_back(x: std::move(Consumer));
466 if (!AfterConsumers.empty()) {
467 // If we have plugins after the main consumer, which may be the codegen
468 // action, they likely will need the ASTContext, so don't clear it in the
469 // codegen action.
470 CI.getCodeGenOpts().ClearASTBeforeBackend = false;
471 for (auto &C : AfterConsumers)
472 Consumers.push_back(x: std::move(C));
473 }
474
475 assert(Consumers.size() >= 1 && "should have added the main consumer");
476 if (Consumers.size() == 1)
477 return std::move(Consumers.front());
478 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
479}
480
481/// For preprocessed files, if the first line is the linemarker and specifies
482/// the original source file name, use that name as the input file name.
483/// Returns the location of the first token after the line marker directive.
484///
485/// \param CI The compiler instance.
486/// \param InputFile Populated with the filename from the line marker.
487/// \param IsModuleMap If \c true, add a line note corresponding to this line
488/// directive. (We need to do this because the directive will not be
489/// visited by the preprocessor.)
490static SourceLocation ReadOriginalFileName(CompilerInstance &CI,
491 std::string &InputFile,
492 bool IsModuleMap = false) {
493 auto &SourceMgr = CI.getSourceManager();
494 auto MainFileID = SourceMgr.getMainFileID();
495
496 auto MainFileBuf = SourceMgr.getBufferOrNone(FID: MainFileID);
497 if (!MainFileBuf)
498 return SourceLocation();
499
500 std::unique_ptr<Lexer> RawLexer(
501 new Lexer(MainFileID, *MainFileBuf, SourceMgr, CI.getLangOpts()));
502
503 // If the first line has the syntax of
504 //
505 // # NUM "FILENAME"
506 //
507 // we use FILENAME as the input file name.
508 Token T;
509 if (RawLexer->LexFromRawLexer(Result&: T) || T.getKind() != tok::hash)
510 return SourceLocation();
511 if (RawLexer->LexFromRawLexer(Result&: T) || T.isAtStartOfLine() ||
512 T.getKind() != tok::numeric_constant)
513 return SourceLocation();
514
515 unsigned LineNo;
516 SourceLocation LineNoLoc = T.getLocation();
517 if (IsModuleMap) {
518 llvm::SmallString<16> Buffer;
519 if (Lexer::getSpelling(loc: LineNoLoc, buffer&: Buffer, SM: SourceMgr, options: CI.getLangOpts())
520 .getAsInteger(Radix: 10, Result&: LineNo))
521 return SourceLocation();
522 }
523
524 RawLexer->LexFromRawLexer(Result&: T);
525 if (T.isAtStartOfLine() || T.getKind() != tok::string_literal)
526 return SourceLocation();
527
528 StringLiteralParser Literal(T, CI.getPreprocessor());
529 if (Literal.hadError)
530 return SourceLocation();
531 RawLexer->LexFromRawLexer(Result&: T);
532 if (T.isNot(K: tok::eof) && !T.isAtStartOfLine())
533 return SourceLocation();
534 InputFile = Literal.GetString().str();
535
536 if (IsModuleMap)
537 CI.getSourceManager().AddLineNote(
538 Loc: LineNoLoc, LineNo, FilenameID: SourceMgr.getLineTableFilenameID(Str: InputFile), IsFileEntry: false,
539 IsFileExit: false, FileKind: SrcMgr::C_User_ModuleMap);
540
541 return T.getLocation();
542}
543
544static SmallVectorImpl<char> &
545operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
546 Includes.append(in_start: RHS.begin(), in_end: RHS.end());
547 return Includes;
548}
549
550static void addHeaderInclude(StringRef HeaderName,
551 SmallVectorImpl<char> &Includes,
552 const LangOptions &LangOpts,
553 bool IsExternC) {
554 if (IsExternC && LangOpts.CPlusPlus)
555 Includes += "extern \"C\" {\n";
556 if (LangOpts.ObjC)
557 Includes += "#import \"";
558 else
559 Includes += "#include \"";
560
561 Includes += HeaderName;
562
563 Includes += "\"\n";
564 if (IsExternC && LangOpts.CPlusPlus)
565 Includes += "}\n";
566}
567
568/// Collect the set of header includes needed to construct the given
569/// module and update the TopHeaders file set of the module.
570///
571/// \param Module The module we're collecting includes from.
572///
573/// \param Includes Will be augmented with the set of \#includes or \#imports
574/// needed to load all of the named headers.
575static std::error_code collectModuleHeaderIncludes(
576 const LangOptions &LangOpts, FileManager &FileMgr, DiagnosticsEngine &Diag,
577 ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl<char> &Includes) {
578 // Don't collect any headers for unavailable modules.
579 if (!Module->isAvailable())
580 return std::error_code();
581
582 // Resolve all lazy header directives to header files.
583 ModMap.resolveHeaderDirectives(Mod: Module, /*File=*/std::nullopt);
584
585 // If any headers are missing, we can't build this module. In most cases,
586 // diagnostics for this should have already been produced; we only get here
587 // if explicit stat information was provided.
588 // FIXME: If the name resolves to a file with different stat information,
589 // produce a better diagnostic.
590 if (!Module->MissingHeaders.empty()) {
591 auto &MissingHeader = Module->MissingHeaders.front();
592 Diag.Report(Loc: MissingHeader.FileNameLoc, DiagID: diag::err_module_header_missing)
593 << MissingHeader.IsUmbrella << MissingHeader.FileName;
594 return std::error_code();
595 }
596
597 // Add includes for each of these headers.
598 for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
599 for (const Module::Header &H : Module->getHeaders(HK)) {
600 Module->addTopHeader(File: H.Entry);
601 // Use the path as specified in the module map file. We'll look for this
602 // file relative to the module build directory (the directory containing
603 // the module map file) so this will find the same file that we found
604 // while parsing the module map.
605 addHeaderInclude(HeaderName: H.PathRelativeToRootModuleDirectory, Includes, LangOpts,
606 IsExternC: Module->IsExternC);
607 }
608 }
609 // Note that Module->PrivateHeaders will not be a TopHeader.
610
611 if (std::optional<Module::Header> UmbrellaHeader =
612 Module->getUmbrellaHeaderAsWritten()) {
613 Module->addTopHeader(File: UmbrellaHeader->Entry);
614 if (Module->Parent)
615 // Include the umbrella header for submodules.
616 addHeaderInclude(HeaderName: UmbrellaHeader->PathRelativeToRootModuleDirectory,
617 Includes, LangOpts, IsExternC: Module->IsExternC);
618 } else if (std::optional<Module::DirectoryName> UmbrellaDir =
619 Module->getUmbrellaDirAsWritten()) {
620 // Add all of the headers we find in this subdirectory.
621 std::error_code EC;
622 SmallString<128> DirNative;
623 llvm::sys::path::native(path: UmbrellaDir->Entry.getName(), result&: DirNative);
624
625 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
626 SmallVector<std::pair<std::string, std::string>, 8> HeaderPaths;
627 for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
628 Dir != End && !EC; Dir.increment(EC)) {
629 // Check whether this entry has an extension typically associated with
630 // headers.
631 if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(path: Dir->path()))
632 .Cases(CaseStrings: {".h", ".H", ".hh", ".hpp"}, Value: true)
633 .Default(Value: false))
634 continue;
635
636 // Compute the relative path from the directory to this file.
637 SmallVector<StringRef, 16> Components;
638 auto PathIt = llvm::sys::path::rbegin(path: Dir->path());
639 for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
640 Components.push_back(Elt: *PathIt);
641 SmallString<128> RelativeHeader(
642 UmbrellaDir->PathRelativeToRootModuleDirectory);
643 for (auto It = Components.rbegin(), End = Components.rend(); It != End;
644 ++It)
645 llvm::sys::path::append(path&: RelativeHeader, a: *It);
646
647 HeaderPaths.push_back(
648 Elt: std::make_pair(x: Dir->path().str(), y: RelativeHeader.c_str()));
649 }
650
651 if (EC)
652 return EC;
653
654 // Sort header paths and make the header inclusion order deterministic
655 // across different OSs and filesystems. As the header search table
656 // serialization order depends on the file reference UID, we need to create
657 // file references in deterministic order too.
658 llvm::sort(C&: HeaderPaths, Comp: llvm::less_first());
659 for (auto &[Path, RelPath] : HeaderPaths) {
660 auto Header = FileMgr.getOptionalFileRef(Filename: Path);
661 // FIXME: This shouldn't happen unless there is a file system race. Is
662 // that worth diagnosing?
663 if (!Header)
664 continue;
665
666 // If this header is marked 'unavailable' in this module, don't include
667 // it.
668 if (ModMap.isHeaderUnavailableInModule(Header: *Header, RequestingModule: Module))
669 continue;
670
671 // Include this header as part of the umbrella directory.
672 Module->addTopHeader(File: *Header);
673 addHeaderInclude(HeaderName: RelPath, Includes, LangOpts, IsExternC: Module->IsExternC);
674 }
675 }
676
677 // Recurse into submodules.
678 for (auto *Submodule : Module->submodules())
679 if (std::error_code Err = collectModuleHeaderIncludes(
680 LangOpts, FileMgr, Diag, ModMap, Module: Submodule, Includes))
681 return Err;
682
683 return std::error_code();
684}
685
686static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem,
687 bool IsPreprocessed,
688 std::string &PresumedModuleMapFile,
689 unsigned &Offset) {
690 auto &SrcMgr = CI.getSourceManager();
691 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
692
693 // Map the current input to a file.
694 FileID ModuleMapID = SrcMgr.getMainFileID();
695 OptionalFileEntryRef ModuleMap = SrcMgr.getFileEntryRefForID(FID: ModuleMapID);
696 assert(ModuleMap && "MainFileID without FileEntry");
697
698 // If the module map is preprocessed, handle the initial line marker;
699 // line directives are not part of the module map syntax in general.
700 Offset = 0;
701 if (IsPreprocessed) {
702 SourceLocation EndOfLineMarker =
703 ReadOriginalFileName(CI, InputFile&: PresumedModuleMapFile, /*IsModuleMap*/ true);
704 if (EndOfLineMarker.isValid())
705 Offset = CI.getSourceManager().getDecomposedLoc(Loc: EndOfLineMarker).second;
706 }
707
708 // Load the module map file.
709 if (HS.parseAndLoadModuleMapFile(File: *ModuleMap, IsSystem, ID: ModuleMapID, Offset: &Offset,
710 OriginalModuleMapFile: PresumedModuleMapFile))
711 return true;
712
713 if (SrcMgr.getBufferOrFake(FID: ModuleMapID).getBufferSize() == Offset)
714 Offset = 0;
715
716 // Infer framework module if possible.
717 if (HS.getModuleMap().canInferFrameworkModule(Dir: ModuleMap->getDir())) {
718 SmallString<128> InferredFrameworkPath = ModuleMap->getDir().getName();
719 llvm::sys::path::append(path&: InferredFrameworkPath,
720 a: CI.getLangOpts().ModuleName + ".framework");
721 if (auto Dir =
722 CI.getFileManager().getOptionalDirectoryRef(DirName: InferredFrameworkPath))
723 (void)HS.getModuleMap().inferFrameworkModule(FrameworkDir: *Dir, IsSystem, Parent: nullptr);
724 }
725
726 return false;
727}
728
729static Module *prepareToBuildModule(CompilerInstance &CI,
730 StringRef ModuleMapFilename) {
731 if (CI.getLangOpts().CurrentModule.empty()) {
732 CI.getDiagnostics().Report(DiagID: diag::err_missing_module_name);
733
734 // FIXME: Eventually, we could consider asking whether there was just
735 // a single module described in the module map, and use that as a
736 // default. Then it would be fairly trivial to just "compile" a module
737 // map with a single module (the common case).
738 return nullptr;
739 }
740
741 // Dig out the module definition.
742 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
743 Module *M = HS.lookupModule(ModuleName: CI.getLangOpts().CurrentModule, ImportLoc: SourceLocation(),
744 /*AllowSearch=*/true);
745 if (!M) {
746 CI.getDiagnostics().Report(DiagID: diag::err_missing_module)
747 << CI.getLangOpts().CurrentModule << ModuleMapFilename;
748
749 return nullptr;
750 }
751
752 // Check whether we can build this module at all.
753 if (Preprocessor::checkModuleIsAvailable(LangOpts: CI.getLangOpts(), TargetInfo: CI.getTarget(), M: *M,
754 Diags&: CI.getDiagnostics()))
755 return nullptr;
756
757 // Inform the preprocessor that includes from within the input buffer should
758 // be resolved relative to the build directory of the module map file.
759 CI.getPreprocessor().setMainFileDir(*M->Directory);
760
761 // If the module was inferred from a different module map (via an expanded
762 // umbrella module definition), track that fact.
763 // FIXME: It would be preferable to fill this in as part of processing
764 // the module map, rather than adding it after the fact.
765 StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap;
766 if (!OriginalModuleMapName.empty()) {
767 auto OriginalModuleMap =
768 CI.getFileManager().getOptionalFileRef(Filename: OriginalModuleMapName,
769 /*openFile*/ OpenFile: true);
770 if (!OriginalModuleMap) {
771 CI.getDiagnostics().Report(DiagID: diag::err_module_map_not_found)
772 << OriginalModuleMapName;
773 return nullptr;
774 }
775 if (*OriginalModuleMap != CI.getSourceManager().getFileEntryRefForID(
776 FID: CI.getSourceManager().getMainFileID())) {
777 auto FileCharacter =
778 M->IsSystem ? SrcMgr::C_System_ModuleMap : SrcMgr::C_User_ModuleMap;
779 FileID OriginalModuleMapFID = CI.getSourceManager().getOrCreateFileID(
780 SourceFile: *OriginalModuleMap, FileCharacter);
781 CI.getPreprocessor()
782 .getHeaderSearchInfo()
783 .getModuleMap()
784 .setInferredModuleAllowedBy(M, ModMapFID: OriginalModuleMapFID);
785 }
786 }
787
788 // If we're being run from the command-line, the module build stack will not
789 // have been filled in yet, so complete it now in order to allow us to detect
790 // module cycles.
791 SourceManager &SourceMgr = CI.getSourceManager();
792 if (SourceMgr.getModuleBuildStack().empty())
793 SourceMgr.pushModuleBuildStack(moduleName: CI.getLangOpts().CurrentModule,
794 importLoc: FullSourceLoc(SourceLocation(), SourceMgr));
795 return M;
796}
797
798/// Compute the input buffer that should be used to build the specified module.
799static std::unique_ptr<llvm::MemoryBuffer>
800getInputBufferForModule(CompilerInstance &CI, Module *M) {
801 FileManager &FileMgr = CI.getFileManager();
802
803 // Collect the set of #includes we need to build the module.
804 SmallString<256> HeaderContents;
805 std::error_code Err = std::error_code();
806 if (std::optional<Module::Header> UmbrellaHeader =
807 M->getUmbrellaHeaderAsWritten())
808 addHeaderInclude(HeaderName: UmbrellaHeader->PathRelativeToRootModuleDirectory,
809 Includes&: HeaderContents, LangOpts: CI.getLangOpts(), IsExternC: M->IsExternC);
810 Err = collectModuleHeaderIncludes(
811 LangOpts: CI.getLangOpts(), FileMgr, Diag&: CI.getDiagnostics(),
812 ModMap&: CI.getPreprocessor().getHeaderSearchInfo().getModuleMap(), Module: M,
813 Includes&: HeaderContents);
814
815 if (Err) {
816 CI.getDiagnostics().Report(DiagID: diag::err_module_cannot_create_includes)
817 << M->getFullModuleName() << Err.message();
818 return nullptr;
819 }
820
821 return llvm::MemoryBuffer::getMemBufferCopy(
822 InputData: HeaderContents, BufferName: Module::getModuleInputBufferName());
823}
824
825bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
826 const FrontendInputFile &RealInput) {
827 FrontendInputFile Input(RealInput);
828 assert(!Instance && "Already processing a source file!");
829 assert(!Input.isEmpty() && "Unexpected empty filename!");
830 setCurrentInput(CurrentInput: Input);
831 setCompilerInstance(&CI);
832
833 bool HasBegunSourceFile = false;
834 bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled &&
835 usesPreprocessorOnly();
836
837 // If we fail, reset state since the client will not end up calling the
838 // matching EndSourceFile(). All paths that return true should release this.
839 llvm::scope_exit FailureCleanup([&]() {
840 if (HasBegunSourceFile)
841 CI.getDiagnosticClient().EndSourceFile();
842 CI.setASTConsumer(nullptr);
843 CI.clearOutputFiles(/*EraseFiles=*/true);
844 CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
845 setCurrentInput(CurrentInput: FrontendInputFile());
846 setCompilerInstance(nullptr);
847 });
848
849 if (!BeginInvocation(CI))
850 return false;
851
852 // If we're replaying the build of an AST file, import it and set up
853 // the initial state from its build.
854 if (ReplayASTFile) {
855 IntrusiveRefCntPtr<DiagnosticsEngine> Diags = CI.getDiagnosticsPtr();
856
857 // The AST unit populates its own diagnostics engine rather than ours.
858 auto ASTDiags = llvm::makeIntrusiveRefCnt<DiagnosticsEngine>(
859 A: Diags->getDiagnosticIDs(), A&: Diags->getDiagnosticOptions());
860 ASTDiags->setClient(client: Diags->getClient(), /*OwnsClient*/ShouldOwnClient: false);
861
862 // FIXME: What if the input is a memory buffer?
863 StringRef InputFile = Input.getFile();
864
865 std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
866 Filename: InputFile, PCHContainerRdr: CI.getPCHContainerReader(), ToLoad: ASTUnit::LoadPreprocessorOnly,
867 VFS: CI.getVirtualFileSystemPtr(), DiagOpts: nullptr, Diags: ASTDiags, FileSystemOpts: CI.getFileSystemOpts(),
868 HSOpts: CI.getHeaderSearchOpts());
869 if (!AST)
870 return false;
871
872 // Options relating to how we treat the input (but not what we do with it)
873 // are inherited from the AST unit.
874 CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
875 CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
876 CI.getLangOpts() = AST->getLangOpts();
877
878 // Set the shared objects, these are reset when we finish processing the
879 // file, otherwise the CompilerInstance will happily destroy them.
880 CI.setVirtualFileSystem(AST->getFileManager().getVirtualFileSystemPtr());
881 CI.setFileManager(AST->getFileManagerPtr());
882 CI.createSourceManager();
883 CI.getSourceManager().initializeForReplay(Old: AST->getSourceManager());
884
885 // Preload all the module files loaded transitively by the AST unit. Also
886 // load all module map files that were parsed as part of building the AST
887 // unit.
888 if (auto ASTReader = AST->getASTReader()) {
889 auto &MM = ASTReader->getModuleManager();
890 auto &PrimaryModule = MM.getPrimaryModule();
891
892 for (serialization::ModuleFile &MF : MM)
893 if (&MF != &PrimaryModule)
894 CI.getFrontendOpts().ModuleFiles.push_back(x: MF.FileName);
895
896 ASTReader->visitTopLevelModuleMaps(MF&: PrimaryModule, Visitor: [&](FileEntryRef FE) {
897 CI.getFrontendOpts().ModuleMapFiles.push_back(
898 x: std::string(FE.getName()));
899 });
900 }
901
902 // Set up the input file for replay purposes.
903 auto Kind = AST->getInputKind();
904 if (Kind.getFormat() == InputKind::ModuleMap) {
905 Module *ASTModule =
906 AST->getPreprocessor().getHeaderSearchInfo().lookupModule(
907 ModuleName: AST->getLangOpts().CurrentModule, ImportLoc: SourceLocation(),
908 /*AllowSearch*/ false);
909 assert(ASTModule && "module file does not define its own module");
910 Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
911 } else {
912 auto &OldSM = AST->getSourceManager();
913 FileID ID = OldSM.getMainFileID();
914 if (auto File = OldSM.getFileEntryRefForID(FID: ID))
915 Input = FrontendInputFile(File->getName(), Kind);
916 else
917 Input = FrontendInputFile(OldSM.getBufferOrFake(FID: ID), Kind);
918 }
919 setCurrentInput(CurrentInput: Input, AST: std::move(AST));
920 }
921
922 // AST files follow a very different path, since they share objects via the
923 // AST unit.
924 if (Input.getKind().getFormat() == InputKind::Precompiled) {
925 assert(!usesPreprocessorOnly() && "this case was handled above");
926 assert(hasASTFileSupport() &&
927 "This action does not have AST file support!");
928
929 IntrusiveRefCntPtr<DiagnosticsEngine> Diags = CI.getDiagnosticsPtr();
930
931 // FIXME: What if the input is a memory buffer?
932 StringRef InputFile = Input.getFile();
933
934 std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
935 Filename: InputFile, PCHContainerRdr: CI.getPCHContainerReader(), ToLoad: ASTUnit::LoadEverything,
936 VFS: CI.getVirtualFileSystemPtr(), DiagOpts: nullptr, Diags, FileSystemOpts: CI.getFileSystemOpts(),
937 HSOpts: CI.getHeaderSearchOpts(), LangOpts: &CI.getLangOpts());
938
939 if (!AST)
940 return false;
941
942 // Inform the diagnostic client we are processing a source file.
943 CI.getDiagnosticClient().BeginSourceFile(LangOpts: CI.getLangOpts(), PP: nullptr);
944 HasBegunSourceFile = true;
945
946 // Set the shared objects, these are reset when we finish processing the
947 // file, otherwise the CompilerInstance will happily destroy them.
948 CI.setVirtualFileSystem(AST->getVirtualFileSystemPtr());
949 CI.setFileManager(AST->getFileManagerPtr());
950 CI.setSourceManager(AST->getSourceManagerPtr());
951 CI.setPreprocessor(AST->getPreprocessorPtr());
952 Preprocessor &PP = CI.getPreprocessor();
953 PP.getBuiltinInfo().initializeBuiltins(Table&: PP.getIdentifierTable(),
954 LangOpts: PP.getLangOpts());
955 CI.setASTContext(AST->getASTContextPtr());
956
957 setCurrentInput(CurrentInput: Input, AST: std::move(AST));
958
959 // Initialize the action.
960 if (!BeginSourceFileAction(CI))
961 return false;
962
963 // Create the AST consumer.
964 CI.setASTConsumer(CreateWrappedASTConsumer(CI, InFile: InputFile));
965 if (!CI.hasASTConsumer())
966 return false;
967
968 FailureCleanup.release();
969 return true;
970 }
971
972 // Set up the file system, file and source managers, if needed.
973 if (!CI.hasVirtualFileSystem())
974 CI.createVirtualFileSystem();
975 if (!CI.hasFileManager())
976 CI.createFileManager();
977 if (!CI.hasSourceManager()) {
978 CI.createSourceManager();
979 if (CI.getDiagnosticOpts().getFormat() == DiagnosticOptions::SARIF) {
980 static_cast<SARIFDiagnosticPrinter *>(&CI.getDiagnosticClient())
981 ->setSarifWriter(
982 std::make_unique<SarifDocumentWriter>(args&: CI.getSourceManager()));
983 }
984 }
985
986 // Set up embedding for any specified files. Do this before we load any
987 // source files, including the primary module map for the compilation.
988 for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
989 if (auto FE = CI.getFileManager().getOptionalFileRef(Filename: F, /*openFile*/OpenFile: true))
990 CI.getSourceManager().setFileIsTransient(*FE);
991 else
992 CI.getDiagnostics().Report(DiagID: diag::err_modules_embed_file_not_found) << F;
993 }
994 if (CI.getFrontendOpts().ModulesEmbedAllFiles)
995 CI.getSourceManager().setAllFilesAreTransient(true);
996
997 // IR files bypass the rest of initialization.
998 if (Input.getKind().getLanguage() == Language::LLVM_IR) {
999 if (!hasIRSupport()) {
1000 CI.getDiagnostics().Report(DiagID: diag::err_ast_action_on_llvm_ir)
1001 << Input.getFile();
1002 return false;
1003 }
1004
1005 // Inform the diagnostic client we are processing a source file.
1006 CI.getDiagnosticClient().BeginSourceFile(LangOpts: CI.getLangOpts(), PP: nullptr);
1007 HasBegunSourceFile = true;
1008
1009 // Initialize the action.
1010 if (!BeginSourceFileAction(CI))
1011 return false;
1012
1013 // Initialize the main file entry.
1014 if (!CI.InitializeSourceManager(Input: CurrentInput))
1015 return false;
1016
1017 FailureCleanup.release();
1018 return true;
1019 }
1020
1021 // If the implicit PCH include is actually a directory, rather than
1022 // a single file, search for a suitable PCH file in that directory.
1023 if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
1024 FileManager &FileMgr = CI.getFileManager();
1025 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
1026 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
1027 std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
1028 if (auto PCHDir = FileMgr.getOptionalDirectoryRef(DirName: PCHInclude)) {
1029 std::error_code EC;
1030 SmallString<128> DirNative;
1031 llvm::sys::path::native(path: PCHDir->getName(), result&: DirNative);
1032 bool Found = false;
1033 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
1034 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(Dir: DirNative, EC),
1035 DirEnd;
1036 Dir != DirEnd && !EC; Dir.increment(EC)) {
1037 // Check whether this is an acceptable AST file.
1038 if (ASTReader::isAcceptableASTFile(
1039 Filename: Dir->path(), FileMgr, ModCache: CI.getModuleCache(),
1040 PCHContainerRdr: CI.getPCHContainerReader(), LangOpts: CI.getLangOpts(),
1041 CGOpts: CI.getCodeGenOpts(), TargetOpts: CI.getTargetOpts(),
1042 PPOpts: CI.getPreprocessorOpts(), HSOpts: CI.getHeaderSearchOpts(),
1043 SpecificModuleCachePath,
1044 /*RequireStrictOptionMatches=*/true)) {
1045 PPOpts.ImplicitPCHInclude = std::string(Dir->path());
1046 Found = true;
1047 break;
1048 }
1049 }
1050
1051 if (!Found) {
1052 CI.getDiagnostics().Report(DiagID: diag::err_fe_no_pch_in_dir) << PCHInclude;
1053 return false;
1054 }
1055 }
1056 }
1057
1058 // Set up the preprocessor if needed. When parsing model files the
1059 // preprocessor of the original source is reused.
1060 if (!isModelParsingAction())
1061 CI.createPreprocessor(TUKind: getTranslationUnitKind());
1062
1063 // Inform the diagnostic client we are processing a source file.
1064 CI.getDiagnosticClient().BeginSourceFile(LangOpts: CI.getLangOpts(),
1065 PP: &CI.getPreprocessor());
1066 HasBegunSourceFile = true;
1067
1068 // Handle C++20 header units.
1069 // Here, the user has the option to specify that the header name should be
1070 // looked up in the pre-processor search paths (and the main filename as
1071 // passed by the driver might therefore be incomplete until that look-up).
1072 if (CI.getLangOpts().CPlusPlusModules && Input.getKind().isHeaderUnit() &&
1073 !Input.getKind().isPreprocessed()) {
1074 StringRef FileName = Input.getFile();
1075 InputKind Kind = Input.getKind();
1076 if (Kind.getHeaderUnitKind() != InputKind::HeaderUnit_Abs) {
1077 assert(CI.hasPreprocessor() &&
1078 "trying to build a header unit without a Pre-processor?");
1079 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
1080 // Relative searches begin from CWD.
1081 auto Dir = CI.getFileManager().getOptionalDirectoryRef(DirName: ".");
1082 SmallVector<std::pair<OptionalFileEntryRef, DirectoryEntryRef>, 1> CWD;
1083 CWD.push_back(Elt: {std::nullopt, *Dir});
1084 OptionalFileEntryRef FE =
1085 HS.LookupFile(Filename: FileName, IncludeLoc: SourceLocation(),
1086 /*Angled*/ isAngled: Input.getKind().getHeaderUnitKind() ==
1087 InputKind::HeaderUnit_System,
1088 FromDir: nullptr, CurDir: nullptr, Includers: CWD, SearchPath: nullptr, RelativePath: nullptr, RequestingModule: nullptr,
1089 SuggestedModule: nullptr, IsMapped: nullptr, IsFrameworkFound: nullptr);
1090 if (!FE) {
1091 CI.getDiagnostics().Report(DiagID: diag::err_module_header_file_not_found)
1092 << FileName;
1093 return false;
1094 }
1095 // We now have the filename...
1096 FileName = FE->getName();
1097 // ... still a header unit, but now use the path as written.
1098 Kind = Input.getKind().withHeaderUnit(HU: InputKind::HeaderUnit_Abs);
1099 Input = FrontendInputFile(FileName, Kind, Input.isSystem());
1100 }
1101 // Unless the user has overridden the name, the header unit module name is
1102 // the pathname for the file.
1103 if (CI.getLangOpts().ModuleName.empty())
1104 CI.getLangOpts().ModuleName = std::string(FileName);
1105 CI.getLangOpts().CurrentModule = CI.getLangOpts().ModuleName;
1106 }
1107
1108 if (!CI.InitializeSourceManager(Input))
1109 return false;
1110
1111 if (CI.getLangOpts().CPlusPlusModules && Input.getKind().isHeaderUnit() &&
1112 Input.getKind().isPreprocessed() && !usesPreprocessorOnly()) {
1113 // We have an input filename like foo.iih, but we want to find the right
1114 // module name (and original file, to build the map entry).
1115 // Check if the first line specifies the original source file name with a
1116 // linemarker.
1117 std::string PresumedInputFile = std::string(getCurrentFileOrBufferName());
1118 ReadOriginalFileName(CI, InputFile&: PresumedInputFile);
1119 // Unless the user overrides this, the module name is the name by which the
1120 // original file was known.
1121 if (CI.getLangOpts().ModuleName.empty())
1122 CI.getLangOpts().ModuleName = std::string(PresumedInputFile);
1123 CI.getLangOpts().CurrentModule = CI.getLangOpts().ModuleName;
1124 }
1125
1126 // For module map files, we first parse the module map and synthesize a
1127 // "<module-includes>" buffer before more conventional processing.
1128 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1129 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap);
1130
1131 std::string PresumedModuleMapFile;
1132 unsigned OffsetToContents;
1133 if (loadModuleMapForModuleBuild(CI, IsSystem: Input.isSystem(),
1134 IsPreprocessed: Input.isPreprocessed(),
1135 PresumedModuleMapFile, Offset&: OffsetToContents))
1136 return false;
1137
1138 auto *CurrentModule = prepareToBuildModule(CI, ModuleMapFilename: Input.getFile());
1139 if (!CurrentModule)
1140 return false;
1141
1142 CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile;
1143
1144 if (OffsetToContents)
1145 // If the module contents are in the same file, skip to them.
1146 CI.getPreprocessor().setSkipMainFilePreamble(Bytes: OffsetToContents, StartOfLine: true);
1147 else {
1148 // Otherwise, convert the module description to a suitable input buffer.
1149 auto Buffer = getInputBufferForModule(CI, M: CurrentModule);
1150 if (!Buffer)
1151 return false;
1152
1153 // Reinitialize the main file entry to refer to the new input.
1154 auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
1155 auto &SourceMgr = CI.getSourceManager();
1156 auto BufferID = SourceMgr.createFileID(Buffer: std::move(Buffer), FileCharacter: Kind);
1157 assert(BufferID.isValid() && "couldn't create module buffer ID");
1158 SourceMgr.setMainFileID(BufferID);
1159 }
1160 }
1161
1162 // Initialize the action.
1163 if (!BeginSourceFileAction(CI))
1164 return false;
1165
1166 // If we were asked to load any module map files, do so now.
1167 for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
1168 if (auto File = CI.getFileManager().getOptionalFileRef(Filename))
1169 CI.getPreprocessor().getHeaderSearchInfo().parseAndLoadModuleMapFile(
1170 File: *File, /*IsSystem*/ false);
1171 else
1172 CI.getDiagnostics().Report(DiagID: diag::err_module_map_not_found) << Filename;
1173 }
1174
1175 // If compiling implementation of a module, load its module map file now.
1176 (void)CI.getPreprocessor().getCurrentModuleImplementation();
1177
1178 // Add a module declaration scope so that modules from -fmodule-map-file
1179 // arguments may shadow modules found implicitly in search paths.
1180 CI.getPreprocessor()
1181 .getHeaderSearchInfo()
1182 .getModuleMap()
1183 .finishModuleDeclarationScope();
1184
1185 // Create the AST context and consumer unless this is a preprocessor only
1186 // action.
1187 if (!usesPreprocessorOnly()) {
1188 // Parsing a model file should reuse the existing ASTContext.
1189 if (!isModelParsingAction())
1190 CI.createASTContext();
1191
1192 // For preprocessed files, check if the first line specifies the original
1193 // source file name with a linemarker.
1194 std::string PresumedInputFile = std::string(getCurrentFileOrBufferName());
1195 if (Input.isPreprocessed())
1196 ReadOriginalFileName(CI, InputFile&: PresumedInputFile);
1197
1198 std::unique_ptr<ASTConsumer> Consumer =
1199 CreateWrappedASTConsumer(CI, InFile: PresumedInputFile);
1200 if (!Consumer)
1201 return false;
1202
1203 // FIXME: should not overwrite ASTMutationListener when parsing model files?
1204 if (!isModelParsingAction())
1205 CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
1206
1207 if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
1208 // Convert headers to PCH and chain them.
1209 IntrusiveRefCntPtr<ExternalSemaSource> source;
1210 IntrusiveRefCntPtr<ASTReader> FinalReader;
1211 source = createChainedIncludesSource(CI, OutReader&: FinalReader);
1212 if (!source)
1213 return false;
1214 CI.setASTReader(FinalReader);
1215 CI.getASTContext().setExternalSource(source);
1216 } else if (CI.getLangOpts().Modules ||
1217 !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
1218 // Use PCM or PCH.
1219 assert(hasPCHSupport() && "This action does not have PCH support!");
1220 ASTDeserializationListener *DeserialListener =
1221 Consumer->GetASTDeserializationListener();
1222 bool DeleteDeserialListener = false;
1223 if (CI.getPreprocessorOpts().DumpDeserializedPCHDecls) {
1224 DeserialListener = new DeserializedDeclsDumper(DeserialListener,
1225 DeleteDeserialListener);
1226 DeleteDeserialListener = true;
1227 }
1228 if (!CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn.empty()) {
1229 DeserialListener = new DeserializedDeclsChecker(
1230 CI.getASTContext(),
1231 CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn,
1232 DeserialListener, DeleteDeserialListener);
1233 DeleteDeserialListener = true;
1234 }
1235 if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
1236 CI.createPCHExternalASTSource(
1237 Path: CI.getPreprocessorOpts().ImplicitPCHInclude,
1238 DisableValidation: CI.getPreprocessorOpts().DisablePCHOrModuleValidation,
1239 AllowPCHWithCompilerErrors: CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
1240 DeserializationListener: DeserialListener, OwnDeserializationListener: DeleteDeserialListener);
1241 if (!CI.getASTContext().getExternalSource())
1242 return false;
1243 }
1244 // If modules are enabled, create the AST reader before creating
1245 // any builtins, so that all declarations know that they might be
1246 // extended by an external source.
1247 if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
1248 !CI.getASTContext().getExternalSource()) {
1249 CI.createASTReader();
1250 CI.getASTReader()->setDeserializationListener(Listener: DeserialListener,
1251 TakeOwnership: DeleteDeserialListener);
1252 }
1253 }
1254
1255 CI.setASTConsumer(std::move(Consumer));
1256 if (!CI.hasASTConsumer())
1257 return false;
1258 }
1259
1260 // Initialize built-in info as long as we aren't using an external AST
1261 // source.
1262 if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
1263 !CI.getASTContext().getExternalSource()) {
1264 Preprocessor &PP = CI.getPreprocessor();
1265 PP.getBuiltinInfo().initializeBuiltins(Table&: PP.getIdentifierTable(),
1266 LangOpts: PP.getLangOpts());
1267 } else {
1268 // FIXME: If this is a problem, recover from it by creating a multiplex
1269 // source.
1270 assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
1271 "modules enabled but created an external source that "
1272 "doesn't support modules");
1273 }
1274
1275 // If we were asked to load any module files, do so now.
1276 for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles) {
1277 serialization::ModuleFile *Loaded = nullptr;
1278 if (!CI.loadModuleFile(FileName: ModuleFile, LoadedModuleFile&: Loaded))
1279 return false;
1280
1281 if (Loaded && Loaded->StandardCXXModule)
1282 CI.getDiagnostics().Report(
1283 DiagID: diag::warn_eagerly_load_for_standard_cplusplus_modules);
1284 }
1285
1286 // If there is a layout overrides file, attach an external AST source that
1287 // provides the layouts from that file.
1288 if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
1289 CI.hasASTContext() && !CI.getASTContext().getExternalSource()) {
1290 auto Override = llvm::makeIntrusiveRefCnt<LayoutOverrideSource>(
1291 A&: CI.getFrontendOpts().OverrideRecordLayoutsFile);
1292 CI.getASTContext().setExternalSource(Override);
1293 }
1294
1295 // Setup HLSL External Sema Source
1296 if (CI.getLangOpts().HLSL && CI.hasASTContext()) {
1297 auto HLSLSema = llvm::makeIntrusiveRefCnt<HLSLExternalSemaSource>();
1298 if (auto SemaSource = dyn_cast_if_present<ExternalSemaSource>(
1299 Val: CI.getASTContext().getExternalSourcePtr())) {
1300 auto MultiSema = llvm::makeIntrusiveRefCnt<MultiplexExternalSemaSource>(
1301 A: std::move(SemaSource), A: std::move(HLSLSema));
1302 CI.getASTContext().setExternalSource(std::move(MultiSema));
1303 } else
1304 CI.getASTContext().setExternalSource(std::move(HLSLSema));
1305 }
1306
1307 FailureCleanup.release();
1308 return true;
1309}
1310
1311llvm::Error FrontendAction::Execute() {
1312 CompilerInstance &CI = getCompilerInstance();
1313 ExecuteAction();
1314
1315 // If we are supposed to rebuild the global module index, do so now unless
1316 // there were any module-build failures.
1317 if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
1318 CI.hasPreprocessor()) {
1319 StringRef Cache =
1320 CI.getPreprocessor().getHeaderSearchInfo().getSpecificModuleCachePath();
1321 if (!Cache.empty()) {
1322 if (llvm::Error Err = GlobalModuleIndex::writeIndex(
1323 FileMgr&: CI.getFileManager(), PCHContainerRdr: CI.getPCHContainerReader(), Path: Cache)) {
1324 // FIXME this drops the error on the floor, but
1325 // Index/pch-from-libclang.c seems to rely on dropping at least some of
1326 // the error conditions!
1327 consumeError(Err: std::move(Err));
1328 }
1329 }
1330 }
1331
1332 return llvm::Error::success();
1333}
1334
1335void FrontendAction::EndSourceFile() {
1336 CompilerInstance &CI = getCompilerInstance();
1337
1338 // Inform the preprocessor we are done.
1339 if (CI.hasPreprocessor())
1340 CI.getPreprocessor().EndSourceFile();
1341
1342 // Inform the diagnostic client we are done with this source file.
1343 // Do this after notifying the preprocessor, so that end-of-file preprocessor
1344 // callbacks can report diagnostics.
1345 CI.getDiagnosticClient().EndSourceFile();
1346
1347 // Finalize the action.
1348 EndSourceFileAction();
1349
1350 // Sema references the ast consumer, so reset sema first.
1351 //
1352 // FIXME: There is more per-file stuff we could just drop here?
1353 bool DisableFree = CI.getFrontendOpts().DisableFree;
1354 if (DisableFree) {
1355 CI.resetAndLeakSema();
1356 CI.resetAndLeakASTContext();
1357 llvm::BuryPointer(Ptr: CI.takeASTConsumer().get());
1358 } else {
1359 CI.setSema(nullptr);
1360 CI.setASTContext(nullptr);
1361 CI.setASTConsumer(nullptr);
1362 }
1363
1364 if (CI.getFrontendOpts().ShowStats) {
1365 llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFileOrBufferName() << "':\n";
1366 if (CI.hasPreprocessor()) {
1367 CI.getPreprocessor().PrintStats();
1368 CI.getPreprocessor().getIdentifierTable().PrintStats();
1369 CI.getPreprocessor().getHeaderSearchInfo().PrintStats();
1370 }
1371 if (CI.hasSourceManager()) {
1372 CI.getSourceManager().PrintStats();
1373 }
1374 llvm::errs() << "\n";
1375 }
1376
1377 // Cleanup the output streams, and erase the output files if instructed by the
1378 // FrontendAction.
1379 CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
1380
1381 // The resources are owned by AST when the current file is AST.
1382 // So we reset the resources here to avoid users accessing it
1383 // accidently.
1384 if (isCurrentFileAST()) {
1385 if (DisableFree) {
1386 CI.resetAndLeakPreprocessor();
1387 CI.resetAndLeakSourceManager();
1388 CI.resetAndLeakFileManager();
1389 llvm::BuryPointer(Ptr: std::move(CurrentASTUnit));
1390 } else {
1391 CI.setPreprocessor(nullptr);
1392 CI.setSourceManager(nullptr);
1393 CI.setFileManager(nullptr);
1394 }
1395 }
1396
1397 setCompilerInstance(nullptr);
1398 setCurrentInput(CurrentInput: FrontendInputFile());
1399 CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
1400}
1401
1402bool FrontendAction::shouldEraseOutputFiles() {
1403 return getCompilerInstance().getDiagnostics().hasErrorOccurred();
1404}
1405
1406//===----------------------------------------------------------------------===//
1407// Utility Actions
1408//===----------------------------------------------------------------------===//
1409
1410void ASTFrontendAction::ExecuteAction() {
1411 CompilerInstance &CI = getCompilerInstance();
1412 if (!CI.hasPreprocessor())
1413 return;
1414 // This is a fallback: If the client forgets to invoke this, we mark the
1415 // current stack as the bottom. Though not optimal, this could help prevent
1416 // stack overflow during deep recursion.
1417 clang::noteBottomOfStack();
1418
1419 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
1420 // here so the source manager would be initialized.
1421 if (hasCodeCompletionSupport() &&
1422 !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
1423 CI.createCodeCompletionConsumer();
1424
1425 // Use a code completion consumer?
1426 CodeCompleteConsumer *CompletionConsumer = nullptr;
1427 if (CI.hasCodeCompletionConsumer())
1428 CompletionConsumer = &CI.getCodeCompletionConsumer();
1429
1430 if (!CI.hasSema())
1431 CI.createSema(TUKind: getTranslationUnitKind(), CompletionConsumer);
1432
1433 ParseAST(S&: CI.getSema(), PrintStats: CI.getFrontendOpts().ShowStats,
1434 SkipFunctionBodies: CI.getFrontendOpts().SkipFunctionBodies);
1435}
1436
1437void PluginASTAction::anchor() { }
1438
1439std::unique_ptr<ASTConsumer>
1440PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
1441 StringRef InFile) {
1442 llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
1443}
1444
1445bool WrapperFrontendAction::PrepareToExecuteAction(CompilerInstance &CI) {
1446 return WrappedAction->PrepareToExecuteAction(CI);
1447}
1448std::unique_ptr<ASTConsumer>
1449WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
1450 StringRef InFile) {
1451 return WrappedAction->CreateASTConsumer(CI, InFile);
1452}
1453bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) {
1454 return WrappedAction->BeginInvocation(CI);
1455}
1456bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI) {
1457 WrappedAction->setCurrentInput(CurrentInput: getCurrentInput());
1458 WrappedAction->setCompilerInstance(&CI);
1459 auto Ret = WrappedAction->BeginSourceFileAction(CI);
1460 // BeginSourceFileAction may change CurrentInput, e.g. during module builds.
1461 setCurrentInput(CurrentInput: WrappedAction->getCurrentInput());
1462 return Ret;
1463}
1464void WrapperFrontendAction::ExecuteAction() {
1465 WrappedAction->ExecuteAction();
1466}
1467void WrapperFrontendAction::EndSourceFile() { WrappedAction->EndSourceFile(); }
1468void WrapperFrontendAction::EndSourceFileAction() {
1469 WrappedAction->EndSourceFileAction();
1470}
1471bool WrapperFrontendAction::shouldEraseOutputFiles() {
1472 return WrappedAction->shouldEraseOutputFiles();
1473}
1474
1475bool WrapperFrontendAction::usesPreprocessorOnly() const {
1476 return WrappedAction->usesPreprocessorOnly();
1477}
1478TranslationUnitKind WrapperFrontendAction::getTranslationUnitKind() {
1479 return WrappedAction->getTranslationUnitKind();
1480}
1481bool WrapperFrontendAction::hasPCHSupport() const {
1482 return WrappedAction->hasPCHSupport();
1483}
1484bool WrapperFrontendAction::hasASTFileSupport() const {
1485 return WrappedAction->hasASTFileSupport();
1486}
1487bool WrapperFrontendAction::hasIRSupport() const {
1488 return WrappedAction->hasIRSupport();
1489}
1490bool WrapperFrontendAction::hasCodeCompletionSupport() const {
1491 return WrappedAction->hasCodeCompletionSupport();
1492}
1493
1494WrapperFrontendAction::WrapperFrontendAction(
1495 std::unique_ptr<FrontendAction> WrappedAction)
1496 : WrappedAction(std::move(WrappedAction)) {}
1497