clang/lib/Frontend/FrontendAction.cpp

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