| 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/DeclGroup.h" |
| 13 |
#include "clang/Basic/Builtins.h" |
| 14 |
#include "clang/Basic/DiagnosticOptions.h" |
| 15 |
#include "clang/Basic/FileEntry.h" |
| 16 |
#include "clang/Basic/LangStandard.h" |
| 17 |
#include "clang/Basic/Sarif.h" |
| 18 |
#include "clang/Frontend/ASTUnit.h" |
| 19 |
#include "clang/Frontend/CompilerInstance.h" |
| 20 |
#include "clang/Frontend/FrontendDiagnostic.h" |
| 21 |
#include "clang/Frontend/FrontendPluginRegistry.h" |
| 22 |
#include "clang/Frontend/LayoutOverrideSource.h" |
| 23 |
#include "clang/Frontend/MultiplexConsumer.h" |
| 24 |
#include "clang/Frontend/SARIFDiagnosticPrinter.h" |
| 25 |
#include "clang/Frontend/Utils.h" |
| 26 |
#include "clang/Lex/HeaderSearch.h" |
| 27 |
#include "clang/Lex/LiteralSupport.h" |
| 28 |
#include "clang/Lex/Preprocessor.h" |
| 29 |
#include "clang/Lex/PreprocessorOptions.h" |
| 30 |
#include "clang/Parse/ParseAST.h" |
| 31 |
#include "clang/Sema/HLSLExternalSemaSource.h" |
| 32 |
#include "clang/Sema/MultiplexExternalSemaSource.h" |
| 33 |
#include "clang/Serialization/ASTDeserializationListener.h" |
| 34 |
#include "clang/Serialization/ASTReader.h" |
| 35 |
#include "clang/Serialization/GlobalModuleIndex.h" |
| 36 |
#include "llvm/ADT/ScopeExit.h" |
| 37 |
#include "llvm/Support/BuryPointer.h" |
| 38 |
#include "llvm/Support/ErrorHandling.h" |
| 39 |
#include "llvm/Support/FileSystem.h" |
| 40 |
#include "llvm/Support/Path.h" |
| 41 |
#include "llvm/Support/Timer.h" |
| 42 |
#include "llvm/Support/raw_ostream.h" |
| 43 |
#include <memory> |
| 44 |
#include <system_error> |
| 45 |
using namespace clang; |
| 46 |
|
| 47 |
LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry) |
| 48 |
|
| 49 |
namespace { |
| 50 |
|
| 51 |
class DelegatingDeserializationListener : public ASTDeserializationListener { |
| 52 |
ASTDeserializationListener *Previous; |
| 53 |
bool DeletePrevious; |
| 54 |
|
| 55 |
public: |
| 56 |
explicit DelegatingDeserializationListener( |
| 57 |
ASTDeserializationListener *Previous, bool DeletePrevious) |
| 58 |
: Previous(Previous), DeletePrevious(DeletePrevious) {} |
| 59 |
~DelegatingDeserializationListener() override { |
| 60 |
if (DeletePrevious) |
| 61 |
delete Previous; |
| 62 |
} |
| 63 |
|
| 64 |
void ReaderInitialized(ASTReader *Reader) override { |
| 65 |
if (Previous) |
| 66 |
Previous->ReaderInitialized(Reader); |
| 67 |
} |
| 68 |
void IdentifierRead(serialization::IdentID ID, |
| 69 |
IdentifierInfo *II) override { |
| 70 |
if (Previous) |
| 71 |
Previous->IdentifierRead(ID, II); |
| 72 |
} |
| 73 |
void TypeRead(serialization::TypeIdx Idx, QualType T) override { |
| 74 |
if (Previous) |
| 75 |
Previous->TypeRead(Idx, T); |
| 76 |
} |
| 77 |
void DeclRead(serialization::DeclID ID, const Decl *D) override { |
| 78 |
if (Previous) |
| 79 |
Previous->DeclRead(ID, D); |
| 80 |
} |
| 81 |
void SelectorRead(serialization::SelectorID ID, Selector Sel) override { |
| 82 |
if (Previous) |
| 83 |
Previous->SelectorRead(ID, Sel); |
| 84 |
} |
| 85 |
void MacroDefinitionRead(serialization::PreprocessedEntityID PPID, |
| 86 |
MacroDefinitionRecord *MD) override { |
| 87 |
if (Previous) |
| 88 |
Previous->MacroDefinitionRead(PPID, MD); |
| 89 |
} |
| 90 |
}; |
| 91 |
|
| 92 |
/// Dumps deserialized declarations. |
| 93 |
class DeserializedDeclsDumper : public DelegatingDeserializationListener { |
| 94 |
public: |
| 95 |
explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous, |
| 96 |
bool DeletePrevious) |
| 97 |
: DelegatingDeserializationListener(Previous, DeletePrevious) {} |
| 98 |
|
| 99 |
void DeclRead(serialization::DeclID ID, const Decl *D) override { |
| 100 |
llvm::outs() << "PCH DECL: " << D->getDeclKindName(); |
| 101 |
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) { |
| 102 |
llvm::outs() << " - "; |
| 103 |
ND->printQualifiedName(llvm::outs()); |
| 104 |
} |
| 105 |
llvm::outs() << "\n"; |
| 106 |
|
| 107 |
DelegatingDeserializationListener::DeclRead(ID, D); |
| 108 |
} |
| 109 |
}; |
| 110 |
|
| 111 |
/// Checks deserialized declarations and emits error if a name |
| 112 |
/// matches one given in command-line using -error-on-deserialized-decl. |
| 113 |
class DeserializedDeclsChecker : public DelegatingDeserializationListener { |
| 114 |
ASTContext &Ctx; |
| 115 |
std::set<std::string> NamesToCheck; |
| 116 |
|
| 117 |
public: |
| 118 |
DeserializedDeclsChecker(ASTContext &Ctx, |
| 119 |
const std::set<std::string> &NamesToCheck, |
| 120 |
ASTDeserializationListener *Previous, |
| 121 |
bool DeletePrevious) |
| 122 |
: DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx), |
| 123 |
NamesToCheck(NamesToCheck) {} |
| 124 |
|
| 125 |
void DeclRead(serialization::DeclID ID, const Decl *D) override { |
| 126 |
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
| 127 |
if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) { |
| 128 |
unsigned DiagID |
| 129 |
= Ctx.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, |
| 130 |
"%0 was deserialized"); |
| 131 |
Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID) |
| 132 |
<< ND; |
| 133 |
} |
| 134 |
|
| 135 |
DelegatingDeserializationListener::DeclRead(ID, D); |
| 136 |
} |
| 137 |
}; |
| 138 |
|
| 139 |
} // end anonymous namespace |
| 140 |
|
| 141 |
FrontendAction::FrontendAction() : Instance(nullptr) {} |
| 142 |
|
| 143 |
FrontendAction::~FrontendAction() {} |
| 144 |
|
| 145 |
void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput, |
| 146 |
std::unique_ptr<ASTUnit> AST) { |
| 147 |
this->CurrentInput = CurrentInput; |
| 148 |
CurrentASTUnit = std::move(AST); |
| 149 |
} |
| 150 |
|
| 151 |
Module *FrontendAction::getCurrentModule() const { |
| 152 |
CompilerInstance &CI = getCompilerInstance(); |
| 153 |
return CI.getPreprocessor().getHeaderSearchInfo().lookupModule( |
| 154 |
CI.getLangOpts().CurrentModule, SourceLocation(), /*AllowSearch*/false); |
| 155 |
} |
| 156 |
|
| 157 |
std::unique_ptr<ASTConsumer> |
| 158 |
FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, |
| 159 |
StringRef InFile) { |
| 160 |
std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile); |
| 161 |
if (!Consumer) |
| 162 |
return nullptr; |
| 163 |
|
| 164 |
// Validate -add-plugin args. |
| 165 |
bool FoundAllPlugins = true; |
| 166 |
for (const std::string &Arg : CI.getFrontendOpts().AddPluginActions) { |
| 167 |
bool Found = false; |
| 168 |
for (const FrontendPluginRegistry::entry &Plugin : |
| 169 |
FrontendPluginRegistry::entries()) { |
| 170 |
if (Plugin.getName() == Arg) |
| 171 |
Found = true; |
| 172 |
} |
| 173 |
if (!Found) { |
| 174 |
CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name) << Arg; |
| 175 |
FoundAllPlugins = false; |
| 176 |
} |
| 177 |
} |
| 178 |
if (!FoundAllPlugins) |
| 179 |
return nullptr; |
| 180 |
|
| 181 |
// If there are no registered plugins we don't need to wrap the consumer |
| 182 |
if (FrontendPluginRegistry::begin() == FrontendPluginRegistry::end()) |
| 183 |
return Consumer; |
| 184 |
|
| 185 |
// If this is a code completion run, avoid invoking the plugin consumers |
| 186 |
if (CI.hasCodeCompletionConsumer()) |
| 187 |
return Consumer; |
| 188 |
|
| 189 |
// Collect the list of plugins that go before the main action (in Consumers) |
| 190 |
// or after it (in AfterConsumers) |
| 191 |
std::vector<std::unique_ptr<ASTConsumer>> Consumers; |
| 192 |
std::vector<std::unique_ptr<ASTConsumer>> AfterConsumers; |
| 193 |
for (const FrontendPluginRegistry::entry &Plugin : |
| 194 |
FrontendPluginRegistry::entries()) { |
| 195 |
std::unique_ptr<PluginASTAction> P = Plugin.instantiate(); |
| 196 |
PluginASTAction::ActionType ActionType = P->getActionType(); |
| 197 |
if (ActionType == PluginASTAction::CmdlineAfterMainAction || |
| 198 |
ActionType == PluginASTAction::CmdlineBeforeMainAction) { |
| 199 |
// This is O(|plugins| * |add_plugins|), but since both numbers are |
| 200 |
// way below 50 in practice, that's ok. |
| 201 |
if (llvm::is_contained(CI.getFrontendOpts().AddPluginActions, |
| 202 |
Plugin.getName())) { |
| 203 |
if (ActionType == PluginASTAction::CmdlineBeforeMainAction) |
| 204 |
ActionType = PluginASTAction::AddBeforeMainAction; |
| 205 |
else |
| 206 |
ActionType = PluginASTAction::AddAfterMainAction; |
| 207 |
} |
| 208 |
} |
| 209 |
if ((ActionType == PluginASTAction::AddBeforeMainAction || |
| 210 |
ActionType == PluginASTAction::AddAfterMainAction) && |
| 211 |
P->ParseArgs( |
| 212 |
CI, |
| 213 |
CI.getFrontendOpts().PluginArgs[std::string(Plugin.getName())])) { |
| 214 |
std::unique_ptr<ASTConsumer> PluginConsumer = P->CreateASTConsumer(CI, InFile); |
| 215 |
if (ActionType == PluginASTAction::AddBeforeMainAction) { |
| 216 |
Consumers.push_back(std::move(PluginConsumer)); |
| 217 |
} else { |
| 218 |
AfterConsumers.push_back(std::move(PluginConsumer)); |
| 219 |
} |
| 220 |
} |
| 221 |
} |
| 222 |
|
| 223 |
// Add to Consumers the main consumer, then all the plugins that go after it |
| 224 |
Consumers.push_back(std::move(Consumer)); |
| 225 |
if (!AfterConsumers.empty()) { |
| 226 |
// If we have plugins after the main consumer, which may be the codegen |
| 227 |
// action, they likely will need the ASTContext, so don't clear it in the |
| 228 |
// codegen action. |
| 229 |
CI.getCodeGenOpts().ClearASTBeforeBackend = false; |
| 230 |
for (auto &C : AfterConsumers) |
| 231 |
Consumers.push_back(std::move(C)); |
| 232 |
} |
| 233 |
|
| 234 |
return std::make_unique<MultiplexConsumer>(std::move(Consumers)); |
| 235 |
} |
| 236 |
|
| 237 |
/// For preprocessed files, if the first line is the linemarker and specifies |
| 238 |
/// the original source file name, use that name as the input file name. |
| 239 |
/// Returns the location of the first token after the line marker directive. |
| 240 |
/// |
| 241 |
/// \param CI The compiler instance. |
| 242 |
/// \param InputFile Populated with the filename from the line marker. |
| 243 |
/// \param IsModuleMap If \c true, add a line note corresponding to this line |
| 244 |
/// directive. (We need to do this because the directive will not be |
| 245 |
/// visited by the preprocessor.) |
| 246 |
static SourceLocation ReadOriginalFileName(CompilerInstance &CI, |
| 247 |
std::string &InputFile, |
| 248 |
bool IsModuleMap = false) { |
| 249 |
auto &SourceMgr = CI.getSourceManager(); |
| 250 |
auto MainFileID = SourceMgr.getMainFileID(); |
| 251 |
|
| 252 |
auto MainFileBuf = SourceMgr.getBufferOrNone(MainFileID); |
| 253 |
if (!MainFileBuf) |
| 254 |
return SourceLocation(); |
| 255 |
|
| 256 |
std::unique_ptr<Lexer> RawLexer( |
| 257 |
new Lexer(MainFileID, *MainFileBuf, SourceMgr, CI.getLangOpts())); |
| 258 |
|
| 259 |
// If the first line has the syntax of |
| 260 |
// |
| 261 |
// # NUM "FILENAME" |
| 262 |
// |
| 263 |
// we use FILENAME as the input file name. |
| 264 |
Token T; |
| 265 |
if (RawLexer->LexFromRawLexer(T) || T.getKind() != tok::hash) |
| 266 |
return SourceLocation(); |
| 267 |
if (RawLexer->LexFromRawLexer(T) || T.isAtStartOfLine() || |
| 268 |
T.getKind() != tok::numeric_constant) |
| 269 |
return SourceLocation(); |
| 270 |
|
| 271 |
unsigned LineNo; |
| 272 |
SourceLocation LineNoLoc = T.getLocation(); |
| 273 |
if (IsModuleMap) { |
| 274 |
llvm::SmallString<16> Buffer; |
| 275 |
if (Lexer::getSpelling(LineNoLoc, Buffer, SourceMgr, CI.getLangOpts()) |
| 276 |
.getAsInteger(10, LineNo)) |
| 277 |
return SourceLocation(); |
| 278 |
} |
| 279 |
|
| 280 |
RawLexer->LexFromRawLexer(T); |
| 281 |
if (T.isAtStartOfLine() || T.getKind() != tok::string_literal) |
| 282 |
return SourceLocation(); |
| 283 |
|
| 284 |
StringLiteralParser Literal(T, CI.getPreprocessor()); |
| 285 |
if (Literal.hadError) |
| 286 |
return SourceLocation(); |
| 287 |
RawLexer->LexFromRawLexer(T); |
| 288 |
if (T.isNot(tok::eof) && !T.isAtStartOfLine()) |
| 289 |
return SourceLocation(); |
| 290 |
InputFile = Literal.GetString().str(); |
| 291 |
|
| 292 |
if (IsModuleMap) |
| 293 |
CI.getSourceManager().AddLineNote( |
| 294 |
LineNoLoc, LineNo, SourceMgr.getLineTableFilenameID(InputFile), false, |
| 295 |
false, SrcMgr::C_User_ModuleMap); |
| 296 |
|
| 297 |
return T.getLocation(); |
| 298 |
} |
| 299 |
|
| 300 |
static SmallVectorImpl<char> & |
| 301 |
operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) { |
| 302 |
Includes.append(RHS.begin(), RHS.end()); |
| 303 |
return Includes; |
| 304 |
} |
| 305 |
|
| 306 |
static void addHeaderInclude(StringRef HeaderName, |
| 307 |
SmallVectorImpl<char> &Includes, |
| 308 |
const LangOptions &LangOpts, |
| 309 |
bool IsExternC) { |
| 310 |
if (IsExternC && LangOpts.CPlusPlus) |
| 311 |
Includes += "extern \"C\" {\n"; |
| 312 |
if (LangOpts.ObjC) |
| 313 |
Includes += "#import \""; |
| 314 |
else |
| 315 |
Includes += "#include \""; |
| 316 |
|
| 317 |
Includes += HeaderName; |
| 318 |
|
| 319 |
Includes += "\"\n"; |
| 320 |
if (IsExternC && LangOpts.CPlusPlus) |
| 321 |
Includes += "}\n"; |
| 322 |
} |
| 323 |
|
| 324 |
/// Collect the set of header includes needed to construct the given |
| 325 |
/// module and update the TopHeaders file set of the module. |
| 326 |
/// |
| 327 |
/// \param Module The module we're collecting includes from. |
| 328 |
/// |
| 329 |
/// \param Includes Will be augmented with the set of \#includes or \#imports |
| 330 |
/// needed to load all of the named headers. |
| 331 |
static std::error_code collectModuleHeaderIncludes( |
| 332 |
const LangOptions &LangOpts, FileManager &FileMgr, DiagnosticsEngine &Diag, |
| 333 |
ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl<char> &Includes) { |
| 334 |
// Don't collect any headers for unavailable modules. |
| 335 |
if (!Module->isAvailable()) |
| 336 |
return std::error_code(); |
| 337 |
|
| 338 |
// Resolve all lazy header directives to header files. |
| 339 |
ModMap.resolveHeaderDirectives(Module, /*File=*/std::nullopt); |
| 340 |
|
| 341 |
// If any headers are missing, we can't build this module. In most cases, |
| 342 |
// diagnostics for this should have already been produced; we only get here |
| 343 |
// if explicit stat information was provided. |
| 344 |
// FIXME: If the name resolves to a file with different stat information, |
| 345 |
// produce a better diagnostic. |
| 346 |
if (!Module->MissingHeaders.empty()) { |
| 347 |
auto &MissingHeader = Module->MissingHeaders.front(); |
| 348 |
Diag.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) |
| 349 |
<< MissingHeader.IsUmbrella << MissingHeader.FileName; |
| 350 |
return std::error_code(); |
| 351 |
} |
| 352 |
|
| 353 |
// Add includes for each of these headers. |
| 354 |
for (auto HK : {Module::HK_Normal, Module::HK_Private}) { |
| 355 |
for (Module::Header &H : Module->Headers[HK]) { |
| 356 |
Module->addTopHeader(H.Entry); |
| 357 |
// Use the path as specified in the module map file. We'll look for this |
| 358 |
// file relative to the module build directory (the directory containing |
| 359 |
// the module map file) so this will find the same file that we found |
| 360 |
// while parsing the module map. |
| 361 |
addHeaderInclude(H.PathRelativeToRootModuleDirectory, Includes, LangOpts, |
| 362 |
Module->IsExternC); |
| 363 |
} |
| 364 |
} |
| 365 |
// Note that Module->PrivateHeaders will not be a TopHeader. |
| 366 |
|
| 367 |
if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) { |
| 368 |
Module->addTopHeader(UmbrellaHeader.Entry); |
| 369 |
if (Module->Parent) |
| 370 |
// Include the umbrella header for submodules. |
| 371 |
addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory, |
| 372 |
Includes, LangOpts, Module->IsExternC); |
| 373 |
} else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) { |
| 374 |
// Add all of the headers we find in this subdirectory. |
| 375 |
std::error_code EC; |
| 376 |
SmallString<128> DirNative; |
| 377 |
llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative); |
| 378 |
|
| 379 |
llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem(); |
| 380 |
SmallVector< |
| 381 |
std::pair<std::string, OptionalFileEntryRefDegradesToFileEntryPtr>, 8> |
| 382 |
Headers; |
| 383 |
for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End; |
| 384 |
Dir != End && !EC; Dir.increment(EC)) { |
| 385 |
// Check whether this entry has an extension typically associated with |
| 386 |
// headers. |
| 387 |
if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path())) |
| 388 |
.Cases(".h", ".H", ".hh", ".hpp", true) |
| 389 |
.Default(false)) |
| 390 |
continue; |
| 391 |
|
| 392 |
auto Header = FileMgr.getOptionalFileRef(Dir->path()); |
| 393 |
// FIXME: This shouldn't happen unless there is a file system race. Is |
| 394 |
// that worth diagnosing? |
| 395 |
if (!Header) |
| 396 |
continue; |
| 397 |
|
| 398 |
// If this header is marked 'unavailable' in this module, don't include |
| 399 |
// it. |
| 400 |
if (ModMap.isHeaderUnavailableInModule(*Header, Module)) |
| 401 |
continue; |
| 402 |
|
| 403 |
// Compute the relative path from the directory to this file. |
| 404 |
SmallVector<StringRef, 16> Components; |
| 405 |
auto PathIt = llvm::sys::path::rbegin(Dir->path()); |
| 406 |
for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt) |
| 407 |
Components.push_back(*PathIt); |
| 408 |
SmallString<128> RelativeHeader( |
| 409 |
UmbrellaDir.PathRelativeToRootModuleDirectory); |
| 410 |
for (auto It = Components.rbegin(), End = Components.rend(); It != End; |
| 411 |
++It) |
| 412 |
llvm::sys::path::append(RelativeHeader, *It); |
| 413 |
|
| 414 |
std::string RelName = RelativeHeader.c_str(); |
| 415 |
Headers.push_back(std::make_pair(RelName, *Header)); |
| 416 |
} |
| 417 |
|
| 418 |
if (EC) |
| 419 |
return EC; |
| 420 |
|
| 421 |
// Sort header paths and make the header inclusion order deterministic |
| 422 |
// across different OSs and filesystems. |
| 423 |
llvm::sort(Headers, llvm::less_first()); |
| 424 |
for (auto &H : Headers) { |
| 425 |
// Include this header as part of the umbrella directory. |
| 426 |
Module->addTopHeader(H.second); |
| 427 |
addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC); |
| 428 |
} |
| 429 |
} |
| 430 |
|
| 431 |
// Recurse into submodules. |
| 432 |
for (clang::Module::submodule_iterator Sub = Module->submodule_begin(), |
| 433 |
SubEnd = Module->submodule_end(); |
| 434 |
Sub != SubEnd; ++Sub) |
| 435 |
if (std::error_code Err = collectModuleHeaderIncludes( |
| 436 |
LangOpts, FileMgr, Diag, ModMap, *Sub, Includes)) |
| 437 |
return Err; |
| 438 |
|
| 439 |
return std::error_code(); |
| 440 |
} |
| 441 |
|
| 442 |
static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem, |
| 443 |
bool IsPreprocessed, |
| 444 |
std::string &PresumedModuleMapFile, |
| 445 |
unsigned &Offset) { |
| 446 |
auto &SrcMgr = CI.getSourceManager(); |
| 447 |
HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo(); |
| 448 |
|
| 449 |
// Map the current input to a file. |
| 450 |
FileID ModuleMapID = SrcMgr.getMainFileID(); |
| 451 |
const FileEntry *ModuleMap = SrcMgr.getFileEntryForID(ModuleMapID); |
| 452 |
|
| 453 |
// If the module map is preprocessed, handle the initial line marker; |
| 454 |
// line directives are not part of the module map syntax in general. |
| 455 |
Offset = 0; |
| 456 |
if (IsPreprocessed) { |
| 457 |
SourceLocation EndOfLineMarker = |
| 458 |
ReadOriginalFileName(CI, PresumedModuleMapFile, /*IsModuleMap*/ true); |
| 459 |
if (EndOfLineMarker.isValid()) |
| 460 |
Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second; |
| 461 |
} |
| 462 |
|
| 463 |
// Load the module map file. |
| 464 |
if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset, |
| 465 |
PresumedModuleMapFile)) |
| 466 |
return true; |
| 467 |
|
| 468 |
if (SrcMgr.getBufferOrFake(ModuleMapID).getBufferSize() == Offset) |
| 469 |
Offset = 0; |
| 470 |
|
| 471 |
// Infer framework module if possible. |
| 472 |
if (HS.getModuleMap().canInferFrameworkModule(ModuleMap->getDir())) { |
| 473 |
SmallString<128> InferredFrameworkPath = ModuleMap->getDir()->getName(); |
| 474 |
llvm::sys::path::append(InferredFrameworkPath, |
| 475 |
CI.getLangOpts().ModuleName + ".framework"); |
| 476 |
if (auto Dir = CI.getFileManager().getDirectory(InferredFrameworkPath)) |
| 477 |
(void)HS.getModuleMap().inferFrameworkModule(*Dir, IsSystem, nullptr); |
| 478 |
} |
| 479 |
|
| 480 |
return false; |
| 481 |
} |
| 482 |
|
| 483 |
static Module *prepareToBuildModule(CompilerInstance &CI, |
| 484 |
StringRef ModuleMapFilename) { |
| 485 |
if (CI.getLangOpts().CurrentModule.empty()) { |
| 486 |
CI.getDiagnostics().Report(diag::err_missing_module_name); |
| 487 |
|
| 488 |
// FIXME: Eventually, we could consider asking whether there was just |
| 489 |
// a single module described in the module map, and use that as a |
| 490 |
// default. Then it would be fairly trivial to just "compile" a module |
| 491 |
// map with a single module (the common case). |
| 492 |
return nullptr; |
| 493 |
} |
| 494 |
|
| 495 |
// Dig out the module definition. |
| 496 |
HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo(); |
| 497 |
Module *M = HS.lookupModule(CI.getLangOpts().CurrentModule, SourceLocation(), |
| 498 |
/*AllowSearch=*/true); |
| 499 |
if (!M) { |
| 500 |
CI.getDiagnostics().Report(diag::err_missing_module) |
| 501 |
<< CI.getLangOpts().CurrentModule << ModuleMapFilename; |
| 502 |
|
| 503 |
return nullptr; |
| 504 |
} |
| 505 |
|
| 506 |
// Check whether we can build this module at all. |
| 507 |
if (Preprocessor::checkModuleIsAvailable(CI.getLangOpts(), CI.getTarget(), |
| 508 |
CI.getDiagnostics(), M)) |
| 509 |
return nullptr; |
| 510 |
|
| 511 |
// Inform the preprocessor that includes from within the input buffer should |
| 512 |
// be resolved relative to the build directory of the module map file. |
| 513 |
CI.getPreprocessor().setMainFileDir(M->Directory); |
| 514 |
|
| 515 |
// If the module was inferred from a different module map (via an expanded |
| 516 |
// umbrella module definition), track that fact. |
| 517 |
// FIXME: It would be preferable to fill this in as part of processing |
| 518 |
// the module map, rather than adding it after the fact. |
| 519 |
StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap; |
| 520 |
if (!OriginalModuleMapName.empty()) { |
| 521 |
auto OriginalModuleMap = |
| 522 |
CI.getFileManager().getFile(OriginalModuleMapName, |
| 523 |
/*openFile*/ true); |
| 524 |
if (!OriginalModuleMap) { |
| 525 |
CI.getDiagnostics().Report(diag::err_module_map_not_found) |
| 526 |
<< OriginalModuleMapName; |
| 527 |
return nullptr; |
| 528 |
} |
| 529 |
if (*OriginalModuleMap != CI.getSourceManager().getFileEntryForID( |
| 530 |
CI.getSourceManager().getMainFileID())) { |
| 531 |
M->IsInferred = true; |
| 532 |
CI.getPreprocessor().getHeaderSearchInfo().getModuleMap() |
| 533 |
.setInferredModuleAllowedBy(M, *OriginalModuleMap); |
| 534 |
} |
| 535 |
} |
| 536 |
|
| 537 |
// If we're being run from the command-line, the module build stack will not |
| 538 |
// have been filled in yet, so complete it now in order to allow us to detect |
| 539 |
// module cycles. |
| 540 |
SourceManager &SourceMgr = CI.getSourceManager(); |
| 541 |
if (SourceMgr.getModuleBuildStack().empty()) |
| 542 |
SourceMgr.pushModuleBuildStack(CI.getLangOpts().CurrentModule, |
| 543 |
FullSourceLoc(SourceLocation(), SourceMgr)); |
| 544 |
return M; |
| 545 |
} |
| 546 |
|
| 547 |
/// Compute the input buffer that should be used to build the specified module. |
| 548 |
static std::unique_ptr<llvm::MemoryBuffer> |
| 549 |
getInputBufferForModule(CompilerInstance &CI, Module *M) { |
| 550 |
FileManager &FileMgr = CI.getFileManager(); |
| 551 |
|
| 552 |
// Collect the set of #includes we need to build the module. |
| 553 |
SmallString<256> HeaderContents; |
| 554 |
std::error_code Err = std::error_code(); |
| 555 |
if (Module::Header UmbrellaHeader = M->getUmbrellaHeader()) |
| 556 |
addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory, |
| 557 |
HeaderContents, CI.getLangOpts(), M->IsExternC); |
| 558 |
Err = collectModuleHeaderIncludes( |
| 559 |
CI.getLangOpts(), FileMgr, CI.getDiagnostics(), |
| 560 |
CI.getPreprocessor().getHeaderSearchInfo().getModuleMap(), M, |
| 561 |
HeaderContents); |
| 562 |
|
| 563 |
if (Err) { |
| 564 |
CI.getDiagnostics().Report(diag::err_module_cannot_create_includes) |
| 565 |
<< M->getFullModuleName() << Err.message(); |
| 566 |
return nullptr; |
| 567 |
} |
| 568 |
|
| 569 |
return llvm::MemoryBuffer::getMemBufferCopy( |
| 570 |
HeaderContents, Module::getModuleInputBufferName()); |
| 571 |
} |
| 572 |
|
| 573 |
bool FrontendAction::BeginSourceFile(CompilerInstance &CI, |
| 574 |
const FrontendInputFile &RealInput) { |
| 575 |
FrontendInputFile Input(RealInput); |
| 576 |
assert(!Instance && "Already processing a source file!"); |
| 577 |
assert(!Input.isEmpty() && "Unexpected empty filename!"); |
| 578 |
setCurrentInput(Input); |
| 579 |
setCompilerInstance(&CI); |
| 580 |
|
| 581 |
bool HasBegunSourceFile = false; |
| 582 |
bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled && |
| 583 |
usesPreprocessorOnly(); |
| 584 |
|
| 585 |
// If we fail, reset state since the client will not end up calling the |
| 586 |
// matching EndSourceFile(). All paths that return true should release this. |
| 587 |
auto FailureCleanup = llvm::make_scope_exit([&]() { |
| 588 |
if (HasBegunSourceFile) |
| 589 |
CI.getDiagnosticClient().EndSourceFile(); |
| 590 |
CI.setASTConsumer(nullptr); |
| 591 |
CI.clearOutputFiles(/*EraseFiles=*/true); |
| 592 |
CI.getLangOpts().setCompilingModule(LangOptions::CMK_None); |
| 593 |
setCurrentInput(FrontendInputFile()); |
| 594 |
setCompilerInstance(nullptr); |
| 595 |
}); |
| 596 |
|
| 597 |
if (!BeginInvocation(CI)) |
| 598 |
return false; |
| 599 |
|
| 600 |
// If we're replaying the build of an AST file, import it and set up |
| 601 |
// the initial state from its build. |
| 602 |
if (ReplayASTFile) { |
| 603 |
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics()); |
| 604 |
|
| 605 |
// The AST unit populates its own diagnostics engine rather than ours. |
| 606 |
IntrusiveRefCntPtr<DiagnosticsEngine> ASTDiags( |
| 607 |
new DiagnosticsEngine(Diags->getDiagnosticIDs(), |
| 608 |
&Diags->getDiagnosticOptions())); |
| 609 |
ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false); |
| 610 |
|
| 611 |
// FIXME: What if the input is a memory buffer? |
| 612 |
StringRef InputFile = Input.getFile(); |
| 613 |
|
| 614 |
std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile( |
| 615 |
std::string(InputFile), CI.getPCHContainerReader(), |
| 616 |
ASTUnit::LoadPreprocessorOnly, ASTDiags, CI.getFileSystemOpts(), |
| 617 |
CI.getCodeGenOpts().DebugTypeExtRefs); |
| 618 |
if (!AST) |
| 619 |
return false; |
| 620 |
|
| 621 |
// Options relating to how we treat the input (but not what we do with it) |
| 622 |
// are inherited from the AST unit. |
| 623 |
CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts(); |
| 624 |
CI.getPreprocessorOpts() = AST->getPreprocessorOpts(); |
| 625 |
CI.getLangOpts() = AST->getLangOpts(); |
| 626 |
|
| 627 |
// Set the shared objects, these are reset when we finish processing the |
| 628 |
// file, otherwise the CompilerInstance will happily destroy them. |
| 629 |
CI.setFileManager(&AST->getFileManager()); |
| 630 |
CI.createSourceManager(CI.getFileManager()); |
| 631 |
CI.getSourceManager().initializeForReplay(AST->getSourceManager()); |
| 632 |
|
| 633 |
// Preload all the module files loaded transitively by the AST unit. Also |
| 634 |
// load all module map files that were parsed as part of building the AST |
| 635 |
// unit. |
| 636 |
if (auto ASTReader = AST->getASTReader()) { |
| 637 |
auto &MM = ASTReader->getModuleManager(); |
| 638 |
auto &PrimaryModule = MM.getPrimaryModule(); |
| 639 |
|
| 640 |
for (serialization::ModuleFile &MF : MM) |
| 641 |
if (&MF != &PrimaryModule) |
| 642 |
CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName); |
| 643 |
|
| 644 |
ASTReader->visitTopLevelModuleMaps(PrimaryModule, [&](FileEntryRef FE) { |
| 645 |
CI.getFrontendOpts().ModuleMapFiles.push_back( |
| 646 |
std::string(FE.getName())); |
| 647 |
}); |
| 648 |
} |
| 649 |
|
| 650 |
// Set up the input file for replay purposes. |
| 651 |
auto Kind = AST->getInputKind(); |
| 652 |
if (Kind.getFormat() == InputKind::ModuleMap) { |
| 653 |
Module *ASTModule = |
| 654 |
AST->getPreprocessor().getHeaderSearchInfo().lookupModule( |
| 655 |
AST->getLangOpts().CurrentModule, SourceLocation(), |
| 656 |
/*AllowSearch*/ false); |
| 657 |
assert(ASTModule && "module file does not define its own module"); |
| 658 |
Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind); |
| 659 |
} else { |
| 660 |
auto &OldSM = AST->getSourceManager(); |
| 661 |
FileID ID = OldSM.getMainFileID(); |
| 662 |
if (auto *File = OldSM.getFileEntryForID(ID)) |
| 663 |
Input = FrontendInputFile(File->getName(), Kind); |
| 664 |
else |
| 665 |
Input = FrontendInputFile(OldSM.getBufferOrFake(ID), Kind); |
| 666 |
} |
| 667 |
setCurrentInput(Input, std::move(AST)); |
| 668 |
} |
| 669 |
|
| 670 |
// AST files follow a very different path, since they share objects via the |
| 671 |
// AST unit. |
| 672 |
if (Input.getKind().getFormat() == InputKind::Precompiled) { |
| 673 |
assert(!usesPreprocessorOnly() && "this case was handled above"); |
| 674 |
assert(hasASTFileSupport() && |
| 675 |
"This action does not have AST file support!"); |
| 676 |
|
| 677 |
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics()); |
| 678 |
|
| 679 |
// FIXME: What if the input is a memory buffer? |
| 680 |
StringRef InputFile = Input.getFile(); |
| 681 |
|
| 682 |
std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile( |
| 683 |
std::string(InputFile), CI.getPCHContainerReader(), |
| 684 |
ASTUnit::LoadEverything, Diags, CI.getFileSystemOpts(), |
| 685 |
CI.getCodeGenOpts().DebugTypeExtRefs); |
| 686 |
|
| 687 |
if (!AST) |
| 688 |
return false; |
| 689 |
|
| 690 |
// Inform the diagnostic client we are processing a source file. |
| 691 |
CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr); |
| 692 |
HasBegunSourceFile = true; |
| 693 |
|
| 694 |
// Set the shared objects, these are reset when we finish processing the |
| 695 |
// file, otherwise the CompilerInstance will happily destroy them. |
| 696 |
CI.setFileManager(&AST->getFileManager()); |
| 697 |
CI.setSourceManager(&AST->getSourceManager()); |
| 698 |
CI.setPreprocessor(AST->getPreprocessorPtr()); |
| 699 |
Preprocessor &PP = CI.getPreprocessor(); |
| 700 |
PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(), |
| 701 |
PP.getLangOpts()); |
| 702 |
CI.setASTContext(&AST->getASTContext()); |
| 703 |
|
| 704 |
setCurrentInput(Input, std::move(AST)); |
| 705 |
|
| 706 |
// Initialize the action. |
| 707 |
if (!BeginSourceFileAction(CI)) |
| 708 |
return false; |
| 709 |
|
| 710 |
// Create the AST consumer. |
| 711 |
CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile)); |
| 712 |
if (!CI.hasASTConsumer()) |
| 713 |
return false; |
| 714 |
|
| 715 |
FailureCleanup.release(); |
| 716 |
return true; |
| 717 |
} |
| 718 |
|
| 719 |
// Set up the file and source managers, if needed. |
| 720 |
if (!CI.hasFileManager()) { |
| 721 |
if (!CI.createFileManager()) { |
| 722 |
return false; |
| 723 |
} |
| 724 |
} |
| 725 |
if (!CI.hasSourceManager()) { |
| 726 |
CI.createSourceManager(CI.getFileManager()); |
| 727 |
if (CI.getDiagnosticOpts().getFormat() == DiagnosticOptions::SARIF) { |
| 728 |
static_cast<SARIFDiagnosticPrinter *>(&CI.getDiagnosticClient()) |
| 729 |
->setSarifWriter( |
| 730 |
std::make_unique<SarifDocumentWriter>(CI.getSourceManager())); |
| 731 |
} |
| 732 |
} |
| 733 |
|
| 734 |
// Set up embedding for any specified files. Do this before we load any |
| 735 |
// source files, including the primary module map for the compilation. |
| 736 |
for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) { |
| 737 |
if (auto FE = CI.getFileManager().getFile(F, /*openFile*/true)) |
| 738 |
CI.getSourceManager().setFileIsTransient(*FE); |
| 739 |
else |
| 740 |
CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F; |
| 741 |
} |
| 742 |
if (CI.getFrontendOpts().ModulesEmbedAllFiles) |
| 743 |
CI.getSourceManager().setAllFilesAreTransient(true); |
| 744 |
|
| 745 |
// IR files bypass the rest of initialization. |
| 746 |
if (Input.getKind().getLanguage() == Language::LLVM_IR) { |
| 747 |
assert(hasIRSupport() && |
| 748 |
"This action does not have IR file support!"); |
| 749 |
|
| 750 |
// Inform the diagnostic client we are processing a source file. |
| 751 |
CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr); |
| 752 |
HasBegunSourceFile = true; |
| 753 |
|
| 754 |
// Initialize the action. |
| 755 |
if (!BeginSourceFileAction(CI)) |
| 756 |
return false; |
| 757 |
|
| 758 |
// Initialize the main file entry. |
| 759 |
if (!CI.InitializeSourceManager(CurrentInput)) |
| 760 |
return false; |
| 761 |
|
| 762 |
FailureCleanup.release(); |
| 763 |
return true; |
| 764 |
} |
| 765 |
|
| 766 |
// If the implicit PCH include is actually a directory, rather than |
| 767 |
// a single file, search for a suitable PCH file in that directory. |
| 768 |
if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) { |
| 769 |
FileManager &FileMgr = CI.getFileManager(); |
| 770 |
PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); |
| 771 |
StringRef PCHInclude = PPOpts.ImplicitPCHInclude; |
| 772 |
std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath(); |
| 773 |
if (auto PCHDir = FileMgr.getOptionalDirectoryRef(PCHInclude)) { |
| 774 |
std::error_code EC; |
| 775 |
SmallString<128> DirNative; |
| 776 |
llvm::sys::path::native(PCHDir->getName(), DirNative); |
| 777 |
bool Found = false; |
| 778 |
llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem(); |
| 779 |
for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), |
| 780 |
DirEnd; |
| 781 |
Dir != DirEnd && !EC; Dir.increment(EC)) { |
| 782 |
// Check whether this is an acceptable AST file. |
| 783 |
if (ASTReader::isAcceptableASTFile( |
| 784 |
Dir->path(), FileMgr, CI.getModuleCache(), |
| 785 |
CI.getPCHContainerReader(), CI.getLangOpts(), |
| 786 |
CI.getTargetOpts(), CI.getPreprocessorOpts(), |
| 787 |
SpecificModuleCachePath, /*RequireStrictOptionMatches=*/true)) { |
| 788 |
PPOpts.ImplicitPCHInclude = std::string(Dir->path()); |
| 789 |
Found = true; |
| 790 |
break; |
| 791 |
} |
| 792 |
} |
| 793 |
|
| 794 |
if (!Found) { |
| 795 |
CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude; |
| 796 |
return false; |
| 797 |
} |
| 798 |
} |
| 799 |
} |
| 800 |
|
| 801 |
// Set up the preprocessor if needed. When parsing model files the |
| 802 |
// preprocessor of the original source is reused. |
| 803 |
if (!isModelParsingAction()) |
| 804 |
CI.createPreprocessor(getTranslationUnitKind()); |
| 805 |
|
| 806 |
// Inform the diagnostic client we are processing a source file. |
| 807 |
CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), |
| 808 |
&CI.getPreprocessor()); |
| 809 |
HasBegunSourceFile = true; |
| 810 |
|
| 811 |
// Handle C++20 header units. |
| 812 |
// Here, the user has the option to specify that the header name should be |
| 813 |
// looked up in the pre-processor search paths (and the main filename as |
| 814 |
// passed by the driver might therefore be incomplete until that look-up). |
| 815 |
if (CI.getLangOpts().CPlusPlusModules && Input.getKind().isHeaderUnit() && |
| 816 |
!Input.getKind().isPreprocessed()) { |
| 817 |
StringRef FileName = Input.getFile(); |
| 818 |
InputKind Kind = Input.getKind(); |
| 819 |
if (Kind.getHeaderUnitKind() != InputKind::HeaderUnit_Abs) { |
| 820 |
assert(CI.hasPreprocessor() && |
| 821 |
"trying to build a header unit without a Pre-processor?"); |
| 822 |
HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo(); |
| 823 |
// Relative searches begin from CWD. |
| 824 |
const DirectoryEntry *Dir = nullptr; |
| 825 |
if (auto DirOrErr = CI.getFileManager().getDirectory(".")) |
| 826 |
Dir = *DirOrErr; |
| 827 |
SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 1> CWD; |
| 828 |
CWD.push_back({nullptr, Dir}); |
| 829 |
OptionalFileEntryRef FE = |
| 830 |
HS.LookupFile(FileName, SourceLocation(), |
| 831 |
/*Angled*/ Input.getKind().getHeaderUnitKind() == |
| 832 |
InputKind::HeaderUnit_System, |
| 833 |
nullptr, nullptr, CWD, nullptr, nullptr, nullptr, |
| 834 |
nullptr, nullptr, nullptr); |
| 835 |
if (!FE) { |
| 836 |
CI.getDiagnostics().Report(diag::err_module_header_file_not_found) |
| 837 |
<< FileName; |
| 838 |
return false; |
| 839 |
} |
| 840 |
// We now have the filename... |
| 841 |
FileName = FE->getFileEntry().getName(); |
| 842 |
// ... still a header unit, but now use the path as written. |
| 843 |
Kind = Input.getKind().withHeaderUnit(InputKind::HeaderUnit_Abs); |
| 844 |
Input = FrontendInputFile(FileName, Kind, Input.isSystem()); |
| 845 |
} |
| 846 |
// Unless the user has overridden the name, the header unit module name is |
| 847 |
// the pathname for the file. |
| 848 |
if (CI.getLangOpts().ModuleName.empty()) |
| 849 |
CI.getLangOpts().ModuleName = std::string(FileName); |
| 850 |
CI.getLangOpts().CurrentModule = CI.getLangOpts().ModuleName; |
| 851 |
} |
| 852 |
|
| 853 |
if (!CI.InitializeSourceManager(Input)) |
| 854 |
return false; |
| 855 |
|
| 856 |
if (CI.getLangOpts().CPlusPlusModules && Input.getKind().isHeaderUnit() && |
| 857 |
Input.getKind().isPreprocessed() && !usesPreprocessorOnly()) { |
| 858 |
// We have an input filename like foo.iih, but we want to find the right |
| 859 |
// module name (and original file, to build the map entry). |
| 860 |
// Check if the first line specifies the original source file name with a |
| 861 |
// linemarker. |
| 862 |
std::string PresumedInputFile = std::string(getCurrentFileOrBufferName()); |
| 863 |
ReadOriginalFileName(CI, PresumedInputFile); |
| 864 |
// Unless the user overrides this, the module name is the name by which the |
| 865 |
// original file was known. |
| 866 |
if (CI.getLangOpts().ModuleName.empty()) |
| 867 |
CI.getLangOpts().ModuleName = std::string(PresumedInputFile); |
| 868 |
CI.getLangOpts().CurrentModule = CI.getLangOpts().ModuleName; |
| 869 |
} |
| 870 |
|
| 871 |
// For module map files, we first parse the module map and synthesize a |
| 872 |
// "<module-includes>" buffer before more conventional processing. |
| 873 |
if (Input.getKind().getFormat() == InputKind::ModuleMap) { |
| 874 |
CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap); |
| 875 |
|
| 876 |
std::string PresumedModuleMapFile; |
| 877 |
unsigned OffsetToContents; |
| 878 |
if (loadModuleMapForModuleBuild(CI, Input.isSystem(), |
| 879 |
Input.isPreprocessed(), |
| 880 |
PresumedModuleMapFile, OffsetToContents)) |
| 881 |
return false; |
| 882 |
|
| 883 |
auto *CurrentModule = prepareToBuildModule(CI, Input.getFile()); |
| 884 |
if (!CurrentModule) |
| 885 |
return false; |
| 886 |
|
| 887 |
CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile; |
| 888 |
|
| 889 |
if (OffsetToContents) |
| 890 |
// If the module contents are in the same file, skip to them. |
| 891 |
CI.getPreprocessor().setSkipMainFilePreamble(OffsetToContents, true); |
| 892 |
else { |
| 893 |
// Otherwise, convert the module description to a suitable input buffer. |
| 894 |
auto Buffer = getInputBufferForModule(CI, CurrentModule); |
| 895 |
if (!Buffer) |
| 896 |
return false; |
| 897 |
|
| 898 |
// Reinitialize the main file entry to refer to the new input. |
| 899 |
auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User; |
| 900 |
auto &SourceMgr = CI.getSourceManager(); |
| 901 |
auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind); |
| 902 |
assert(BufferID.isValid() && "couldn't create module buffer ID"); |
| 903 |
SourceMgr.setMainFileID(BufferID); |
| 904 |
} |
| 905 |
} |
| 906 |
|
| 907 |
// Initialize the action. |
| 908 |
if (!BeginSourceFileAction(CI)) |
| 909 |
return false; |
| 910 |
|
| 911 |
// If we were asked to load any module map files, do so now. |
| 912 |
for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) { |
| 913 |
if (auto File = CI.getFileManager().getFile(Filename)) |
| 914 |
CI.getPreprocessor().getHeaderSearchInfo().loadModuleMapFile( |
| 915 |
*File, /*IsSystem*/false); |
| 916 |
else |
| 917 |
CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename; |
| 918 |
} |
| 919 |
|
| 920 |
// If compiling implementation of a module, load its module map file now. |
| 921 |
(void)CI.getPreprocessor().getCurrentModuleImplementation(); |
| 922 |
|
| 923 |
// Add a module declaration scope so that modules from -fmodule-map-file |
| 924 |
// arguments may shadow modules found implicitly in search paths. |
| 925 |
CI.getPreprocessor() |
| 926 |
.getHeaderSearchInfo() |
| 927 |
.getModuleMap() |
| 928 |
.finishModuleDeclarationScope(); |
| 929 |
|
| 930 |
// Create the AST context and consumer unless this is a preprocessor only |
| 931 |
// action. |
| 932 |
if (!usesPreprocessorOnly()) { |
| 933 |
// Parsing a model file should reuse the existing ASTContext. |
| 934 |
if (!isModelParsingAction()) |
| 935 |
CI.createASTContext(); |
| 936 |
|
| 937 |
// For preprocessed files, check if the first line specifies the original |
| 938 |
// source file name with a linemarker. |
| 939 |
std::string PresumedInputFile = std::string(getCurrentFileOrBufferName()); |
| 940 |
if (Input.isPreprocessed()) |
| 941 |
ReadOriginalFileName(CI, PresumedInputFile); |
| 942 |
|
| 943 |
std::unique_ptr<ASTConsumer> Consumer = |
| 944 |
CreateWrappedASTConsumer(CI, PresumedInputFile); |
| 945 |
if (!Consumer) |
| 946 |
return false; |
| 947 |
|
| 948 |
// FIXME: should not overwrite ASTMutationListener when parsing model files? |
| 949 |
if (!isModelParsingAction()) |
| 950 |
CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener()); |
| 951 |
|
| 952 |
if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) { |
| 953 |
// Convert headers to PCH and chain them. |
| 954 |
IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader; |
| 955 |
source = createChainedIncludesSource(CI, FinalReader); |
| 956 |
if (!source) |
| 957 |
return false; |
| 958 |
CI.setASTReader(static_cast<ASTReader *>(FinalReader.get())); |
| 959 |
CI.getASTContext().setExternalSource(source); |
| 960 |
} else if (CI.getLangOpts().Modules || |
| 961 |
!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) { |
| 962 |
// Use PCM or PCH. |
| 963 |
assert(hasPCHSupport() && "This action does not have PCH support!"); |
| 964 |
ASTDeserializationListener *DeserialListener = |
| 965 |
Consumer->GetASTDeserializationListener(); |
| 966 |
bool DeleteDeserialListener = false; |
| 967 |
if (CI.getPreprocessorOpts().DumpDeserializedPCHDecls) { |
| 968 |
DeserialListener = new DeserializedDeclsDumper(DeserialListener, |
| 969 |
DeleteDeserialListener); |
| 970 |
DeleteDeserialListener = true; |
| 971 |
} |
| 972 |
if (!CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn.empty()) { |
| 973 |
DeserialListener = new DeserializedDeclsChecker( |
| 974 |
CI.getASTContext(), |
| 975 |
CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn, |
| 976 |
DeserialListener, DeleteDeserialListener); |
| 977 |
DeleteDeserialListener = true; |
| 978 |
} |
| 979 |
if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) { |
| 980 |
CI.createPCHExternalASTSource( |
| 981 |
CI.getPreprocessorOpts().ImplicitPCHInclude, |
| 982 |
CI.getPreprocessorOpts().DisablePCHOrModuleValidation, |
| 983 |
CI.getPreprocessorOpts().AllowPCHWithCompilerErrors, |
| 984 |
DeserialListener, DeleteDeserialListener); |
| 985 |
if (!CI.getASTContext().getExternalSource()) |
| 986 |
return false; |
| 987 |
} |
| 988 |
// If modules are enabled, create the AST reader before creating |
| 989 |
// any builtins, so that all declarations know that they might be |
| 990 |
// extended by an external source. |
| 991 |
if (CI.getLangOpts().Modules || !CI.hasASTContext() || |
| 992 |
!CI.getASTContext().getExternalSource()) { |
| 993 |
CI.createASTReader(); |
| 994 |
CI.getASTReader()->setDeserializationListener(DeserialListener, |
| 995 |
DeleteDeserialListener); |
| 996 |
} |
| 997 |
} |
| 998 |
|
| 999 |
CI.setASTConsumer(std::move(Consumer)); |
| 1000 |
if (!CI.hasASTConsumer()) |
| 1001 |
return false; |
| 1002 |
} |
| 1003 |
|
| 1004 |
// Initialize built-in info as long as we aren't using an external AST |
| 1005 |
// source. |
| 1006 |
if (CI.getLangOpts().Modules || !CI.hasASTContext() || |
| 1007 |
!CI.getASTContext().getExternalSource()) { |
| 1008 |
Preprocessor &PP = CI.getPreprocessor(); |
| 1009 |
PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(), |
| 1010 |
PP.getLangOpts()); |
| 1011 |
} else { |
| 1012 |
// FIXME: If this is a problem, recover from it by creating a multiplex |
| 1013 |
// source. |
| 1014 |
assert((!CI.getLangOpts().Modules || CI.getASTReader()) && |
| 1015 |
"modules enabled but created an external source that " |
| 1016 |
"doesn't support modules"); |
| 1017 |
} |
| 1018 |
|
| 1019 |
// If we were asked to load any module files, do so now. |
| 1020 |
for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles) |
| 1021 |
if (!CI.loadModuleFile(ModuleFile)) |
| 1022 |
return false; |
| 1023 |
|
| 1024 |
// If there is a layout overrides file, attach an external AST source that |
| 1025 |
// provides the layouts from that file. |
| 1026 |
if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() && |
| 1027 |
CI.hasASTContext() && !CI.getASTContext().getExternalSource()) { |
| 1028 |
IntrusiveRefCntPtr<ExternalASTSource> |
| 1029 |
Override(new LayoutOverrideSource( |
| 1030 |
CI.getFrontendOpts().OverrideRecordLayoutsFile)); |
| 1031 |
CI.getASTContext().setExternalSource(Override); |
| 1032 |
} |
| 1033 |
|
| 1034 |
// Setup HLSL External Sema Source |
| 1035 |
if (CI.getLangOpts().HLSL && CI.hasASTContext()) { |
| 1036 |
IntrusiveRefCntPtr<ExternalSemaSource> HLSLSema( |
| 1037 |
new HLSLExternalSemaSource()); |
| 1038 |
if (auto *SemaSource = dyn_cast_if_present<ExternalSemaSource>( |
| 1039 |
CI.getASTContext().getExternalSource())) { |
| 1040 |
IntrusiveRefCntPtr<ExternalSemaSource> MultiSema( |
| 1041 |
new MultiplexExternalSemaSource(SemaSource, HLSLSema.get())); |
| 1042 |
CI.getASTContext().setExternalSource(MultiSema); |
| 1043 |
} else |
| 1044 |
CI.getASTContext().setExternalSource(HLSLSema); |
| 1045 |
} |
| 1046 |
|
| 1047 |
FailureCleanup.release(); |
| 1048 |
return true; |
| 1049 |
} |
| 1050 |
|
| 1051 |
llvm::Error FrontendAction::Execute() { |
| 1052 |
CompilerInstance &CI = getCompilerInstance(); |
| 1053 |
|
| 1054 |
if (CI.hasFrontendTimer()) { |
| 1055 |
llvm::TimeRegion Timer(CI.getFrontendTimer()); |
| 1056 |
ExecuteAction(); |
| 1057 |
} |
| 1058 |
else ExecuteAction(); |
| 1059 |
|
| 1060 |
// If we are supposed to rebuild the global module index, do so now unless |
| 1061 |
// there were any module-build failures. |
| 1062 |
if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() && |
| 1063 |
CI.hasPreprocessor()) { |
| 1064 |
StringRef Cache = |
| 1065 |
CI.getPreprocessor().getHeaderSearchInfo().getModuleCachePath(); |
| 1066 |
if (!Cache.empty()) { |
| 1067 |
if (llvm::Error Err = GlobalModuleIndex::writeIndex( |
| 1068 |
CI.getFileManager(), CI.getPCHContainerReader(), Cache)) { |
| 1069 |
// FIXME this drops the error on the floor, but |
| 1070 |
// Index/pch-from-libclang.c seems to rely on dropping at least some of |
| 1071 |
// the error conditions! |
| 1072 |
consumeError(std::move(Err)); |
| 1073 |
} |
| 1074 |
} |
| 1075 |
} |
| 1076 |
|
| 1077 |
return llvm::Error::success(); |
| 1078 |
} |
| 1079 |
|
| 1080 |
void FrontendAction::EndSourceFile() { |
| 1081 |
CompilerInstance &CI = getCompilerInstance(); |
| 1082 |
|
| 1083 |
// Inform the diagnostic client we are done with this source file. |
| 1084 |
CI.getDiagnosticClient().EndSourceFile(); |
| 1085 |
|
| 1086 |
// Inform the preprocessor we are done. |
| 1087 |
if (CI.hasPreprocessor()) |
| 1088 |
CI.getPreprocessor().EndSourceFile(); |
| 1089 |
|
| 1090 |
// Finalize the action. |
| 1091 |
EndSourceFileAction(); |
| 1092 |
|
| 1093 |
// Sema references the ast consumer, so reset sema first. |
| 1094 |
// |
| 1095 |
// FIXME: There is more per-file stuff we could just drop here? |
| 1096 |
bool DisableFree = CI.getFrontendOpts().DisableFree; |
| 1097 |
if (DisableFree) { |
| 1098 |
CI.resetAndLeakSema(); |
| 1099 |
CI.resetAndLeakASTContext(); |
| 1100 |
llvm::BuryPointer(CI.takeASTConsumer().get()); |
| 1101 |
} else { |
| 1102 |
CI.setSema(nullptr); |
| 1103 |
CI.setASTContext(nullptr); |
| 1104 |
CI.setASTConsumer(nullptr); |
| 1105 |
} |
| 1106 |
|
| 1107 |
if (CI.getFrontendOpts().ShowStats) { |
| 1108 |
llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFileOrBufferName() << "':\n"; |
| 1109 |
CI.getPreprocessor().PrintStats(); |
| 1110 |
CI.getPreprocessor().getIdentifierTable().PrintStats(); |
| 1111 |
CI.getPreprocessor().getHeaderSearchInfo().PrintStats(); |
| 1112 |
CI.getSourceManager().PrintStats(); |
| 1113 |
llvm::errs() << "\n"; |
| 1114 |
} |
| 1115 |
|
| 1116 |
// Cleanup the output streams, and erase the output files if instructed by the |
| 1117 |
// FrontendAction. |
| 1118 |
CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles()); |
| 1119 |
|
| 1120 |
if (isCurrentFileAST()) { |
| 1121 |
if (DisableFree) { |
| 1122 |
CI.resetAndLeakPreprocessor(); |
| 1123 |
CI.resetAndLeakSourceManager(); |
| 1124 |
CI.resetAndLeakFileManager(); |
| 1125 |
llvm::BuryPointer(std::move(CurrentASTUnit)); |
| 1126 |
} else { |
| 1127 |
CI.setPreprocessor(nullptr); |
| 1128 |
CI.setSourceManager(nullptr); |
| 1129 |
CI.setFileManager(nullptr); |
| 1130 |
} |
| 1131 |
} |
| 1132 |
|
| 1133 |
setCompilerInstance(nullptr); |
| 1134 |
setCurrentInput(FrontendInputFile()); |
| 1135 |
CI.getLangOpts().setCompilingModule(LangOptions::CMK_None); |
| 1136 |
} |
| 1137 |
|
| 1138 |
bool FrontendAction::shouldEraseOutputFiles() { |
| 1139 |
return getCompilerInstance().getDiagnostics().hasErrorOccurred(); |
| 1140 |
} |
| 1141 |
|
| 1142 |
//===----------------------------------------------------------------------===// |
| 1143 |
// Utility Actions |
| 1144 |
//===----------------------------------------------------------------------===// |
| 1145 |
|
| 1146 |
void ASTFrontendAction::ExecuteAction() { |
| 1147 |
CompilerInstance &CI = getCompilerInstance(); |
| 1148 |
if (!CI.hasPreprocessor()) |
| 1149 |
return; |
| 1150 |
|
| 1151 |
// FIXME: Move the truncation aspect of this into Sema, we delayed this till |
| 1152 |
// here so the source manager would be initialized. |
| 1153 |
if (hasCodeCompletionSupport() && |
| 1154 |
!CI.getFrontendOpts().CodeCompletionAt.FileName.empty()) |
| 1155 |
CI.createCodeCompletionConsumer(); |
| 1156 |
|
| 1157 |
// Use a code completion consumer? |
| 1158 |
CodeCompleteConsumer *CompletionConsumer = nullptr; |
| 1159 |
if (CI.hasCodeCompletionConsumer()) |
| 1160 |
CompletionConsumer = &CI.getCodeCompletionConsumer(); |
| 1161 |
|
| 1162 |
if (!CI.hasSema()) |
| 1163 |
CI.createSema(getTranslationUnitKind(), CompletionConsumer); |
| 1164 |
|
| 1165 |
ParseAST(CI.getSema(), CI.getFrontendOpts().ShowStats, |
| 1166 |
CI.getFrontendOpts().SkipFunctionBodies); |
| 1167 |
} |
| 1168 |
|
| 1169 |
void PluginASTAction::anchor() { } |
| 1170 |
|
| 1171 |
std::unique_ptr<ASTConsumer> |
| 1172 |
PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI, |
| 1173 |
StringRef InFile) { |
| 1174 |
llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!"); |
| 1175 |
} |
| 1176 |
|
| 1177 |
bool WrapperFrontendAction::PrepareToExecuteAction(CompilerInstance &CI) { |
| 1178 |
return WrappedAction->PrepareToExecuteAction(CI); |
| 1179 |
} |
| 1180 |
std::unique_ptr<ASTConsumer> |
| 1181 |
WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI, |
| 1182 |
StringRef InFile) { |
| 1183 |
return WrappedAction->CreateASTConsumer(CI, InFile); |
| 1184 |
} |
| 1185 |
bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) { |
| 1186 |
return WrappedAction->BeginInvocation(CI); |
| 1187 |
} |
| 1188 |
bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI) { |
| 1189 |
WrappedAction->setCurrentInput(getCurrentInput()); |
| 1190 |
WrappedAction->setCompilerInstance(&CI); |
| 1191 |
auto Ret = WrappedAction->BeginSourceFileAction(CI); |
| 1192 |
// BeginSourceFileAction may change CurrentInput, e.g. during module builds. |
| 1193 |
setCurrentInput(WrappedAction->getCurrentInput()); |
| 1194 |
return Ret; |
| 1195 |
} |
| 1196 |
void WrapperFrontendAction::ExecuteAction() { |
| 1197 |
WrappedAction->ExecuteAction(); |
| 1198 |
} |
| 1199 |
void WrapperFrontendAction::EndSourceFile() { WrappedAction->EndSourceFile(); } |
| 1200 |
void WrapperFrontendAction::EndSourceFileAction() { |
| 1201 |
WrappedAction->EndSourceFileAction(); |
| 1202 |
} |
| 1203 |
bool WrapperFrontendAction::shouldEraseOutputFiles() { |
| 1204 |
return WrappedAction->shouldEraseOutputFiles(); |
| 1205 |
} |
| 1206 |
|
| 1207 |
bool WrapperFrontendAction::usesPreprocessorOnly() const { |
| 1208 |
return WrappedAction->usesPreprocessorOnly(); |
| 1209 |
} |
| 1210 |
TranslationUnitKind WrapperFrontendAction::getTranslationUnitKind() { |
| 1211 |
return WrappedAction->getTranslationUnitKind(); |
| 1212 |
} |
| 1213 |
bool WrapperFrontendAction::hasPCHSupport() const { |
| 1214 |
return WrappedAction->hasPCHSupport(); |
| 1215 |
} |
| 1216 |
bool WrapperFrontendAction::hasASTFileSupport() const { |
| 1217 |
return WrappedAction->hasASTFileSupport(); |
| 1218 |
} |
| 1219 |
bool WrapperFrontendAction::hasIRSupport() const { |
| 1220 |
return WrappedAction->hasIRSupport(); |
| 1221 |
} |
| 1222 |
bool WrapperFrontendAction::hasCodeCompletionSupport() const { |
| 1223 |
return WrappedAction->hasCodeCompletionSupport(); |
| 1224 |
} |
| 1225 |
|
| 1226 |
WrapperFrontendAction::WrapperFrontendAction( |
| 1227 |
std::unique_ptr<FrontendAction> WrappedAction) |
| 1228 |
: WrappedAction(std::move(WrappedAction)) {} |