head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.31; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.19; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.07; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.44; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.27; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.53; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.34.47; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.34.54; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.09; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.23; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.44; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.27; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.28; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.38; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.11.2.1 date 2018.07.28.04.33.19; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.23; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.34; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CompilerInstance.cpp ---------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/Frontend/CompilerInstance.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/Version.h" #include "clang/Frontend/ChainedDiagnosticConsumer.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/LogDiagnosticPrinter.h" #include "clang/Frontend/SerializedDiagnosticPrinter.h" #include "clang/Frontend/TextDiagnosticPrinter.h" #include "clang/Frontend/Utils.h" #include "clang/Frontend/VerifyDiagnosticConsumer.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/PTHManager.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "llvm/ADT/Statistic.h" #include "llvm/Config/config.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Host.h" #include "llvm/Support/LockFileManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/Program.h" #include "llvm/Support/Signals.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #include #include using namespace clang; CompilerInstance::CompilerInstance() : Invocation(new CompilerInvocation()), ModuleManager(0), BuildGlobalModuleIndex(false), ModuleBuildFailed(false) { } CompilerInstance::~CompilerInstance() { assert(OutputFiles.empty() && "Still output files in flight?"); } void CompilerInstance::setInvocation(CompilerInvocation *Value) { Invocation = Value; } bool CompilerInstance::shouldBuildGlobalModuleIndex() const { return (BuildGlobalModuleIndex || (ModuleManager && ModuleManager->isGlobalIndexUnavailable() && getFrontendOpts().GenerateGlobalModuleIndex)) && !ModuleBuildFailed; } void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { Diagnostics = Value; } void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; } void CompilerInstance::setFileManager(FileManager *Value) { FileMgr = Value; } void CompilerInstance::setSourceManager(SourceManager *Value) { SourceMgr = Value; } void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } void CompilerInstance::setSema(Sema *S) { TheSema.reset(S); } void CompilerInstance::setASTConsumer(ASTConsumer *Value) { Consumer.reset(Value); } void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { CompletionConsumer.reset(Value); } // Diagnostics static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags) { std::string ErrorInfo; bool OwnsStream = false; raw_ostream *OS = &llvm::errs(); if (DiagOpts->DiagnosticLogFile != "-") { // Create the output stream. llvm::raw_fd_ostream *FileOS( new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo, llvm::sys::fs::F_Append)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) << DiagOpts->DiagnosticLogFile << ErrorInfo; } else { FileOS->SetUnbuffered(); FileOS->SetUseAtomicWrites(true); OS = FileOS; OwnsStream = true; } } // Chain in the diagnostic client which will log the diagnostics. LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, OwnsStream); if (CodeGenOpts) Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); } static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile) { std::string ErrorInfo; OwningPtr OS; OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_Binary)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_serialized_diag_failure) << OutputFile << ErrorInfo; return; } DiagnosticConsumer *SerializedConsumer = clang::serialized_diags::create(OS.take(), DiagOpts); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), SerializedConsumer)); } void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, bool ShouldOwnClient) { Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient, &getCodeGenOpts()); } IntrusiveRefCntPtr CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient, const CodeGenOptions *CodeGenOpts) { IntrusiveRefCntPtr DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr Diags(new DiagnosticsEngine(DiagID, Opts)); // Create the diagnostic client for reporting errors or for // implementing -verify. if (Client) { Diags->setClient(Client, ShouldOwnClient); } else Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); // Chain in -verify checker, if requested. if (Opts->VerifyDiagnostics) Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); // Chain in -diagnostic-log-file dumper, if requested. if (!Opts->DiagnosticLogFile.empty()) SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); if (!Opts->DiagnosticSerializationFile.empty()) SetupSerializedDiagnostics(Opts, *Diags, Opts->DiagnosticSerializationFile); // Configure our handling of diagnostics. ProcessWarningOptions(*Diags, *Opts); return Diags; } // File Manager void CompilerInstance::createFileManager() { FileMgr = new FileManager(getFileSystemOpts()); } // Source Manager void CompilerInstance::createSourceManager(FileManager &FileMgr) { SourceMgr = new SourceManager(getDiagnostics(), FileMgr); } // Preprocessor void CompilerInstance::createPreprocessor() { const PreprocessorOptions &PPOpts = getPreprocessorOpts(); // Create a PTH manager if we are using some form of a token cache. PTHManager *PTHMgr = 0; if (!PPOpts.TokenCache.empty()) PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); // Create the Preprocessor. HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(), getSourceManager(), getDiagnostics(), getLangOpts(), &getTarget()); PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(), &getTarget(), getSourceManager(), *HeaderInfo, *this, PTHMgr, /*OwnsHeaderSearch=*/true); // Note that this is different then passing PTHMgr to Preprocessor's ctor. // That argument is used as the IdentifierInfoLookup argument to // IdentifierTable's ctor. if (PTHMgr) { PTHMgr->setPreprocessor(&*PP); PP->setPTHManager(PTHMgr); } if (PPOpts.DetailedRecord) PP->createPreprocessingRecord(); InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts()); PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP); // Set up the module path, including the hash for the // module-creation options. SmallString<256> SpecificModuleCache( getHeaderSearchOpts().ModuleCachePath); if (!getHeaderSearchOpts().DisableModuleHash) llvm::sys::path::append(SpecificModuleCache, getInvocation().getModuleHash()); PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache); // Handle generating dependencies, if requested. const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); if (!DepOpts.OutputFile.empty()) AttachDependencyFileGen(*PP, DepOpts); if (!DepOpts.DOTOutputFile.empty()) AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, getHeaderSearchOpts().Sysroot); // Handle generating header include information, if requested. if (DepOpts.ShowHeaderIncludes) AttachHeaderIncludeGen(*PP); if (!DepOpts.HeaderIncludeOutputFile.empty()) { StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; if (OutputPath == "-") OutputPath = ""; AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, /*ShowDepth=*/false); } if (DepOpts.PrintShowIncludes) { AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"", /*ShowDepth=*/true, /*MSStyle=*/true); } } // ASTContext void CompilerInstance::createASTContext() { Preprocessor &PP = getPreprocessor(); Context = new ASTContext(getLangOpts(), PP.getSourceManager(), &getTarget(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo(), /*size_reserve=*/ 0); } // ExternalASTSource void CompilerInstance::createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener){ OwningPtr Source; bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), DeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex)); ModuleManager = static_cast(Source.get()); getASTContext().setExternalSource(Source); } ExternalASTSource * CompilerInstance::createPCHExternalASTSource(StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, void *DeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { OwningPtr Reader; Reader.reset(new ASTReader(PP, Context, Sysroot.empty() ? "" : Sysroot.c_str(), DisablePCHValidation, AllowPCHWithCompilerErrors, UseGlobalModuleIndex)); Reader->setDeserializationListener( static_cast(DeserializationListener)); switch (Reader->ReadAST(Path, Preamble ? serialization::MK_Preamble : serialization::MK_PCH, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: // Set the predefines buffer as suggested by the PCH reader. Typically, the // predefines buffer will be empty. PP.setPredefines(Reader->getSuggestedPredefines()); return Reader.take(); case ASTReader::Failure: // Unrecoverable failure: don't even try to process the input file. break; case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: // No suitable PCH file could be found. Return an error. break; } return 0; } // Code Completion static bool EnableCodeCompletion(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column) { // Tell the source manager to chop off the given file at a specific // line and column. const FileEntry *Entry = PP.getFileManager().getFile(Filename); if (!Entry) { PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) << Filename; return true; } // Truncate the named file at the given line/column. PP.SetCodeCompletionPoint(Entry, Line, Column); return false; } void CompilerInstance::createCodeCompletionConsumer() { const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; if (!CompletionConsumer) { setCodeCompletionConsumer( createCodeCompletionConsumer(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column, getFrontendOpts().CodeCompleteOpts, llvm::outs())); if (!CompletionConsumer) return; } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column)) { setCodeCompletionConsumer(0); return; } if (CompletionConsumer->isOutputBinary() && llvm::sys::ChangeStdoutToBinary()) { getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); setCodeCompletionConsumer(0); } } void CompilerInstance::createFrontendTimer() { FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); } CodeCompleteConsumer * CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column, const CodeCompleteOptions &Opts, raw_ostream &OS) { if (EnableCodeCompletion(PP, Filename, Line, Column)) return 0; // Set up the creation routine for code-completion. return new PrintingCodeCompleteConsumer(Opts, OS); } void CompilerInstance::createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer) { TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), TUKind, CompletionConsumer)); } // Output Files void CompilerInstance::addOutputFile(const OutputFile &OutFile) { assert(OutFile.OS && "Attempt to add empty stream to output list!"); OutputFiles.push_back(OutFile); } void CompilerInstance::clearOutputFiles(bool EraseFiles) { for (std::list::iterator it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { delete it->OS; if (!it->TempFilename.empty()) { if (EraseFiles) { bool existed; llvm::sys::fs::remove(it->TempFilename, existed); } else { SmallString<128> NewOutFile(it->Filename); // If '-working-directory' was passed, the output filename should be // relative to that. FileMgr->FixupRelativePath(NewOutFile); if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) { getDiagnostics().Report(diag::err_unable_to_rename_temp) << it->TempFilename << it->Filename << ec.message(); bool existed; llvm::sys::fs::remove(it->TempFilename, existed); } } } else if (!it->Filename.empty() && EraseFiles) llvm::sys::fs::remove(it->Filename); } OutputFiles.clear(); } llvm::raw_fd_ostream * CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile, StringRef Extension) { return createOutputFile(getFrontendOpts().OutputFile, Binary, /*RemoveFileOnSignal=*/true, InFile, Extension, /*UseTemporary=*/true); } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories) { std::string Error, OutputPathName, TempPathName; llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, RemoveFileOnSignal, InFile, Extension, UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName); if (!OS) { getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath << Error; return 0; } // Add the output file -- but don't try to remove "-", since this means we are // using stdin. addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName, OS)); return OS; } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, std::string &Error, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories, std::string *ResultPathName, std::string *TempPathName) { assert((!CreateMissingDirectories || UseTemporary) && "CreateMissingDirectories is only allowed when using temporary files"); std::string OutFile, TempFile; if (!OutputPath.empty()) { OutFile = OutputPath; } else if (InFile == "-") { OutFile = "-"; } else if (!Extension.empty()) { SmallString<128> Path(InFile); llvm::sys::path::replace_extension(Path, Extension); OutFile = Path.str(); } else { OutFile = "-"; } OwningPtr OS; std::string OSFile; if (UseTemporary) { if (OutFile == "-") UseTemporary = false; else { llvm::sys::fs::file_status Status; llvm::sys::fs::status(OutputPath, Status); if (llvm::sys::fs::exists(Status)) { // Fail early if we can't write to the final destination. if (!llvm::sys::fs::can_write(OutputPath)) return 0; // Don't use a temporary if the output is a special file. This handles // things like '-o /dev/null' if (!llvm::sys::fs::is_regular_file(Status)) UseTemporary = false; } } } if (UseTemporary) { // Create a temporary file. SmallString<128> TempPath; TempPath = OutFile; TempPath += "-%%%%%%%%"; int fd; llvm::error_code EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); if (CreateMissingDirectories && EC == llvm::errc::no_such_file_or_directory) { StringRef Parent = llvm::sys::path::parent_path(OutputPath); EC = llvm::sys::fs::create_directories(Parent); if (!EC) { EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); } } if (!EC) { OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); OSFile = TempFile = TempPath.str(); } // If we failed to create the temporary, fallback to writing to the file // directly. This handles the corner case where we cannot write to the // directory, but can write to the file. } if (!OS) { OSFile = OutFile; OS.reset(new llvm::raw_fd_ostream( OSFile.c_str(), Error, (Binary ? llvm::sys::fs::F_Binary : llvm::sys::fs::F_None))); if (!Error.empty()) return 0; } // Make sure the out stream file gets removed if we crash. if (RemoveFileOnSignal) llvm::sys::RemoveFileOnSignal(OSFile); if (ResultPathName) *ResultPathName = OutFile; if (TempPathName) *TempPathName = TempFile; return OS.take(); } // Initialization Utilities bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ return InitializeSourceManager(Input, getDiagnostics(), getFileManager(), getSourceManager(), getFrontendOpts()); } bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, DiagnosticsEngine &Diags, FileManager &FileMgr, SourceManager &SourceMgr, const FrontendOptions &Opts) { SrcMgr::CharacteristicKind Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; if (Input.isBuffer()) { SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind); assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } StringRef InputFile = Input.getFile(); // Figure out where to get and map in the main file. if (InputFile != "-") { const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); if (!File) { Diags.Report(diag::err_fe_error_reading) << InputFile; return false; } // The natural SourceManager infrastructure can't currently handle named // pipes, but we would at least like to accept them for the main // file. Detect them here, read them with the volatile flag so FileMgr will // pick up the correct size, and simply override their contents as we do for // STDIN. if (File->isNamedPipe()) { std::string ErrorStr; if (llvm::MemoryBuffer *MB = FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) { // Create a new virtual file that will have the correct size. File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0); SourceMgr.overrideFileContents(File, MB); } else { Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr; return false; } } SourceMgr.createMainFileID(File, Kind); } else { OwningPtr SB; if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) { Diags.Report(diag::err_fe_error_reading_stdin) << ec.message(); return false; } const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), SB->getBufferSize(), 0); SourceMgr.createMainFileID(File, Kind); SourceMgr.overrideFileContents(File, SB.take()); } assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } // High-Level Operations bool CompilerInstance::ExecuteAction(FrontendAction &Act) { assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); // FIXME: Take this as an argument, once all the APIs we used have moved to // taking it as an input instead of hard-coding llvm::errs. raw_ostream &OS = llvm::errs(); // Create the target instance. setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts())); if (!hasTarget()) return false; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. getTarget().setForcedLangOptions(getLangOpts()); // rewriter project will change target built-in bool type from its default. if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) getTarget().noSignedCharForObjCBool(); // Validate/process some options. if (getHeaderSearchOpts().Verbose) OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon " << PACKAGE_STRING << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; if (getFrontendOpts().ShowTimers) createFrontendTimer(); if (getFrontendOpts().ShowStats) llvm::EnableStatistics(); for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { // Reset the ID tables if we are reusing the SourceManager. if (hasSourceManager()) getSourceManager().clearIDTables(); if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { Act.Execute(); Act.EndSourceFile(); } } // Notify the diagnostic client that all files were processed. getDiagnostics().getClient()->finish(); if (getDiagnosticOpts().ShowCarets) { // We can have multiple diagnostics sharing one diagnostic client. // Get the total number of warnings/errors from the client. unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); if (NumWarnings) OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); if (NumWarnings && NumErrors) OS << " and "; if (NumErrors) OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); if (NumWarnings || NumErrors) OS << " generated.\n"; } if (getFrontendOpts().ShowStats && hasFileManager()) { getFileManager().PrintStats(); OS << "\n"; } return !getDiagnostics().getClient()->getNumErrors(); } /// \brief Determine the appropriate source input kind based on language /// options. static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { if (LangOpts.OpenCL) return IK_OpenCL; if (LangOpts.CUDA) return IK_CUDA; if (LangOpts.ObjC1) return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; return LangOpts.CPlusPlus? IK_CXX : IK_C; } namespace { struct CompileModuleMapData { CompilerInstance &Instance; GenerateModuleAction &CreateModuleAction; }; } /// \brief Helper function that executes the module-generating action under /// a crash recovery context. static void doCompileMapModule(void *UserData) { CompileModuleMapData &Data = *reinterpret_cast(UserData); Data.Instance.ExecuteAction(Data.CreateModuleAction); } namespace { /// \brief Function object that checks with the given macro definition should /// be removed, because it is one of the ignored macros. class RemoveIgnoredMacro { const HeaderSearchOptions &HSOpts; public: explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts) : HSOpts(HSOpts) { } bool operator()(const std::pair &def) const { StringRef MacroDef = def.first; return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; } }; } /// \brief Compile a module file for the given module, using the options /// provided by the importing compiler instance. static void compileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { // FIXME: have LockFileManager return an error_code so that we can // avoid the mkdir when the directory already exists. StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); llvm::sys::fs::create_directories(Dir); llvm::LockFileManager Locked(ModuleFileName); switch (Locked) { case llvm::LockFileManager::LFS_Error: return; case llvm::LockFileManager::LFS_Owned: // We're responsible for building the module ourselves. Do so below. break; case llvm::LockFileManager::LFS_Shared: // Someone else is responsible for building the module. Wait for them to // finish. Locked.waitForUnlock(); return; } ModuleMap &ModMap = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); // Construct a compiler invocation for creating this module. IntrusiveRefCntPtr Invocation (new CompilerInvocation(ImportingInstance.getInvocation())); PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); // For any options that aren't intended to affect how a module is built, // reset them to their default values. Invocation->getLangOpts()->resetNonModularOptions(); PPOpts.resetNonModularOptions(); // Remove any macro definitions that are explicitly ignored by the module. // They aren't supposed to affect how the module is built anyway. const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), RemoveIgnoredMacro(HSOpts)), PPOpts.Macros.end()); // Note the name of the module we're building. Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); // Make sure that the failed-module structure has been allocated in // the importing instance, and propagate the pointer to the newly-created // instance. PreprocessorOptions &ImportingPPOpts = ImportingInstance.getInvocation().getPreprocessorOpts(); if (!ImportingPPOpts.FailedModules) ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet; PPOpts.FailedModules = ImportingPPOpts.FailedModules; // If there is a module map file, build the module using the module map. // Set up the inputs/outputs so that we build the module from its umbrella // header. FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); FrontendOpts.OutputFile = ModuleFileName.str(); FrontendOpts.DisableFree = false; FrontendOpts.GenerateGlobalModuleIndex = false; FrontendOpts.Inputs.clear(); InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); // Don't free the remapped file buffers; they are owned by our caller. PPOpts.RetainRemappedFileBuffers = true; Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; assert(ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"); // Construct a compiler instance that will be used to actually create the // module. CompilerInstance Instance; Instance.setInvocation(&*Invocation); Instance.createDiagnostics(new ForwardingDiagnosticConsumer( ImportingInstance.getDiagnosticClient()), /*ShouldOwnClient=*/true); // Note that this module is part of the module build stack, so that we // can detect cycles in the module graph. Instance.createFileManager(); // FIXME: Adopt file manager from importer? Instance.createSourceManager(Instance.getFileManager()); SourceManager &SourceMgr = Instance.getSourceManager(); SourceMgr.setModuleBuildStack( ImportingInstance.getSourceManager().getModuleBuildStack()); SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(), FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); // Get or create the module map that we'll use to build this module. std::string InferredModuleMapContent; if (const FileEntry *ModuleMapFile = ModMap.getContainingModuleMapFile(Module)) { // Use the module map where this module resides. FrontendOpts.Inputs.push_back( FrontendInputFile(ModuleMapFile->getName(), IK)); } else { llvm::raw_string_ostream OS(InferredModuleMapContent); Module->print(OS); OS.flush(); FrontendOpts.Inputs.push_back( FrontendInputFile("__inferred_module.map", IK)); const llvm::MemoryBuffer *ModuleMapBuffer = llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); ModuleMapFile = Instance.getFileManager().getVirtualFile( "__inferred_module.map", InferredModuleMapContent.size(), 0); SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer); } // Construct a module-generating action. GenerateModuleAction CreateModuleAction(Module->IsSystem); // Execute the action to actually build the module in-place. Use a separate // thread so that we get a stack large enough. const unsigned ThreadStackSize = 8 << 20; llvm::CrashRecoveryContext CRC; CompileModuleMapData Data = { Instance, CreateModuleAction }; CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize); // Delete the temporary module map file. // FIXME: Even though we're executing under crash protection, it would still // be nice to do this with RemoveFileOnSignal when we can. However, that // doesn't make sense for all clients, so clean this up manually. Instance.clearOutputFiles(/*EraseFiles=*/true); // We've rebuilt a module. If we're allowed to generate or update the global // module index, record that fact in the importing compiler instance. if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { ImportingInstance.setBuildGlobalModuleIndex(true); } } /// \brief Diagnose differences between the current definition of the given /// configuration macro and the definition provided on the command line. static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc) { IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro); SourceManager &SourceMgr = PP.getSourceManager(); // If this identifier has never had a macro definition, then it could // not have changed. if (!Id->hadMacroDefinition()) return; // If this identifier does not currently have a macro definition, // check whether it had one on the command line. if (!Id->hasMacroDefinition()) { MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; // This macro was defined on the command line, then #undef'd later. // Complain. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << true << ConfigMacro << Mod->getFullModuleName(); if (LatestDef.isUndefined()) PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) << true; return; } // Okay: no definition in the predefines buffer. return; } // This identifier has a macro definition. Check whether we had a definition // on the command line. MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); MacroDirective::DefInfo PredefinedDef; for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; PredefinedDef = Def; break; } // If there was no definition for this macro in the predefines buffer, // complain. if (!PredefinedDef || (!PredefinedDef.getLocation().isValid() && PredefinedDef.getUndefLocation().isValid())) { PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; return; } // If the current macro definition is the same as the predefined macro // definition, it's okay. if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() || LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP, /*Syntactically=*/true)) return; // The macro definitions differ. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; } /// \brief Write a new timestamp file with the given path. static void writeTimestampFile(StringRef TimestampFile) { std::string ErrorInfo; llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_Binary); } /// \brief Prune the module cache of modules that haven't been accessed in /// a long time. static void pruneModuleCache(const HeaderSearchOptions &HSOpts) { struct stat StatBuf; llvm::SmallString<128> TimestampFile; TimestampFile = HSOpts.ModuleCachePath; llvm::sys::path::append(TimestampFile, "modules.timestamp"); // Try to stat() the timestamp file. if (::stat(TimestampFile.c_str(), &StatBuf)) { // If the timestamp file wasn't there, create one now. if (errno == ENOENT) { writeTimestampFile(TimestampFile); } return; } // Check whether the time stamp is older than our pruning interval. // If not, do nothing. time_t TimeStampModTime = StatBuf.st_mtime; time_t CurrentTime = time(0); if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval)) return; // Write a new timestamp file so that nobody else attempts to prune. // There is a benign race condition here, if two Clang instances happen to // notice at the same time that the timestamp is out-of-date. writeTimestampFile(TimestampFile); // Walk the entire module cache, looking for unused module files and module // indices. llvm::error_code EC; SmallString<128> ModuleCachePathNative; llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative); for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative.str(), EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // If we don't have a directory, there's nothing to look into. if (!llvm::sys::fs::is_directory(Dir->path())) continue; // Walk all of the files within this directory. bool RemovedAllFiles = true; for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd; File != FileEnd && !EC; File.increment(EC)) { // We only care about module and global module index files. if (llvm::sys::path::extension(File->path()) != ".pcm" && llvm::sys::path::filename(File->path()) != "modules.idx") { RemovedAllFiles = false; continue; } // Look at this file. If we can't stat it, there's nothing interesting // there. if (::stat(File->path().c_str(), &StatBuf)) { RemovedAllFiles = false; continue; } // If the file has been used recently enough, leave it there. time_t FileAccessTime = StatBuf.st_atime; if (CurrentTime - FileAccessTime <= time_t(HSOpts.ModuleCachePruneAfter)) { RemovedAllFiles = false; continue; } // Remove the file. bool Existed; if (llvm::sys::fs::remove(File->path(), Existed) || !Existed) { RemovedAllFiles = false; } } // If we removed all of the files in the directory, remove the directory // itself. if (RemovedAllFiles) { bool Existed; llvm::sys::fs::remove(Dir->path(), Existed); } } } ModuleLoadResult CompilerInstance::loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) { // Determine what file we're searching from. StringRef ModuleName = Path[0].first->getName(); SourceLocation ModuleNameLoc = Path[0].second; // If we've already handled this import, just return the cached result. // This one-element cache is important to eliminate redundant diagnostics // when both the preprocessor and parser see the same import declaration. if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { // Make the named module visible. if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility, ImportLoc, /*Complain=*/false); return LastModuleImportResult; } clang::Module *Module = 0; // If we don't already have information on this module, load the module now. llvm::DenseMap::iterator Known = KnownModules.find(Path[0].first); if (Known != KnownModules.end()) { // Retrieve the cached top-level module. Module = Known->second; } else if (ModuleName == getLangOpts().CurrentModule) { // This is the module we're building. Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName); Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } else { // Search for a module with the given name. Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); std::string ModuleFileName; if (Module) { ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); } else ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName); // If we don't already have an ASTReader, create one now. if (!ModuleManager) { if (!hasASTContext()) createASTContext(); // If we're not recursively building a module, check whether we // need to prune the module cache. if (getSourceManager().getModuleBuildStack().empty() && getHeaderSearchOpts().ModuleCachePruneInterval > 0 && getHeaderSearchOpts().ModuleCachePruneAfter > 0) { pruneModuleCache(getHeaderSearchOpts()); } std::string Sysroot = getHeaderSearchOpts().Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); ModuleManager = new ASTReader(getPreprocessor(), *Context, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); getASTContext().setASTMutationListener( getASTConsumer().GetASTMutationListener()); } OwningPtr Source; Source.reset(ModuleManager); getASTContext().setExternalSource(Source); if (hasSema()) ModuleManager->InitializeSema(getSema()); if (hasASTConsumer()) ModuleManager->StartTranslationUnit(&getASTConsumer()); } // Try to load the module file. unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, ImportLoc, ARRFlags)) { case ASTReader::Success: break; case ASTReader::OutOfDate: case ASTReader::Missing: { // The module file is missing or out-of-date. Build it. // If we don't have a module, we don't know how to build the module file. // Complain and return. if (!Module) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } // Check whether there is a cycle in the module graph. ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack(); ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end(); for (; Pos != PosEnd; ++Pos) { if (Pos->first == ModuleName) break; } if (Pos != PosEnd) { SmallString<256> CyclePath; for (; Pos != PosEnd; ++Pos) { CyclePath += Pos->first; CyclePath += " -> "; } CyclePath += ModuleName; getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) << ModuleName << CyclePath; return ModuleLoadResult(); } // Check whether we have already attempted to build this module (but // failed). if (getPreprocessorOpts().FailedModules && getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } // Try to compile the module. compileModule(*this, ModuleNameLoc, Module, ModuleFileName); // Try to read the module file, now that we've compiled it. ASTReader::ASTReadResult ReadResult = ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, ImportLoc, ASTReader::ARR_Missing); if (ReadResult != ASTReader::Success) { if (ReadResult == ASTReader::Missing) { getDiagnostics().Report(ModuleNameLoc, Module? diag::err_module_not_built : diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); } if (getPreprocessorOpts().FailedModules) getPreprocessorOpts().FailedModules->addFailed(ModuleName); KnownModules[Path[0].first] = 0; ModuleBuildFailed = true; return ModuleLoadResult(); } // Okay, we've rebuilt and now loaded the module. break; } case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: ModuleLoader::HadFatalFailure = true; // FIXME: The ASTReader will already have complained, but can we showhorn // that diagnostic information into a more useful form? KnownModules[Path[0].first] = 0; return ModuleLoadResult(); case ASTReader::Failure: ModuleLoader::HadFatalFailure = true; // Already complained, but note now that we failed. KnownModules[Path[0].first] = 0; ModuleBuildFailed = true; return ModuleLoadResult(); } if (!Module) { // If we loaded the module directly, without finding a module map first, // we'll have loaded the module's information from the module itself. Module = PP->getHeaderSearchInfo().getModuleMap() .findModule((Path[0].first->getName())); } // Cache the result of this top-level module lookup for later. Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } // If we never found the module, fail. if (!Module) return ModuleLoadResult(); // Verify that the rest of the module path actually corresponds to // a submodule. if (Path.size() > 1) { for (unsigned I = 1, N = Path.size(); I != N; ++I) { StringRef Name = Path[I].first->getName(); clang::Module *Sub = Module->findSubmodule(Name); if (!Sub) { // Attempt to perform typo correction to find a module name that works. SmallVector Best; unsigned BestEditDistance = (std::numeric_limits::max)(); for (clang::Module::submodule_iterator J = Module->submodule_begin(), JEnd = Module->submodule_end(); J != JEnd; ++J) { unsigned ED = Name.edit_distance((*J)->Name, /*AllowReplacements=*/true, BestEditDistance); if (ED <= BestEditDistance) { if (ED < BestEditDistance) { Best.clear(); BestEditDistance = ED; } Best.push_back((*J)->Name); } } // If there was a clear winner, user it. if (Best.size() == 1) { getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest) << Path[I].first << Module->getFullModuleName() << Best[0] << SourceRange(Path[0].second, Path[I-1].second) << FixItHint::CreateReplacement(SourceRange(Path[I].second), Best[0]); Sub = Module->findSubmodule(Best[0]); } } if (!Sub) { // No submodule by this name. Complain, and don't look for further // submodules. getDiagnostics().Report(Path[I].second, diag::err_no_submodule) << Path[I].first << Module->getFullModuleName() << SourceRange(Path[0].second, Path[I-1].second); break; } Module = Sub; } } // Make the named module visible, if it's not already part of the module // we are parsing. if (ModuleName != getLangOpts().CurrentModule) { if (!Module->IsFromModuleFile) { // We have an umbrella header or directory that doesn't actually include // all of the headers within the directory it covers. Complain about // this missing submodule and recover by forgetting that we ever saw // this submodule. // FIXME: Should we detect this at module load time? It seems fairly // expensive (and rare). getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) << Module->getFullModuleName() << SourceRange(Path.front().second, Path.back().second); return ModuleLoadResult(0, true); } // Check whether this module is available. clang::Module::Requirement Requirement; if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement)) { getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) << Module->getFullModuleName() << Requirement.second << Requirement.first << SourceRange(Path.front().second, Path.back().second); LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(); return ModuleLoadResult(); } ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc, /*Complain=*/true); } // Check for any configuration macros that have changed. clang::Module *TopModule = Module->getTopLevelModule(); for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) { checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I], Module, ImportLoc); } // If this module import was due to an inclusion directive, create an // implicit import declaration to capture it in the AST. if (IsInclusionDirective && hasASTContext()) { TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, ImportLoc, Module, Path.back().second); TU->addDecl(ImportD); if (Consumer) Consumer->HandleImplicitImportDecl(ImportD); } LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(Module, false); return LastModuleImportResult; } void CompilerInstance::makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc, bool Complain){ ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d1363 5 a1367 13 clang::Module::HeaderDirective MissingHeader; if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement, MissingHeader)) { if (MissingHeader.FileNameLoc.isValid()) { getDiagnostics().Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) << MissingHeader.IsUmbrella << MissingHeader.FileName; } else { getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) << Module->getFullModuleName() << Requirement.second << Requirement.first << SourceRange(Path.front().second, Path.back().second); } @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d435 2 a436 1 llvm::sys::fs::remove(it->TempFilename); d448 2 a449 1 llvm::sys::fs::remove(it->TempFilename); d1094 4 a1097 2 if (RemovedAllFiles) llvm::sys::fs::remove(Dir->path()); @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @a323 2 /*AllowConfigurationMismatch*/false, /*ValidateSystemInputs*/false, d1132 5 a1136 9 if (!Module) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); a1156 2 /*AllowConfigurationMismatch=*/false, /*ValidateSystemInputs=*/false, d1183 11 a1193 1 assert(Module && "missing module file"); d1270 7 @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @a81 4 if (Value) VirtualFileSystem = Value->getVirtualFileSystem(); else VirtualFileSystem.reset(); a102 7 IntrusiveRefCntPtr CompilerInstance::getModuleManager() const { return ModuleManager; } void CompilerInstance::setModuleManager(IntrusiveRefCntPtr Reader) { ModuleManager = Reader; } d113 3 a115 3 llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream( DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo, llvm::sys::fs::F_Append | llvm::sys::fs::F_Text)); d141 1 a141 1 llvm::sys::fs::F_None)); d200 1 a200 5 if (!hasVirtualFileSystem()) { // TODO: choose the virtual file system based on the CompilerInvocation. setVirtualFileSystem(vfs::getRealFileSystem()); } FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem); d296 1 a296 1 IntrusiveRefCntPtr Source; d298 1 a298 1 Source = createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, d304 2 a305 2 getFrontendOpts().UseGlobalModuleIndex); ModuleManager = static_cast(Source.getPtr()); d577 1 a577 1 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text))); a869 2 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem()); d872 1 a872 1 Instance.setFileManager(&ImportingInstance.getFileManager()); d1015 1 a1015 1 llvm::sys::fs::F_None); d1060 1 d1064 3 a1066 3 StringRef Extension = llvm::sys::path::extension(File->path()); if (Extension != ".pcm" && Extension != ".timestamp" && llvm::sys::path::filename(File->path()) != "modules.idx") d1068 1 d1072 2 a1073 1 if (::stat(File->path().c_str(), &StatBuf)) d1075 1 d1081 1 d1086 4 a1089 5 llvm::sys::fs::remove(File->path()); // Remove the timestamp file. std::string TimpestampFilename = File->path() + ".timestamp"; llvm::sys::fs::remove(TimpestampFilename); d1094 1 a1094 2 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) == llvm::sys::fs::directory_iterator() && !EC) d1172 3 a1174 1 getASTContext().setExternalSource(ModuleManager); @ 1.1.1.5.2.1 log @Rebase. @ text @a33 1 #include "clang/Serialization/GlobalModuleIndex.h" d52 3 a54 5 CompilerInstance::CompilerInstance(bool BuildingModule) : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()), ModuleManager(nullptr), BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), ModuleBuildFailed(false) { d150 1 a150 1 std::unique_ptr OS; d159 1 a159 1 d161 1 a161 1 clang::serialized_diags::create(OS.release(), DiagOpts); d163 1 d226 1 a226 1 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { d230 1 a230 1 PTHManager *PTHMgr = nullptr; d240 2 a241 1 PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(), d243 1 a243 2 /*OwnsHeaderSearch=*/true, TUKind); PP->Initialize(getTarget()); d272 1 a272 2 TheDependencyFileGenerator.reset( DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts)); d300 3 a302 3 PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); Context->InitBuiltinTypes(getTarget()); d307 4 a310 3 void CompilerInstance::createPCHExternalASTSource( StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener) { d313 7 a319 5 Source = createPCHExternalASTSource( Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), DeserializationListener, OwnDeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex); d324 11 a334 8 ExternalASTSource *CompilerInstance::createPCHExternalASTSource( StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, void *DeserializationListener, bool OwnDeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); std::unique_ptr Reader; d340 1 a340 1 HSOpts.ModulesValidateSystemHeaders, d344 1 a344 2 static_cast(DeserializationListener), /*TakeOwnership=*/OwnDeserializationListener); d354 1 a354 1 return Reader.release(); d369 1 a369 1 return nullptr; d404 1 a404 1 setCodeCompletionConsumer(nullptr); d411 1 a411 1 setCodeCompletionConsumer(nullptr); d427 1 a427 1 return nullptr; d501 1 a501 1 return nullptr; d539 1 a539 1 std::unique_ptr OS; d551 1 a551 1 return nullptr; d594 1 a594 1 return nullptr; d606 1 a606 1 return OS.release(); d626 1 a626 1 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind)); d660 1 a660 2 SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); d662 1 a662 1 std::unique_ptr SB; d669 2 a670 3 SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); SourceMgr.overrideFileContents(File, SB.release()); d766 32 d800 1 a800 1 static void compileModuleImpl(CompilerInstance &ImportingInstance, d804 21 d842 4 a845 7 PPOpts.Macros.erase( std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), [&HSOpts](const std::pair &def) { StringRef MacroDef = def.first; return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; }), PPOpts.Macros.end()); d878 1 a878 1 CompilerInstance Instance(/*BuildingModule=*/true); d918 2 a919 3 // Construct a module-generating action. Passing through Module->ModuleMap is // safe because the FileManager is shared between the compiler instances. GenerateModuleAction CreateModuleAction(Module->ModuleMap, Module->IsSystem); d925 2 a926 2 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); }, ThreadStackSize); d928 1 a941 32 static void compileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { // FIXME: have LockFileManager return an error_code so that we can // avoid the mkdir when the directory already exists. StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); llvm::sys::fs::create_directories(Dir); while (1) { llvm::LockFileManager Locked(ModuleFileName); switch (Locked) { case llvm::LockFileManager::LFS_Error: return; case llvm::LockFileManager::LFS_Owned: // We're responsible for building the module ourselves. Do so below. break; case llvm::LockFileManager::LFS_Shared: // Someone else is responsible for building the module. Wait for them to // finish. if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied) continue; // try again to get the lock. return; } return compileModuleImpl(ImportingInstance, ImportLoc, Module, ModuleFileName); } } d1055 1 a1055 1 time_t CurrentTime = time(nullptr); a1112 37 void CompilerInstance::createModuleManager() { if (!ModuleManager) { if (!hasASTContext()) createASTContext(); // If we're not recursively building a module, check whether we // need to prune the module cache. if (getSourceManager().getModuleBuildStack().empty() && getHeaderSearchOpts().ModuleCachePruneInterval > 0 && getHeaderSearchOpts().ModuleCachePruneAfter > 0) { pruneModuleCache(getHeaderSearchOpts()); } HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); std::string Sysroot = HSOpts.Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); ModuleManager = new ASTReader(getPreprocessor(), *Context, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders, getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); getASTContext().setASTMutationListener( getASTConsumer().GetASTMutationListener()); } getASTContext().setExternalSource(ModuleManager); if (hasSema()) ModuleManager->InitializeSema(getSema()); if (hasASTConsumer()) ModuleManager->StartTranslationUnit(&getASTConsumer()); } } d1133 1 a1133 1 clang::Module *Module = nullptr; d1143 1 a1143 1 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); d1156 1 a1156 2 std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); d1159 11 a1169 2 if (!ModuleManager) createModuleManager(); d1171 21 a1191 2 if (TheDependencyFileGenerator) TheDependencyFileGenerator->AttachToASTReader(*ModuleManager); a1224 3 getDiagnostics().Report(ImportLoc, diag::remark_module_build) << ModuleName << ModuleFileName; d1255 1 a1255 1 KnownModules[Path[0].first] = nullptr; d1270 1 a1270 1 KnownModules[Path[0].first] = nullptr; d1276 1 a1276 1 KnownModules[Path[0].first] = nullptr; d1356 2 a1357 2 return ModuleLoadResult(nullptr, true); a1414 81 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( SourceLocation TriggerLoc) { if (!ModuleManager) createModuleManager(); // Can't do anything if we don't have the module manager. if (!ModuleManager) return nullptr; // Get an existing global index. This loads it if not already // loaded. ModuleManager->loadGlobalIndex(); GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex(); // If the global index doesn't exist, create it. if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() && hasPreprocessor()) { llvm::sys::fs::create_directories( getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } // For finding modules needing to be imported for fixit messages, // we need to make the global index cover all modules, so we do that here. if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) { ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap(); bool RecreateIndex = false; for (ModuleMap::module_iterator I = MMap.module_begin(), E = MMap.module_end(); I != E; ++I) { Module *TheModule = I->second; const FileEntry *Entry = TheModule->getASTFile(); if (!Entry) { SmallVector, 2> Path; Path.push_back(std::make_pair( getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); std::reverse(Path.begin(), Path.end()); // Load a module as hidden. This also adds it to the global index. loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false); RecreateIndex = true; } } if (RecreateIndex) { GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } HaveFullGlobalModuleIndex = true; } return GlobalIndex; } // Check global module index for missing imports. bool CompilerInstance::lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) { // Look for the symbol in non-imported modules, but only if an error // actually occurred. if (!buildingModule()) { // Load global module index, or retrieve a previously loaded one. GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex( TriggerLoc); // Only if we have a global index. if (GlobalIndex) { GlobalModuleIndex::HitSet FoundModules; // Find the modules that reference the identifier. // Note that this only finds top-level modules. // We'll let diagnoseTypo find the actual declaration module. if (GlobalIndex->lookupIdentifier(Name, FoundModules)) return true; } } return false; } @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @a33 1 #include "clang/Serialization/GlobalModuleIndex.h" d52 3 a54 5 CompilerInstance::CompilerInstance(bool BuildingModule) : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()), ModuleManager(nullptr), BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), ModuleBuildFailed(false) { d150 1 a150 1 std::unique_ptr OS; d159 1 a159 1 d161 1 a161 1 clang::serialized_diags::create(OS.release(), DiagOpts); d163 1 d226 1 a226 1 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { d230 1 a230 1 PTHManager *PTHMgr = nullptr; d240 2 a241 1 PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(), d243 1 a243 2 /*OwnsHeaderSearch=*/true, TUKind); PP->Initialize(getTarget()); d272 1 a272 2 TheDependencyFileGenerator.reset( DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts)); d300 3 a302 3 PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); Context->InitBuiltinTypes(getTarget()); d307 4 a310 3 void CompilerInstance::createPCHExternalASTSource( StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener) { d313 7 a319 5 Source = createPCHExternalASTSource( Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), DeserializationListener, OwnDeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex); d324 11 a334 8 ExternalASTSource *CompilerInstance::createPCHExternalASTSource( StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, void *DeserializationListener, bool OwnDeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); std::unique_ptr Reader; d340 1 a340 1 HSOpts.ModulesValidateSystemHeaders, d344 1 a344 2 static_cast(DeserializationListener), /*TakeOwnership=*/OwnDeserializationListener); d354 1 a354 1 return Reader.release(); d369 1 a369 1 return nullptr; d404 1 a404 1 setCodeCompletionConsumer(nullptr); d411 1 a411 1 setCodeCompletionConsumer(nullptr); d427 1 a427 1 return nullptr; d501 1 a501 1 return nullptr; d539 1 a539 1 std::unique_ptr OS; d551 1 a551 1 return nullptr; d594 1 a594 1 return nullptr; d606 1 a606 1 return OS.release(); d626 1 a626 1 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind)); d660 1 a660 2 SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); d662 1 a662 1 std::unique_ptr SB; d669 2 a670 3 SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); SourceMgr.overrideFileContents(File, SB.release()); d766 32 d800 1 a800 1 static void compileModuleImpl(CompilerInstance &ImportingInstance, d804 21 d842 4 a845 7 PPOpts.Macros.erase( std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), [&HSOpts](const std::pair &def) { StringRef MacroDef = def.first; return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; }), PPOpts.Macros.end()); d878 1 a878 1 CompilerInstance Instance(/*BuildingModule=*/true); d918 2 a919 3 // Construct a module-generating action. Passing through Module->ModuleMap is // safe because the FileManager is shared between the compiler instances. GenerateModuleAction CreateModuleAction(Module->ModuleMap, Module->IsSystem); d925 2 a926 2 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); }, ThreadStackSize); d928 1 a941 32 static void compileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { // FIXME: have LockFileManager return an error_code so that we can // avoid the mkdir when the directory already exists. StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); llvm::sys::fs::create_directories(Dir); while (1) { llvm::LockFileManager Locked(ModuleFileName); switch (Locked) { case llvm::LockFileManager::LFS_Error: return; case llvm::LockFileManager::LFS_Owned: // We're responsible for building the module ourselves. Do so below. break; case llvm::LockFileManager::LFS_Shared: // Someone else is responsible for building the module. Wait for them to // finish. if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied) continue; // try again to get the lock. return; } return compileModuleImpl(ImportingInstance, ImportLoc, Module, ModuleFileName); } } d1055 1 a1055 1 time_t CurrentTime = time(nullptr); a1112 37 void CompilerInstance::createModuleManager() { if (!ModuleManager) { if (!hasASTContext()) createASTContext(); // If we're not recursively building a module, check whether we // need to prune the module cache. if (getSourceManager().getModuleBuildStack().empty() && getHeaderSearchOpts().ModuleCachePruneInterval > 0 && getHeaderSearchOpts().ModuleCachePruneAfter > 0) { pruneModuleCache(getHeaderSearchOpts()); } HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); std::string Sysroot = HSOpts.Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); ModuleManager = new ASTReader(getPreprocessor(), *Context, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders, getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); getASTContext().setASTMutationListener( getASTConsumer().GetASTMutationListener()); } getASTContext().setExternalSource(ModuleManager); if (hasSema()) ModuleManager->InitializeSema(getSema()); if (hasASTConsumer()) ModuleManager->StartTranslationUnit(&getASTConsumer()); } } d1133 1 a1133 1 clang::Module *Module = nullptr; d1143 1 a1143 1 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); d1156 1 a1156 2 std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); d1159 11 a1169 2 if (!ModuleManager) createModuleManager(); d1171 21 a1191 2 if (TheDependencyFileGenerator) TheDependencyFileGenerator->AttachToASTReader(*ModuleManager); a1224 3 getDiagnostics().Report(ImportLoc, diag::remark_module_build) << ModuleName << ModuleFileName; d1255 1 a1255 1 KnownModules[Path[0].first] = nullptr; d1270 1 a1270 1 KnownModules[Path[0].first] = nullptr; d1276 1 a1276 1 KnownModules[Path[0].first] = nullptr; d1356 2 a1357 2 return ModuleLoadResult(nullptr, true); a1414 81 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( SourceLocation TriggerLoc) { if (!ModuleManager) createModuleManager(); // Can't do anything if we don't have the module manager. if (!ModuleManager) return nullptr; // Get an existing global index. This loads it if not already // loaded. ModuleManager->loadGlobalIndex(); GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex(); // If the global index doesn't exist, create it. if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() && hasPreprocessor()) { llvm::sys::fs::create_directories( getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } // For finding modules needing to be imported for fixit messages, // we need to make the global index cover all modules, so we do that here. if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) { ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap(); bool RecreateIndex = false; for (ModuleMap::module_iterator I = MMap.module_begin(), E = MMap.module_end(); I != E; ++I) { Module *TheModule = I->second; const FileEntry *Entry = TheModule->getASTFile(); if (!Entry) { SmallVector, 2> Path; Path.push_back(std::make_pair( getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); std::reverse(Path.begin(), Path.end()); // Load a module as hidden. This also adds it to the global index. loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false); RecreateIndex = true; } } if (RecreateIndex) { GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } HaveFullGlobalModuleIndex = true; } return GlobalIndex; } // Check global module index for missing imports. bool CompilerInstance::lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) { // Look for the symbol in non-imported modules, but only if an error // actually occurred. if (!buildingModule()) { // Load global module index, or retrieve a previously loaded one. GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex( TriggerLoc); // Only if we have a global index. if (GlobalIndex) { GlobalModuleIndex::HitSet FoundModules; // Find the modules that reference the identifier. // Note that this only finds top-level modules. // We'll let diagnoseTypo find the actual declaration module. if (GlobalIndex->lookupIdentifier(Name, FoundModules)) return true; } } return false; } @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @a18 1 #include "clang/Config/config.h" d36 1 a37 1 #include "llvm/Support/Errc.h" d47 1 a48 1 #include a117 10 std::shared_ptr CompilerInstance::getModuleDepCollector() const { return ModuleDepCollector; } void CompilerInstance::setModuleDepCollector( std::shared_ptr Collector) { ModuleDepCollector = Collector; } a225 50 // Initialize the remapping of files to alternative contents, e.g., // those specified through other files. static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts) { // Remap files in the source manager (with buffers). for (const auto &RB : InitOpts.RemappedFileBuffers) { // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first; if (!InitOpts.RetainRemappedFileBuffers) delete RB.second; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, RB.second, InitOpts.RetainRemappedFileBuffers); } // Remap files in the source manager (with other files). for (const auto &RF : InitOpts.RemappedFiles) { // Find the file that we're mapping to. const FileEntry *ToFile = FileMgr.getFile(RF.second); if (!ToFile) { Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second; continue; } // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, ToFile); } SourceMgr.setOverridenFilesKeepOriginalName( InitOpts.RemappedFilesKeepOriginalName); } d258 1 a258 10 // Apply remappings to the source manager. InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(), PP->getFileManager(), PPOpts); // Predefine macros and configure the preprocessor. InitializePreprocessor(*PP, PPOpts, getFrontendOpts()); // Initialize the header search object. ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(), PP->getLangOpts(), PP->getTargetInfo().getTriple()); a279 8 for (auto &Listener : DependencyCollectors) Listener->attachToPreprocessor(*PP); // If we don't have a collector, but we are collecting module dependencies, // then we're the top level compiler instance and need to create one. if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) ModuleDepCollector = std::make_shared( DepOpts.ModuleDependencyOutputDir); d320 1 a320 1 ModuleManager = static_cast(Source.get()); d457 2 a458 2 if (std::error_code ec = llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) { a480 6 llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() { llvm::raw_null_ostream *OS = new llvm::raw_null_ostream(); addOutputFile(OutputFile("", "", OS)); return OS; } d565 1 a565 1 std::error_code EC = d661 3 a663 4 llvm::ErrorOr> SBOrErr = llvm::MemoryBuffer::getSTDIN(); if (std::error_code EC = SBOrErr.getError()) { Diags.Report(diag::err_fe_error_reading_stdin) << EC.message(); a665 2 std::unique_ptr SB = std::move(SBOrErr.get()); d690 1 a690 2 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getInvocation().TargetOpts)); d698 1 a698 1 getTarget().adjust(getLangOpts()); d707 1 a707 1 << " based upon " << BACKEND_PACKAGE_STRING d767 5 a771 6 /// provided by the importing compiler instance. Returns true if the module /// was built without errors. static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { a846 4 // If we're collecting module dependencies, we need to share a collector // between all of the module CompilerInstances. Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector()); d861 1 a861 1 llvm::MemoryBuffer *ModuleMapBuffer = d868 1 a868 1 // Construct a module-generating action. Passing through the module map is d870 1 a870 2 GenerateModuleAction CreateModuleAction( ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem); a889 2 return !Instance.getDiagnostics().hasErrorOccurred(); d892 4 a895 10 static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) { auto diagnoseBuildFailure = [&] { ImportingInstance.getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) << Module->Name << SourceRange(ImportLoc, ModuleNameLoc); }; a901 1 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing; d905 1 a905 1 return false; d908 1 a908 6 // We're responsible for building the module ourselves. if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module, ModuleFileName)) { diagnoseBuildFailure(); return false; } d916 1 a916 2 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate; break; d919 2 a920 16 // Try to read the module file, now that we've compiled it. ASTReader::ASTReadResult ReadResult = ImportingInstance.getModuleManager()->ReadAST( ModuleFileName, serialization::MK_Module, ImportLoc, ModuleLoadCapabilities); if (ReadResult == ASTReader::OutOfDate && Locked == llvm::LockFileManager::LFS_Shared) { // The module may be out of date in the presence of file system races, // or if one of its imports depends on header search paths that are not // consistent with this ImportingInstance. Try again... continue; } else if (ReadResult == ASTReader::Missing) { diagnoseBuildFailure(); } return ReadResult == ASTReader::Success; d1048 1 a1048 1 std::error_code EC; d1146 1 a1146 2 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule && ModuleName != getLangOpts().ImplementationOfModule) d1160 1 a1160 2 } else if (ModuleName == getLangOpts().CurrentModule || ModuleName == getLangOpts().ImplementationOfModule) { a1184 6 if (ModuleDepCollector) ModuleDepCollector->attachToASTReader(*ModuleManager); for (auto &Listener : DependencyCollectors) Listener->attachToASTReader(*ModuleManager); d1231 17 a1247 3 // Try to compile and then load the module. if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module, ModuleFileName)) { a1336 4 // Don't make the module visible if we are in the implementation. if (ModuleName == getLangOpts().ImplementationOfModule) return ModuleLoadResult(Module, false); @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d104 2 a105 2 void CompilerInstance::setASTConsumer(std::unique_ptr Value) { Consumer = std::move(Value); d111 1 a111 5 std::unique_ptr CompilerInstance::takeSema() { return std::move(TheSema); } d133 2 a134 2 std::error_code EC; std::unique_ptr StreamOwner; d138 4 a141 4 auto FileOS = llvm::make_unique( DiagOpts->DiagnosticLogFile, EC, llvm::sys::fs::F_Append | llvm::sys::fs::F_Text); if (EC) { d143 1 a143 1 << DiagOpts->DiagnosticLogFile << EC.message(); d147 2 a148 2 OS = FileOS.get(); StreamOwner = std::move(FileOS); d153 2 a154 2 auto Logger = llvm::make_unique(*OS, DiagOpts, std::move(StreamOwner)); d157 1 a157 3 assert(Diags.ownsClient()); Diags.setClient( new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger))); d163 4 a166 2 auto SerializedConsumer = clang::serialized_diags::create(OutputFile, DiagOpts); d168 4 a171 6 if (Diags.ownsClient()) { Diags.setClient(new ChainedDiagnosticConsumer( Diags.takeClient(), std::move(SerializedConsumer))); } else { Diags.setClient(new ChainedDiagnosticConsumer( Diags.getClient(), std::move(SerializedConsumer))); d173 6 a373 8 // Load all explictly-specified module map files. for (const auto &Filename : getFrontendOpts().ModuleMapFiles) { if (auto *File = getFileManager().getFile(Filename)) PP->getHeaderSearchInfo().loadModuleMapFile(File, /*IsSystem*/false); else getDiagnostics().Report(diag::err_module_map_not_found) << Filename; } d572 8 a579 5 std::string OutputPathName, TempPathName; std::error_code EC; llvm::raw_fd_ostream *OS = createOutputFile( OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension, UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName); d581 2 a582 2 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath << EC.message(); d594 11 a604 5 llvm::raw_fd_ostream *CompilerInstance::createOutputFile( StringRef OutputPath, std::error_code &Error, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories, std::string *ResultPathName, std::string *TempPathName) { d673 1 a673 1 OSFile, Error, d675 1 a675 1 if (Error) d708 1 a708 2 SourceMgr.setMainFileID(SourceMgr.createFileID( std::unique_ptr(Input.getBuffer()), Kind)); d730 3 a732 2 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true); if (MB) { d734 2 a735 2 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0); SourceMgr.overrideFileContents(File, std::move(*MB)); d737 1 a737 2 Diags.Report(diag::err_cannot_open_file) << InputFile << MB.getError().message(); d757 1 a757 1 SourceMgr.overrideFileContents(File, std::move(SB)); d805 2 a806 3 // Reset the ID tables if we are reusing the SourceManager and parsing // regular files. if (hasSourceManager() && !Act.isModelParsingAction()) d954 1 a954 1 std::unique_ptr ModuleMapBuffer = d958 1 a958 1 SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer)); d965 1 a965 5 ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build) << Module->Name << ModuleFileName; a972 4 ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build_done) << Module->Name; a991 2 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics(); d993 2 a994 1 Diags.Report(ModuleNameLoc, diag::err_module_not_built) a1007 2 Diags.Report(ModuleNameLoc, diag::err_module_lock_failure) << Module->Name; d1031 1 a1031 1 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc, a1041 4 } else if (ReadResult != ASTReader::Success && !Diags.hasErrorOccurred()) { // The ASTReader didn't diagnose the error, so conservatively report it. diagnoseBuildFailure(); d1135 3 a1137 2 std::error_code EC; llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None); a1254 59 bool CompilerInstance::loadModuleFile(StringRef FileName) { // Helper to recursively read the module names for all modules we're adding. // We mark these as known and redirect any attempt to load that module to // the files we were handed. struct ReadModuleNames : ASTReaderListener { CompilerInstance &CI; std::vector ModuleFileStack; bool Failed; bool TopFileIsModule; ReadModuleNames(CompilerInstance &CI) : CI(CI), Failed(false), TopFileIsModule(false) {} bool needsImportVisitation() const override { return true; } void visitImport(StringRef FileName) override { ModuleFileStack.push_back(FileName); if (ASTReader::readASTFileControlBlock(FileName, CI.getFileManager(), *this)) { CI.getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_found) << FileName; // FIXME: Produce a note stack explaining how we got here. Failed = true; } ModuleFileStack.pop_back(); } void ReadModuleName(StringRef ModuleName) override { if (ModuleFileStack.size() == 1) TopFileIsModule = true; auto &ModuleFile = CI.ModuleFileOverrides[ModuleName]; if (!ModuleFile.empty() && CI.getFileManager().getFile(ModuleFile) != CI.getFileManager().getFile(ModuleFileStack.back())) CI.getDiagnostics().Report(SourceLocation(), diag::err_conflicting_module_files) << ModuleName << ModuleFile << ModuleFileStack.back(); ModuleFile = ModuleFileStack.back(); } } RMN(*this); RMN.visitImport(FileName); if (RMN.Failed) return false; // If we never found a module name for the top file, then it's not a module, // it's a PCH or preamble or something. if (!RMN.TopFileIsModule) { getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_module) << FileName; return false; } return true; } a1299 3 auto Override = ModuleFileOverrides.find(ModuleName); bool Explicit = Override != ModuleFileOverrides.end(); d1301 1 a1301 2 Explicit ? Override->second : PP->getHeaderSearchInfo().getModuleFileName(Module); d1317 2 a1318 5 unsigned ARRFlags = Explicit ? 0 : ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; switch (ModuleManager->ReadAST(ModuleFileName, Explicit ? serialization::MK_ExplicitModule : serialization::MK_ImplicitModule, a1324 7 if (Explicit) { // ReadAST has already complained for us. ModuleLoader::HadFatalFailure = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } d1348 3 a1364 2 assert(getDiagnostics().hasErrorOccurred() && "undiagnosed error in compileAndLoadModule"); d1478 1 a1478 1 clang::Module::UnresolvedHeaderDirective MissingHeader; a1506 7 // Determine whether we're in the #include buffer for a module. The #includes // in that buffer do not qualify as module imports; they're just an // implementation detail of us building the module. bool IsInModuleIncludes = !getLangOpts().CurrentModule.empty() && getSourceManager().getFileID(ImportLoc) == getSourceManager().getMainFileID(); d1509 1 a1509 1 if (IsInclusionDirective && hasASTContext() && !IsInModuleIncludes) { a1611 1 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); } @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d104 2 a105 2 void CompilerInstance::setASTConsumer(std::unique_ptr Value) { Consumer = std::move(Value); d111 1 a111 5 std::unique_ptr CompilerInstance::takeSema() { return std::move(TheSema); } d133 2 a134 2 std::error_code EC; std::unique_ptr StreamOwner; d138 4 a141 4 auto FileOS = llvm::make_unique( DiagOpts->DiagnosticLogFile, EC, llvm::sys::fs::F_Append | llvm::sys::fs::F_Text); if (EC) { d143 1 a143 1 << DiagOpts->DiagnosticLogFile << EC.message(); d147 2 a148 2 OS = FileOS.get(); StreamOwner = std::move(FileOS); d153 2 a154 2 auto Logger = llvm::make_unique(*OS, DiagOpts, std::move(StreamOwner)); d157 1 a157 3 assert(Diags.ownsClient()); Diags.setClient( new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger))); d163 4 a166 2 auto SerializedConsumer = clang::serialized_diags::create(OutputFile, DiagOpts); d168 4 a171 6 if (Diags.ownsClient()) { Diags.setClient(new ChainedDiagnosticConsumer( Diags.takeClient(), std::move(SerializedConsumer))); } else { Diags.setClient(new ChainedDiagnosticConsumer( Diags.getClient(), std::move(SerializedConsumer))); d173 6 a373 8 // Load all explictly-specified module map files. for (const auto &Filename : getFrontendOpts().ModuleMapFiles) { if (auto *File = getFileManager().getFile(Filename)) PP->getHeaderSearchInfo().loadModuleMapFile(File, /*IsSystem*/false); else getDiagnostics().Report(diag::err_module_map_not_found) << Filename; } d572 8 a579 5 std::string OutputPathName, TempPathName; std::error_code EC; llvm::raw_fd_ostream *OS = createOutputFile( OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension, UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName); d581 2 a582 2 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath << EC.message(); d594 11 a604 5 llvm::raw_fd_ostream *CompilerInstance::createOutputFile( StringRef OutputPath, std::error_code &Error, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories, std::string *ResultPathName, std::string *TempPathName) { d673 1 a673 1 OSFile, Error, d675 1 a675 1 if (Error) d708 1 a708 2 SourceMgr.setMainFileID(SourceMgr.createFileID( std::unique_ptr(Input.getBuffer()), Kind)); d730 3 a732 2 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true); if (MB) { d734 2 a735 2 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0); SourceMgr.overrideFileContents(File, std::move(*MB)); d737 1 a737 2 Diags.Report(diag::err_cannot_open_file) << InputFile << MB.getError().message(); d757 1 a757 1 SourceMgr.overrideFileContents(File, std::move(SB)); d805 2 a806 3 // Reset the ID tables if we are reusing the SourceManager and parsing // regular files. if (hasSourceManager() && !Act.isModelParsingAction()) d954 1 a954 1 std::unique_ptr ModuleMapBuffer = d958 1 a958 1 SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer)); d965 1 a965 5 ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build) << Module->Name << ModuleFileName; a972 4 ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build_done) << Module->Name; a991 2 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics(); d993 2 a994 1 Diags.Report(ModuleNameLoc, diag::err_module_not_built) a1007 2 Diags.Report(ModuleNameLoc, diag::err_module_lock_failure) << Module->Name; d1031 1 a1031 1 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc, a1041 4 } else if (ReadResult != ASTReader::Success && !Diags.hasErrorOccurred()) { // The ASTReader didn't diagnose the error, so conservatively report it. diagnoseBuildFailure(); d1135 3 a1137 2 std::error_code EC; llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None); a1254 59 bool CompilerInstance::loadModuleFile(StringRef FileName) { // Helper to recursively read the module names for all modules we're adding. // We mark these as known and redirect any attempt to load that module to // the files we were handed. struct ReadModuleNames : ASTReaderListener { CompilerInstance &CI; std::vector ModuleFileStack; bool Failed; bool TopFileIsModule; ReadModuleNames(CompilerInstance &CI) : CI(CI), Failed(false), TopFileIsModule(false) {} bool needsImportVisitation() const override { return true; } void visitImport(StringRef FileName) override { ModuleFileStack.push_back(FileName); if (ASTReader::readASTFileControlBlock(FileName, CI.getFileManager(), *this)) { CI.getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_found) << FileName; // FIXME: Produce a note stack explaining how we got here. Failed = true; } ModuleFileStack.pop_back(); } void ReadModuleName(StringRef ModuleName) override { if (ModuleFileStack.size() == 1) TopFileIsModule = true; auto &ModuleFile = CI.ModuleFileOverrides[ModuleName]; if (!ModuleFile.empty() && CI.getFileManager().getFile(ModuleFile) != CI.getFileManager().getFile(ModuleFileStack.back())) CI.getDiagnostics().Report(SourceLocation(), diag::err_conflicting_module_files) << ModuleName << ModuleFile << ModuleFileStack.back(); ModuleFile = ModuleFileStack.back(); } } RMN(*this); RMN.visitImport(FileName); if (RMN.Failed) return false; // If we never found a module name for the top file, then it's not a module, // it's a PCH or preamble or something. if (!RMN.TopFileIsModule) { getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_module) << FileName; return false; } return true; } a1299 3 auto Override = ModuleFileOverrides.find(ModuleName); bool Explicit = Override != ModuleFileOverrides.end(); d1301 1 a1301 2 Explicit ? Override->second : PP->getHeaderSearchInfo().getModuleFileName(Module); d1317 2 a1318 5 unsigned ARRFlags = Explicit ? 0 : ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; switch (ModuleManager->ReadAST(ModuleFileName, Explicit ? serialization::MK_ExplicitModule : serialization::MK_ImplicitModule, a1324 7 if (Explicit) { // ReadAST has already complained for us. ModuleLoader::HadFatalFailure = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } d1348 3 a1364 2 assert(getDiagnostics().hasErrorOccurred() && "undiagnosed error in compileAndLoadModule"); d1478 1 a1478 1 clang::Module::UnresolvedHeaderDirective MissingHeader; a1506 7 // Determine whether we're in the #include buffer for a module. The #includes // in that buffer do not qualify as module imports; they're just an // implementation detail of us building the module. bool IsInModuleIncludes = !getLangOpts().CurrentModule.empty() && getSourceManager().getFileID(ImportLoc) == getSourceManager().getMainFileID(); d1509 1 a1509 1 if (IsInclusionDirective && hasASTContext() && !IsInModuleIncludes) { a1611 1 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); } @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @d54 6 a59 7 CompilerInstance::CompilerInstance( std::shared_ptr PCHContainerOps, bool BuildingModule) : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()), ModuleManager(nullptr), ThePCHContainerOperations(PCHContainerOps), BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), ModuleBuildFailed(false) {} d80 3 a82 2 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; } void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; } d98 1 a98 6 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; if (Context && Consumer) getASTConsumer().Initialize(getASTContext()); } a105 3 if (Context && Consumer) getASTConsumer().Initialize(getASTContext()); d150 1 d306 1 a306 1 PP->Initialize(getTarget(), getAuxTarget()); d324 1 a324 2 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(), getFrontendOpts()); d332 8 a339 2 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath()); d361 1 a361 1 AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps); d366 1 a366 2 AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps, /*ShowAllHeaders=*/true, OutputPath, d371 1 a371 2 AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps, /*ShowAllHeaders=*/false, /*OutputPath=*/"", a373 1 } d375 7 a381 8 std::string CompilerInstance::getSpecificModuleCachePath() { // Set up the module path, including the hash for the // module-creation options. SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath); if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash) llvm::sys::path::append(SpecificModuleCache, getInvocation().getModuleHash()); return SpecificModuleCache.str(); d388 4 a391 5 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); Context->InitBuiltinTypes(getTarget(), getAuxTarget()); setASTContext(Context); d399 1 d401 1 a401 1 ModuleManager = createPCHExternalASTSource( d404 1 a404 4 getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions, DeserializationListener, OwnDeserializationListener, Preamble, d406 2 d410 2 a411 2 IntrusiveRefCntPtr CompilerInstance::createPCHExternalASTSource( StringRef Path, StringRef Sysroot, bool DisablePCHValidation, a412 2 const PCHContainerReader &PCHContainerRdr, ArrayRef> Extensions, d417 8 a424 9 IntrusiveRefCntPtr Reader(new ASTReader( PP, Context, PCHContainerRdr, Extensions, Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation, AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false, HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex)); // We need the external source to be set up before we read the AST, because // eagerly-deserialized declarations may use it. Context.setExternalSource(Reader.get()); d438 1 a438 1 return Reader; a452 1 Context.setExternalSource(nullptr); d500 1 a500 3 FrontendTimerGroup.reset(new llvm::TimerGroup("Clang front-end time report")); FrontendTimer.reset( new llvm::Timer("Clang front-end timer", *FrontendTimerGroup)); d505 1 a505 1 StringRef Filename, d525 1 a525 1 void CompilerInstance::addOutputFile(OutputFile &&OutFile) { d527 1 a527 1 OutputFiles.push_back(std::move(OutFile)); d531 4 a534 5 for (OutputFile &OF : OutputFiles) { // Manually close the stream before we rename it. OF.OS.reset(); if (!OF.TempFilename.empty()) { d536 1 a536 1 llvm::sys::fs::remove(OF.TempFilename); d538 1 a538 1 SmallString<128> NewOutFile(OF.Filename); d544 1 a544 1 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) { d546 1 a546 1 << OF.TempFilename << OF.Filename << ec.message(); d548 1 a548 1 llvm::sys::fs::remove(OF.TempFilename); d551 2 a552 2 } else if (!OF.Filename.empty() && EraseFiles) llvm::sys::fs::remove(OF.Filename); a555 1 NonSeekStream.reset(); d558 3 a560 2 raw_pwrite_stream * CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile, d568 3 a570 4 auto OS = llvm::make_unique(); llvm::raw_null_ostream *Ret = OS.get(); addOutputFile(OutputFile("", "", std::move(OS))); return Ret; d573 6 a578 4 raw_pwrite_stream * CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, d582 1 a582 1 std::unique_ptr OS = createOutputFile( a590 1 raw_pwrite_stream *Ret = OS.get(); d594 1 a594 1 TempPathName, std::move(OS))); d596 1 a596 1 return Ret; d599 1 a599 1 std::unique_ptr CompilerInstance::createOutputFile( d631 1 a631 2 if (!llvm::sys::fs::can_write(OutputPath)) { Error = make_error_code(llvm::errc::operation_not_permitted); a632 1 } d649 1 a649 1 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath); d656 1 a656 1 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath); d687 1 a687 7 if (!Binary || OS->supportsSeeking()) return std::move(OS); auto B = llvm::make_unique(*OS); assert(!NonSeekStream); NonSeekStream = std::move(OS); return std::move(B); d709 1 a709 1 assert(SourceMgr.getMainFileID().isValid() && d760 1 a760 1 assert(SourceMgr.getMainFileID().isValid() && a781 7 // Create TargetInfo for the other side of CUDA compilation. if (getLangOpts().CUDA && !getFrontendOpts().AuxTriple.empty()) { std::shared_ptr TO(new TargetOptions); TO->Triple = getFrontendOpts().AuxTriple; setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO)); } d804 1 a804 1 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) { d810 1 a810 1 if (Act.BeginSourceFile(*this, FIF)) { a905 1 FrontendOpts.BuildingImplicitModule = true; d918 1 a918 2 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(), /*BuildingModule=*/true); d938 1 a938 2 // between all of the module CompilerInstances. Other than that, we don't // want to produce any dependency output from the module build. a939 1 Invocation->getDependencyOutputOpts() = DependencyOutputOptions(); d946 2 a947 1 FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK); a948 4 SmallString<128> FakeModuleMapFile(Module->Directory->getName()); llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map"); FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK); d952 2 d958 1 a958 1 FakeModuleMapFile, InferredModuleMapContent.size(), 0); d1034 1 a1034 5 switch (Locked.waitForUnlock()) { case llvm::LockFileManager::Res_Success: ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate; break; case llvm::LockFileManager::Res_OwnerDied: d1036 1 a1036 7 case llvm::LockFileManager::Res_Timeout: Diags.Report(ModuleNameLoc, diag::err_module_lock_timeout) << Module->Name; // Clear the lock file so that future invokations can make progress. Locked.unsafeRemoveLockFile(); return false; } a1073 1 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id); d1075 40 a1114 3 // Find the macro definition from the command line. MacroInfo *CmdLineDefinition = nullptr; for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) { d1116 1 a1116 2 FileID FID = SourceMgr.getFileID(MD->getLocation()); if (FID.isInvalid() || FID != PP.getPredefinesFileID()) d1118 2 a1119 2 if (auto *DMD = dyn_cast(MD)) CmdLineDefinition = DMD->getMacroInfo(); d1123 5 a1127 17 auto *CurrentDefinition = PP.getMacroInfo(Id); if (CurrentDefinition == CmdLineDefinition) { // Macro matches. Nothing to do. } else if (!CurrentDefinition) { // This macro was defined on the command line, then #undef'd later. // Complain. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << true << ConfigMacro << Mod->getFullModuleName(); auto LatestDef = LatestLocalMD->getDefinition(); assert(LatestDef.isUndefined() && "predefined macro went away with no #undef?"); PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) << true; return; } else if (!CmdLineDefinition) { // There was no definition for this macro in the predefines buffer, // but there was a local definition. Complain. d1130 1 a1130 10 PP.Diag(CurrentDefinition->getDefinitionLoc(), diag::note_module_def_undef_here) << false; } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP, /*Syntactically=*/true)) { // The macro definitions differ. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(CurrentDefinition->getDefinitionLoc(), diag::note_module_def_undef_here) d1132 1 d1134 13 a1160 1 assert(!TimestampFile.empty()); d1189 2 a1190 1 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd; d1238 2 a1239 2 // If we're implicitly building modules but not currently recursively // building a module, check whether we need to prune the module cache. a1240 1 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() && d1249 7 a1255 13 std::unique_ptr ReadTimer; if (FrontendTimerGroup) ReadTimer = llvm::make_unique("Reading modules", *FrontendTimerGroup); ModuleManager = new ASTReader( getPreprocessor(), getASTContext(), getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders, getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer)); a1266 7 if (TheDependencyFileGenerator) TheDependencyFileGenerator->AttachToASTReader(*ModuleManager); if (ModuleDepCollector) ModuleDepCollector->attachToASTReader(*ModuleManager); for (auto &Listener : DependencyCollectors) Listener->attachToASTReader(*ModuleManager); a1270 5 llvm::Timer Timer; if (FrontendTimerGroup) Timer.init("Preloading " + FileName.str(), *FrontendTimerGroup); llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr); d1276 21 a1296 3 llvm::SmallVector LoadedModules; ReadModuleNames(CompilerInstance &CI) : CI(CI) {} d1299 2 a1300 3 LoadedModules.push_back( CI.getPreprocessor().getIdentifierInfo(ModuleName)); } d1302 8 a1309 8 void registerAll() { for (auto *II : LoadedModules) { CI.KnownModules[II] = CI.getPreprocessor() .getHeaderSearchInfo() .getModuleMap() .findModule(II->getName()); } LoadedModules.clear(); d1311 1 d1313 1 a1313 11 void markAllUnavailable() { for (auto *II : LoadedModules) { if (Module *M = CI.getPreprocessor() .getHeaderSearchInfo() .getModuleMap() .findModule(II->getName())) M->HasIncompatibleModuleFile = true; } LoadedModules.clear(); } }; d1315 2 a1316 27 // If we don't already have an ASTReader, create one now. if (!ModuleManager) createModuleManager(); auto Listener = llvm::make_unique(*this); auto &ListenerRef = *Listener; ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager, std::move(Listener)); // Try to load the module file. switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule, SourceLocation(), ASTReader::ARR_ConfigurationMismatch)) { case ASTReader::Success: // We successfully loaded the module file; remember the set of provided // modules so that we don't try to load implicit modules for them. ListenerRef.registerAll(); return true; case ASTReader::ConfigurationMismatch: // Ignore unusable module files. getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) << FileName; // All modules provided by any files we tried and failed to load are now // unavailable; includes of those modules should now be handled textually. ListenerRef.markAllUnavailable(); return true; d1318 5 a1322 1 default: d1325 2 d1341 1 a1341 1 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) { d1346 1 a1346 1 ImportLoc); d1374 3 d1378 2 a1379 13 PP->getHeaderSearchInfo().getModuleFileName(Module); if (ModuleFileName.empty()) { if (Module->HasIncompatibleModuleFile) { // We tried and failed to load a module file for this module. Fall // back to textual inclusion for its headers. return ModuleLoadResult(nullptr, /*missingExpected*/true); } getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled) << ModuleName; ModuleBuildFailed = true; return ModuleLoadResult(); } d1385 8 a1392 4 llvm::Timer Timer; if (FrontendTimerGroup) Timer.init("Loading " + ModuleFileName, *FrontendTimerGroup); llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr); d1395 2 a1396 1 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; d1398 2 a1399 1 serialization::MK_ImplicitModule, d1406 7 d1467 1 a1467 1 // FIXME: The ASTReader will already have complained, but can we shoehorn d1583 2 a1584 1 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc); d1594 19 d1620 3 a1622 7 SourceLocation ImportLoc) { if (!ModuleManager) createModuleManager(); if (!ModuleManager) return; ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc); a1626 2 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty()) return nullptr; d1642 2 a1643 2 getFileManager(), getPCHContainerReader(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); d1660 1 a1660 1 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); d1662 3 a1664 2 // Load a module as hidden. This also adds it to the global index. loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false); d1670 2 a1671 2 getFileManager(), getPCHContainerReader(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); @ 1.1.1.9.2.1 log @Sync with HEAD @ text @a31 1 #include "clang/Lex/PreprocessorOptions.h" a50 1 #include d58 1 a58 2 ModuleManager(nullptr), ThePCHContainerOperations(std::move(PCHContainerOps)), d66 2 a67 3 void CompilerInstance::setInvocation( std::shared_ptr Value) { Invocation = std::move(Value); d96 1 a96 3 void CompilerInstance::setPreprocessor(std::shared_ptr Value) { PP = std::move(Value); } d128 1 a128 1 ModuleManager = std::move(Reader); d138 1 a138 61 ModuleDepCollector = std::move(Collector); } static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr MDC) { SmallVector HeaderMapFileNames; HS.getHeaderMapFileNames(HeaderMapFileNames); for (auto &Name : HeaderMapFileNames) MDC->addFile(Name); } static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr MDC) { const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); if (PPOpts.ImplicitPCHInclude.empty()) return; StringRef PCHInclude = PPOpts.ImplicitPCHInclude; FileManager &FileMgr = CI.getFileManager(); const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude); if (!PCHDir) { MDC->addFile(PCHInclude); return; } std::error_code EC; SmallString<128> DirNative; llvm::sys::path::native(PCHDir->getName(), DirNative); vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem(); SimpleASTReaderListener Validator(CI.getPreprocessor()); for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not // used here since we're not interested in validating the PCH at this time, // but only to check whether this is a file containing an AST. if (!ASTReader::readASTFileControlBlock( Dir->getName(), FileMgr, CI.getPCHContainerReader(), /*FindModuleFileExtensions=*/false, Validator, /*ValidateDiagnosticOptions=*/false)) MDC->addFile(Dir->getName()); } } static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr MDC) { if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty()) return; // Collect all VFS found. SmallVector VFSEntries; for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) { llvm::ErrorOr> Buffer = llvm::MemoryBuffer::getFile(VFSFile); if (!Buffer) return; vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr, VFSFile, VFSEntries); } for (auto &E : VFSEntries) MDC->addFile(E.VPath, E.RPath); d305 8 a312 7 HeaderSearch *HeaderInfo = new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(), getDiagnostics(), getLangOpts(), &getTarget()); PP = std::make_shared( Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(), getSourceManager(), *HeaderInfo, *this, PTHMgr, /*OwnsHeaderSearch=*/true, TUKind); d334 1 a334 8 // Initialize the header search object. In CUDA compilations, we use the aux // triple (the host triple) to initialize our header search, since we need to // find the host headers in order to compile the CUDA code. const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple(); if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA && PP->getAuxTargetInfo()) HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple(); d336 1 a336 1 PP->getLangOpts(), *HeaderSearchTriple); d352 3 d357 1 a357 1 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) { a359 13 } // If there is a module dep collector, register with other dep collectors // and also (a) collect header maps and (b) TODO: input vfs overlay files. if (ModuleDepCollector) { addDependencyCollector(ModuleDepCollector); collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector); collectIncludePCH(*this, ModuleDepCollector); collectVFSEntries(*this, ModuleDepCollector); } for (auto &Listener : DependencyCollectors) Listener->attachToPreprocessor(*PP); d363 1 a363 1 AttachHeaderIncludeGen(*PP, DepOpts); d368 1 a368 1 AttachHeaderIncludeGen(*PP, DepOpts, d374 2 a375 2 AttachHeaderIncludeGen(*PP, DepOpts, /*ShowAllHeaders=*/true, /*OutputPath=*/"", d421 1 a421 1 ArrayRef> Extensions, d470 1 a470 1 StringRef Filename, d511 1 a511 2 FrontendTimerGroup.reset( new llvm::TimerGroup("frontend", "Clang front-end time report")); d513 1 a513 2 new llvm::Timer("frontend", "Clang front-end timer", *FrontendTimerGroup)); a533 5 // Attach the external sema source if there is any. if (ExternalSemaSrc) { TheSema->addExternalSource(ExternalSemaSrc.get()); ExternalSemaSrc->InitializeSema(*TheSema); } d539 1 d545 3 d567 1 d573 1 a573 1 std::unique_ptr d581 5 a585 2 std::unique_ptr CompilerInstance::createNullOutputFile() { return llvm::make_unique(); d588 1 a588 1 std::unique_ptr d604 1 d607 2 a608 2 addOutputFile( OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName)); d610 1 a610 1 return OS; d715 3 a717 4 return InitializeSourceManager( Input, getDiagnostics(), getFileManager(), getSourceManager(), hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr, getDependencyOutputOpts(), getFrontendOpts()); d720 5 a724 5 // static bool CompilerInstance::InitializeSourceManager( const FrontendInputFile &Input, DiagnosticsEngine &Diags, FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS, DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) { d740 1 a740 29 const FileEntry *File; if (Opts.FindPchSource.empty()) { File = FileMgr.getFile(InputFile, /*OpenFile=*/true); } else { // When building a pch file in clang-cl mode, the .h file is built as if // it was included by a cc file. Since the driver doesn't know about // all include search directories, the frontend must search the input // file through HeaderSearch here, as if it had been included by the // cc file at Opts.FindPchSource. const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource); if (!FindFile) { Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource; return false; } const DirectoryLookup *UnusedCurDir; SmallVector, 16> Includers; Includers.push_back(std::make_pair(FindFile, FindFile->getDir())); File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false, /*FromDir=*/nullptr, /*CurDir=*/UnusedCurDir, Includers, /*SearchPath=*/nullptr, /*RelativePath=*/nullptr, /*RequestingModule=*/nullptr, /*SuggestedModule=*/nullptr, /*SkipCache=*/true); // Also add the header to /showIncludes output. if (File) DepOpts.ShowIncludesPretendHeader = File->getName(); } d806 1 a806 1 auto TO = std::make_shared(); a807 1 TO->HostTriple = getTarget().getTriple().str(); a816 3 // Adjust target options based on codegen options. getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts()); d830 2 a831 2 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty()) llvm::EnableStatistics(false); d864 3 a866 18 if (getFrontendOpts().ShowStats) { if (hasFileManager()) { getFileManager().PrintStats(); OS << '\n'; } llvm::PrintStatistics(OS); } StringRef StatsFile = getFrontendOpts().StatsFile; if (!StatsFile.empty()) { std::error_code EC; auto StatS = llvm::make_unique(StatsFile, EC, llvm::sys::fs::F_Text); if (EC) { getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file) << StatsFile << EC.message(); } else { llvm::PrintStatisticsJSON(*StatS); } d895 2 a896 2 auto Invocation = std::make_shared(ImportingInstance.getInvocation()); d912 1 a912 2 return HSOpts.ModulesIgnoreMacros.count( llvm::CachedHashString(MacroDef.split('=').first)) > 0; d925 1 a925 2 ImportingPPOpts.FailedModules = std::make_shared(); d950 1 a950 2 auto &Inv = *Invocation; Instance.setInvocation(std::move(Invocation)); d972 1 a972 1 Inv.getDependencyOutputOpts() = DependencyOutputOptions(); d998 1 a998 1 GenerateModuleFromModuleMapAction CreateModuleAction( d1053 1 a1053 1 << Module->Name << Locked.getErrorMessage(); d1268 1 a1268 2 ReadTimer = llvm::make_unique("reading_modules", "Reading modules", d1293 2 d1303 1 a1303 2 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(), *FrontendTimerGroup); d1335 1 a1335 1 .findModule(II->getName())) { a1336 13 // Mark module as available if the only reason it was unavailable // was missing headers. SmallVector Stack; Stack.push_back(M); while (!Stack.empty()) { Module *Current = Stack.pop_back_val(); if (Current->IsMissingRequirement) continue; Current->IsAvailable = true; Stack.insert(Stack.end(), Current->submodule_begin(), Current->submodule_end()); } } d1389 2 a1390 1 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) d1404 2 a1405 1 } else if (ModuleName == getLangOpts().CurrentModule) { d1412 1 a1412 19 HeaderSearchOptions &HSOpts = PP->getHeaderSearchInfo().getHeaderSearchOpts(); std::string ModuleFileName; bool LoadFromPrebuiltModulePath = false; // We try to load the module from the prebuilt module paths. If not // successful, we then try to find it in the module cache. if (!HSOpts.PrebuiltModulePaths.empty()) { // Load the module from the prebuilt module path. ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName( ModuleName, "", /*UsePrebuiltPath*/ true); if (!ModuleFileName.empty()) LoadFromPrebuiltModulePath = true; } if (!LoadFromPrebuiltModulePath && Module) { // Load the module from the module cache. ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); } else if (!LoadFromPrebuiltModulePath) { // We can't find a module, error out here. d1420 2 d1423 1 a1423 1 if (Module && Module->HasIncompatibleModuleFile) { d1426 1 a1426 1 return ModuleLoadResult::ConfigMismatch; d1441 1 a1441 2 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName, *FrontendTimerGroup); d1444 2 a1445 6 // Try to load the module file. If we are trying to load from the prebuilt // module path, we don't have the module map files and don't know how to // rebuild modules. unsigned ARRFlags = LoadFromPrebuiltModulePath ? ASTReader::ARR_ConfigurationMismatch : ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; a1446 2 LoadFromPrebuiltModulePath ? serialization::MK_PrebuiltModule : d1448 2 a1449 16 ImportLoc, ARRFlags)) { case ASTReader::Success: { if (LoadFromPrebuiltModulePath && !Module) { Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); if (!Module || !Module->getASTFile() || FileMgr->getFile(ModuleFileName) != Module->getASTFile()) { // Error out if Module does not refer to the file in the prebuilt // module path. getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt) << ModuleName; ModuleBuildFailed = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } } a1450 1 } a1453 9 if (LoadFromPrebuiltModulePath) { // We can't rebuild the module without a module map. Since ReadAST // already produces diagnostics for these two cases, we simply // error out here. ModuleBuildFailed = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } d1504 1 a1505 6 if (LoadFromPrebuiltModulePath) getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) << ModuleFileName; // Fall through to error out. case ASTReader::VersionMismatch: d1583 4 d1601 1 a1601 1 return ModuleLoadResult::MissingExpected; d1635 1 a1635 1 LastModuleImportResult = ModuleLoadResult(Module); a1732 5 void CompilerInstance::setExternalSemaSource( IntrusiveRefCntPtr ESS) { ExternalSemaSrc = std::move(ESS); } @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @a31 1 #include "clang/Lex/PreprocessorOptions.h" a50 1 #include d58 1 a58 2 ModuleManager(nullptr), ThePCHContainerOperations(std::move(PCHContainerOps)), d66 2 a67 3 void CompilerInstance::setInvocation( std::shared_ptr Value) { Invocation = std::move(Value); d96 1 a96 3 void CompilerInstance::setPreprocessor(std::shared_ptr Value) { PP = std::move(Value); } d128 1 a128 1 ModuleManager = std::move(Reader); d138 1 a138 61 ModuleDepCollector = std::move(Collector); } static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr MDC) { SmallVector HeaderMapFileNames; HS.getHeaderMapFileNames(HeaderMapFileNames); for (auto &Name : HeaderMapFileNames) MDC->addFile(Name); } static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr MDC) { const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); if (PPOpts.ImplicitPCHInclude.empty()) return; StringRef PCHInclude = PPOpts.ImplicitPCHInclude; FileManager &FileMgr = CI.getFileManager(); const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude); if (!PCHDir) { MDC->addFile(PCHInclude); return; } std::error_code EC; SmallString<128> DirNative; llvm::sys::path::native(PCHDir->getName(), DirNative); vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem(); SimpleASTReaderListener Validator(CI.getPreprocessor()); for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not // used here since we're not interested in validating the PCH at this time, // but only to check whether this is a file containing an AST. if (!ASTReader::readASTFileControlBlock( Dir->getName(), FileMgr, CI.getPCHContainerReader(), /*FindModuleFileExtensions=*/false, Validator, /*ValidateDiagnosticOptions=*/false)) MDC->addFile(Dir->getName()); } } static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr MDC) { if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty()) return; // Collect all VFS found. SmallVector VFSEntries; for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) { llvm::ErrorOr> Buffer = llvm::MemoryBuffer::getFile(VFSFile); if (!Buffer) return; vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr, VFSFile, VFSEntries); } for (auto &E : VFSEntries) MDC->addFile(E.VPath, E.RPath); d305 8 a312 7 HeaderSearch *HeaderInfo = new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(), getDiagnostics(), getLangOpts(), &getTarget()); PP = std::make_shared( Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(), getSourceManager(), *HeaderInfo, *this, PTHMgr, /*OwnsHeaderSearch=*/true, TUKind); d334 1 a334 8 // Initialize the header search object. In CUDA compilations, we use the aux // triple (the host triple) to initialize our header search, since we need to // find the host headers in order to compile the CUDA code. const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple(); if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA && PP->getAuxTargetInfo()) HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple(); d336 1 a336 1 PP->getLangOpts(), *HeaderSearchTriple); d352 3 d357 1 a357 1 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) { a359 13 } // If there is a module dep collector, register with other dep collectors // and also (a) collect header maps and (b) TODO: input vfs overlay files. if (ModuleDepCollector) { addDependencyCollector(ModuleDepCollector); collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector); collectIncludePCH(*this, ModuleDepCollector); collectVFSEntries(*this, ModuleDepCollector); } for (auto &Listener : DependencyCollectors) Listener->attachToPreprocessor(*PP); d363 1 a363 1 AttachHeaderIncludeGen(*PP, DepOpts); d368 1 a368 1 AttachHeaderIncludeGen(*PP, DepOpts, d374 2 a375 2 AttachHeaderIncludeGen(*PP, DepOpts, /*ShowAllHeaders=*/true, /*OutputPath=*/"", d421 1 a421 1 ArrayRef> Extensions, d470 1 a470 1 StringRef Filename, d511 1 a511 2 FrontendTimerGroup.reset( new llvm::TimerGroup("frontend", "Clang front-end time report")); d513 1 a513 2 new llvm::Timer("frontend", "Clang front-end timer", *FrontendTimerGroup)); a533 5 // Attach the external sema source if there is any. if (ExternalSemaSrc) { TheSema->addExternalSource(ExternalSemaSrc.get()); ExternalSemaSrc->InitializeSema(*TheSema); } d539 1 d545 3 d567 1 d573 1 a573 1 std::unique_ptr d581 5 a585 2 std::unique_ptr CompilerInstance::createNullOutputFile() { return llvm::make_unique(); d588 1 a588 1 std::unique_ptr d604 1 d607 2 a608 2 addOutputFile( OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName)); d610 1 a610 1 return OS; d715 3 a717 4 return InitializeSourceManager( Input, getDiagnostics(), getFileManager(), getSourceManager(), hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr, getDependencyOutputOpts(), getFrontendOpts()); d720 5 a724 5 // static bool CompilerInstance::InitializeSourceManager( const FrontendInputFile &Input, DiagnosticsEngine &Diags, FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS, DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) { d740 1 a740 29 const FileEntry *File; if (Opts.FindPchSource.empty()) { File = FileMgr.getFile(InputFile, /*OpenFile=*/true); } else { // When building a pch file in clang-cl mode, the .h file is built as if // it was included by a cc file. Since the driver doesn't know about // all include search directories, the frontend must search the input // file through HeaderSearch here, as if it had been included by the // cc file at Opts.FindPchSource. const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource); if (!FindFile) { Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource; return false; } const DirectoryLookup *UnusedCurDir; SmallVector, 16> Includers; Includers.push_back(std::make_pair(FindFile, FindFile->getDir())); File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false, /*FromDir=*/nullptr, /*CurDir=*/UnusedCurDir, Includers, /*SearchPath=*/nullptr, /*RelativePath=*/nullptr, /*RequestingModule=*/nullptr, /*SuggestedModule=*/nullptr, /*SkipCache=*/true); // Also add the header to /showIncludes output. if (File) DepOpts.ShowIncludesPretendHeader = File->getName(); } d806 1 a806 1 auto TO = std::make_shared(); a807 1 TO->HostTriple = getTarget().getTriple().str(); a816 3 // Adjust target options based on codegen options. getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts()); d830 2 a831 2 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty()) llvm::EnableStatistics(false); d864 3 a866 18 if (getFrontendOpts().ShowStats) { if (hasFileManager()) { getFileManager().PrintStats(); OS << '\n'; } llvm::PrintStatistics(OS); } StringRef StatsFile = getFrontendOpts().StatsFile; if (!StatsFile.empty()) { std::error_code EC; auto StatS = llvm::make_unique(StatsFile, EC, llvm::sys::fs::F_Text); if (EC) { getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file) << StatsFile << EC.message(); } else { llvm::PrintStatisticsJSON(*StatS); } d895 2 a896 2 auto Invocation = std::make_shared(ImportingInstance.getInvocation()); d912 1 a912 2 return HSOpts.ModulesIgnoreMacros.count( llvm::CachedHashString(MacroDef.split('=').first)) > 0; d925 1 a925 2 ImportingPPOpts.FailedModules = std::make_shared(); d950 1 a950 2 auto &Inv = *Invocation; Instance.setInvocation(std::move(Invocation)); d972 1 a972 1 Inv.getDependencyOutputOpts() = DependencyOutputOptions(); d998 1 a998 1 GenerateModuleFromModuleMapAction CreateModuleAction( d1053 1 a1053 1 << Module->Name << Locked.getErrorMessage(); d1268 1 a1268 2 ReadTimer = llvm::make_unique("reading_modules", "Reading modules", d1293 2 d1303 1 a1303 2 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(), *FrontendTimerGroup); d1335 1 a1335 1 .findModule(II->getName())) { a1336 13 // Mark module as available if the only reason it was unavailable // was missing headers. SmallVector Stack; Stack.push_back(M); while (!Stack.empty()) { Module *Current = Stack.pop_back_val(); if (Current->IsMissingRequirement) continue; Current->IsAvailable = true; Stack.insert(Stack.end(), Current->submodule_begin(), Current->submodule_end()); } } d1389 2 a1390 1 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) d1404 2 a1405 1 } else if (ModuleName == getLangOpts().CurrentModule) { d1412 1 a1412 19 HeaderSearchOptions &HSOpts = PP->getHeaderSearchInfo().getHeaderSearchOpts(); std::string ModuleFileName; bool LoadFromPrebuiltModulePath = false; // We try to load the module from the prebuilt module paths. If not // successful, we then try to find it in the module cache. if (!HSOpts.PrebuiltModulePaths.empty()) { // Load the module from the prebuilt module path. ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName( ModuleName, "", /*UsePrebuiltPath*/ true); if (!ModuleFileName.empty()) LoadFromPrebuiltModulePath = true; } if (!LoadFromPrebuiltModulePath && Module) { // Load the module from the module cache. ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); } else if (!LoadFromPrebuiltModulePath) { // We can't find a module, error out here. d1420 2 d1423 1 a1423 1 if (Module && Module->HasIncompatibleModuleFile) { d1426 1 a1426 1 return ModuleLoadResult::ConfigMismatch; d1441 1 a1441 2 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName, *FrontendTimerGroup); d1444 2 a1445 6 // Try to load the module file. If we are trying to load from the prebuilt // module path, we don't have the module map files and don't know how to // rebuild modules. unsigned ARRFlags = LoadFromPrebuiltModulePath ? ASTReader::ARR_ConfigurationMismatch : ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; a1446 2 LoadFromPrebuiltModulePath ? serialization::MK_PrebuiltModule : d1448 2 a1449 16 ImportLoc, ARRFlags)) { case ASTReader::Success: { if (LoadFromPrebuiltModulePath && !Module) { Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); if (!Module || !Module->getASTFile() || FileMgr->getFile(ModuleFileName) != Module->getASTFile()) { // Error out if Module does not refer to the file in the prebuilt // module path. getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt) << ModuleName; ModuleBuildFailed = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } } a1450 1 } a1453 9 if (LoadFromPrebuiltModulePath) { // We can't rebuild the module without a module map. Since ReadAST // already produces diagnostics for these two cases, we simply // error out here. ModuleBuildFailed = true; KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); } d1504 1 a1505 6 if (LoadFromPrebuiltModulePath) getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) << ModuleFileName; // Fall through to error out. case ASTReader::VersionMismatch: d1583 4 d1601 1 a1601 1 return ModuleLoadResult::MissingExpected; d1635 1 a1635 1 LastModuleImportResult = ModuleLoadResult(Module); a1732 5 void CompilerInstance::setExternalSemaSource( IntrusiveRefCntPtr ESS) { ExternalSemaSrc = std::move(ESS); } @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @a13 1 #include "clang/Basic/CharInfo.h" a15 1 #include "clang/Basic/MemoryBufferCache.h" d58 6 a63 9 MemoryBufferCache *SharedPCMCache) : ModuleLoader(/* BuildingModule = */ SharedPCMCache), Invocation(new CompilerInvocation()), PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache), ThePCHContainerOperations(std::move(PCHContainerOps)) { // Don't allow this to invalidate buffers in use by others. if (SharedPCMCache) getPCMCache().finalizeCurrentBuffers(); } a133 2 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() && "Expected ASTReader to use the same PCM cache"); d376 1 a376 1 getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr, a493 2 TheDependencyFileGenerator.get(), DependencyCollectors, a503 2 DependencyFileGenerator *DependencyFile, ArrayRef> DependencyCollectors, d509 1 a509 1 PP, &Context, PCHContainerRdr, Extensions, a520 6 if (DependencyFile) DependencyFile->AttachToASTReader(*Reader); for (auto &Listener : DependencyCollectors) Listener->attachToASTReader(*Reader); a653 5 if (DeleteBuiltModules) { for (auto &Module : BuiltModules) llvm::sys::fs::remove(Module.second); BuiltModules.clear(); } d806 2 a807 5 SrcMgr::CharacteristicKind Kind = Input.getKind().getFormat() == InputKind::ModuleMap ? Input.isSystem() ? SrcMgr::C_System_ModuleMap : SrcMgr::C_User_ModuleMap : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; d845 1 a845 2 /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr, /*SkipCache=*/true); d913 2 a914 3 // Create TargetInfo for the other side of CUDA and OpenMP compilation. if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) && !getFrontendOpts().AuxTriple.empty()) { d1002 1 a1002 1 static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) { d1004 1 a1004 1 return InputKind::OpenCL; d1006 1 a1006 1 return InputKind::CUDA; d1008 2 a1009 2 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC; return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C; d1015 7 a1021 8 static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, StringRef ModuleName, FrontendInputFile Input, StringRef OriginalModuleMapFile, StringRef ModuleFileName, llvm::function_ref PreBuildStep = [](CompilerInstance &) {}, llvm::function_ref PostBuildStep = [](CompilerInstance &) {}) { d1035 1 a1035 1 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); d1046 1 a1046 1 Invocation->getLangOpts()->CurrentModule = ModuleName; d1066 2 a1067 4 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile; // Force implicitly-built modules to hash the content of the module file. HSOpts.ModulesHashContent = true; FrontendOpts.Inputs = {Input}; d1077 1 a1077 3 // module. Since we're sharing a PCMCache, // CompilerInstance::CompilerInstance is responsible for finalizing the // buffers to prevent use-after-frees. d1079 1 a1079 1 &ImportingInstance.getPreprocessor().getPCMCache()); d1096 1 a1096 1 SourceMgr.pushModuleBuildStack(ModuleName, d1105 27 d1134 1 a1134 3 << ModuleName << ModuleFileName; PreBuildStep(Instance); d1140 2 a1141 8 CRC.RunSafelyOnThread( [&]() { GenerateModuleFromModuleMapAction Action; Instance.ExecuteAction(Action); }, ThreadStackSize); PostBuildStep(Instance); d1145 1 a1145 1 << ModuleName; a1152 53 return !Instance.getDiagnostics().hasErrorOccurred(); } /// \brief Compile a module file for the given module, using the options /// provided by the importing compiler instance. Returns true if the module /// was built without errors. static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()), InputKind::ModuleMap); // Get or create the module map that we'll use to build this module. ModuleMap &ModMap = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); bool Result; if (const FileEntry *ModuleMapFile = ModMap.getContainingModuleMapFile(Module)) { // Use the module map where this module resides. Result = compileModuleImpl( ImportingInstance, ImportLoc, Module->getTopLevelModuleName(), FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem), ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName); } else { // FIXME: We only need to fake up an input file here as a way of // transporting the module's directory to the module map parser. We should // be able to do that more directly, and parse from a memory buffer without // inventing this file. SmallString<128> FakeModuleMapFile(Module->Directory->getName()); llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map"); std::string InferredModuleMapContent; llvm::raw_string_ostream OS(InferredModuleMapContent); Module->print(OS); OS.flush(); Result = compileModuleImpl( ImportingInstance, ImportLoc, Module->getTopLevelModuleName(), FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem), ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName, [&](CompilerInstance &Instance) { std::unique_ptr ModuleMapBuffer = llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); ModuleMapFile = Instance.getFileManager().getVirtualFile( FakeModuleMapFile, InferredModuleMapContent.size(), 0); Instance.getSourceManager().overrideFileContents( ModuleMapFile, std::move(ModuleMapBuffer)); }); } d1159 1 a1159 1 return Result; d1183 1 a1183 4 // PCMCache takes care of correctness and locks are only necessary for // performance. Fallback to building the module in case of any lock // related errors. Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure) d1185 2 a1186 3 // Clear out any potential leftover. Locked.unsafeRemoveLockFile(); // FALLTHROUGH d1206 1 a1206 4 // Since PCMCache takes care of correctness, we try waiting for another // process to complete the build so clang does not do it done twice. If // case of timeout, build it ourselves. Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout) d1210 1 a1210 1 continue; d1403 1 a1403 1 getPreprocessor(), &getASTContext(), getPCHContainerReader(), d1558 5 a1562 14 enum ModuleSource { ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma } Source = ModuleNotFound; // Check to see if the module has been built as part of this compilation // via a module build pragma. auto BuiltModuleIt = BuiltModules.find(ModuleName); if (BuiltModuleIt != BuiltModules.end()) { ModuleFileName = BuiltModuleIt->second; Source = ModuleBuildPragma; } // Try to load the module from the prebuilt module path. if (Source == ModuleNotFound && !HSOpts.PrebuiltModulePaths.empty()) { d1566 1 a1566 1 Source = PrebuiltModulePath; d1568 2 a1569 3 // Try to load the module from the module cache. if (Source == ModuleNotFound && Module) { d1571 1 a1571 4 Source = ModuleCache; } if (Source == ModuleNotFound) { d1574 2 a1575 1 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); d1603 6 a1608 5 // Try to load the module file. If we are not trying to load from the // module cache, we don't know how to rebuild modules. unsigned ARRFlags = Source == ModuleCache ? ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing : ASTReader::ARR_ConfigurationMismatch; d1610 5 a1614 6 Source == PrebuiltModulePath ? serialization::MK_PrebuiltModule : Source == ModuleBuildPragma ? serialization::MK_ExplicitModule : serialization::MK_ImplicitModule, ImportLoc, ARRFlags)) { d1616 1 a1616 1 if (Source != ModuleCache && !Module) { d1634 4 a1637 4 if (Source != ModuleCache) { // We don't know the desired configuration for this module and don't // necessarily even have a module map. Since ReadAST already produces // diagnostics for these two cases, we simply error out here. d1694 1 a1694 3 if (Source == PrebuiltModulePath) // FIXME: We shouldn't be setting HadFatalFailure below if we only // produce a warning here! a1698 1 LLVM_FALLTHROUGH; d1722 1 a1722 1 d1795 14 a1808 4 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(), getDiagnostics(), Module)) { getDiagnostics().Report(ImportLoc, diag::note_module_import_here) << SourceRange(Path.front().second, Path.back().second); a1828 53 void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) { // Avoid creating filenames with special characters. SmallString<128> CleanModuleName(ModuleName); for (auto &C : CleanModuleName) if (!isAlphanumeric(C)) C = '_'; // FIXME: Using a randomized filename here means that our intermediate .pcm // output is nondeterministic (as .pcm files refer to each other by name). // Can this affect the output in any way? SmallString<128> ModuleFileName; if (std::error_code EC = llvm::sys::fs::createTemporaryFile( CleanModuleName, "pcm", ModuleFileName)) { getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output) << ModuleFileName << EC.message(); return; } std::string ModuleMapFileName = (CleanModuleName + ".map").str(); FrontendInputFile Input( ModuleMapFileName, InputKind(getLanguageFromOptions(*Invocation->getLangOpts()), InputKind::ModuleMap, /*Preprocessed*/true)); std::string NullTerminatedSource(Source.str()); auto PreBuildStep = [&](CompilerInstance &Other) { // Create a virtual file containing our desired source. // FIXME: We shouldn't need to do this. const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile( ModuleMapFileName, NullTerminatedSource.size(), 0); Other.getSourceManager().overrideFileContents( ModuleMapFile, llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str())); Other.BuiltModules = std::move(BuiltModules); Other.DeleteBuiltModules = false; }; auto PostBuildStep = [this](CompilerInstance &Other) { BuiltModules = std::move(Other.BuiltModules); }; // Build the module, inheriting any modules that we've built locally. if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(), ModuleFileName, PreBuildStep, PostBuildStep)) { BuiltModules[ModuleName] = ModuleFileName.str(); llvm::sys::RemoveFileOnSignal(ModuleFileName); } } @ 1.1.1.11.4.1 log @Sync with HEAD @ text @a18 1 #include "clang/Basic/Stack.h" d303 1 a303 1 FileManager *CompilerInstance::createFileManager() { d305 2 a306 3 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()); setVirtualFileSystem(VFS); a308 1 return FileMgr.get(); a384 1 getTarget().adjust(getLangOpts()); d462 1 a462 1 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) { d762 2 a763 6 // Insert -%%%%%%%% before the extension (if any), and because some tools // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build // artifacts, also append .tmp. StringRef OutputExtension = llvm::sys::path::extension(OutFile); SmallString<128> TempPath = StringRef(OutFile).drop_back(OutputExtension.size()); a764 2 TempPath += OutputExtension; TempPath += ".tmp"; d835 2 a836 2 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned, Input.getBuffer(), Kind)); d846 30 a875 1 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); d1000 2 a1001 11 if (NumWarnings || NumErrors) { OS << " generated"; if (getLangOpts().CUDA) { if (!getLangOpts().CUDAIsDevice) { OS << " when compiling for host"; } else { OS << " when compiling for " << getTargetOpts().CPU; } } OS << ".\n"; } d1027 1 a1027 1 /// Determine the appropriate source input kind based on language d1039 1 a1039 1 /// Compile a module file for the given module, using the options a1072 4 // If the original compiler invocation had -fmodule-name, pass it through. Invocation->getLangOpts()->ModuleName = ImportingInstance.getInvocation().getLangOpts()->ModuleName; d1145 1 d1152 1 a1152 1 DesiredStackSize); d1169 1 a1169 14 static const FileEntry *getPublicModuleMap(const FileEntry *File, FileManager &FileMgr) { StringRef Filename = llvm::sys::path::filename(File->getName()); SmallString<128> PublicFilename(File->getDir()->getName()); if (Filename == "module_private.map") llvm::sys::path::append(PublicFilename, "module.map"); else if (Filename == "module.private.modulemap") llvm::sys::path::append(PublicFilename, "module.modulemap"); else return nullptr; return FileMgr.getFile(PublicFilename); } /// Compile a module file for the given module, using the options a1184 7 // Canonicalize compilation to start with the public module map. This is // vital for submodules declarations in the private module maps to be // correctly parsed when depending on a top level module in the public one. if (const FileEntry *PublicMMFile = getPublicModuleMap( ModuleMapFile, ImportingInstance.getFileManager())) ModuleMapFile = PublicMMFile; d1281 1 a1281 1 // Clear the lock file so that future invocations can make progress. d1311 1 a1311 1 /// Diagnose differences between the current definition of the given d1369 1 a1369 1 /// Write a new timestamp file with the given path. d1375 1 a1375 1 /// Prune the module cache of modules that haven't been accessed in a1562 7 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the // ASTReader to diagnose it, since it can produce better errors that we can. bool ConfigMismatchIsRecoverable = getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch, SourceLocation()) <= DiagnosticsEngine::Warning; d1569 3 a1571 3 switch (ModuleManager->ReadAST( FileName, serialization::MK_ExplicitModule, SourceLocation(), ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) { d1598 1 a1598 16 // FIXME: Should we be deciding whether this is a submodule (here and // below) based on -fmodules-ts or should we pass a flag and make the // caller decide? std::string ModuleName; if (getLangOpts().ModulesTS) { // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a // better place/way to do this. for (auto &Piece : Path) { if (!ModuleName.empty()) ModuleName += "."; ModuleName += Piece.first->getName(); } } else ModuleName = Path[0].first->getName(); a1622 8 /// FIXME: perhaps we should (a) look for a module using the module name // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found? //if (Module == nullptr) { // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) // << ModuleName; // ModuleBuildFailed = true; // return ModuleLoadResult(); //} d1644 3 a1646 4 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() || !HSOpts.PrebuiltModulePaths.empty())) { ModuleFileName = PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName); d1653 1 a1653 1 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module); d1813 1 a1813 2 bool MapPrivateSubModToTopLevel = false; if (!getLangOpts().ModulesTS && Path.size() > 1) { a1816 33 // If the user is requesting Foo.Private and it doesn't exist, try to // match Foo_Private and emit a warning asking for the user to write // @@import Foo_Private instead. FIXME: remove this when existing clients // migrate off of Foo.Private syntax. if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" && Module == Module->getTopLevelModule()) { SmallString<128> PrivateModule(Module->Name); PrivateModule.append("_Private"); SmallVector, 2> PrivPath; auto &II = PP->getIdentifierTable().get( PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID()); PrivPath.push_back(std::make_pair(&II, Path[0].second)); if (PP->getHeaderSearchInfo().lookupModule(PrivateModule)) Sub = loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective); if (Sub) { MapPrivateSubModToTopLevel = true; if (!getDiagnostics().isIgnored( diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) { getDiagnostics().Report(Path[I].second, diag::warn_no_priv_submodule_use_toplevel) << Path[I].first << Module->getFullModuleName() << PrivateModule << SourceRange(Path[0].second, Path[I].second) << FixItHint::CreateReplacement(SourceRange(Path[0].second), PrivateModule); getDiagnostics().Report(Sub->DefinitionLoc, diag::note_private_top_level_defined); } } } d1851 1 a1851 1 d1868 1 a1868 1 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) { a1901 6 // Resolve any remaining module using export_as for this one. getPreprocessor() .getHeaderSearchInfo() .getModuleMap() .resolveLinkAsDependencies(TopModule); @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @a18 1 #include "clang/Basic/Stack.h" d303 1 a303 1 FileManager *CompilerInstance::createFileManager() { d305 2 a306 3 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()); setVirtualFileSystem(VFS); a308 1 return FileMgr.get(); a384 1 getTarget().adjust(getLangOpts()); d462 1 a462 1 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) { d762 2 a763 6 // Insert -%%%%%%%% before the extension (if any), and because some tools // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build // artifacts, also append .tmp. StringRef OutputExtension = llvm::sys::path::extension(OutFile); SmallString<128> TempPath = StringRef(OutFile).drop_back(OutputExtension.size()); a764 2 TempPath += OutputExtension; TempPath += ".tmp"; d835 2 a836 2 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned, Input.getBuffer(), Kind)); d846 30 a875 1 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); d1000 2 a1001 11 if (NumWarnings || NumErrors) { OS << " generated"; if (getLangOpts().CUDA) { if (!getLangOpts().CUDAIsDevice) { OS << " when compiling for host"; } else { OS << " when compiling for " << getTargetOpts().CPU; } } OS << ".\n"; } d1027 1 a1027 1 /// Determine the appropriate source input kind based on language d1039 1 a1039 1 /// Compile a module file for the given module, using the options a1072 4 // If the original compiler invocation had -fmodule-name, pass it through. Invocation->getLangOpts()->ModuleName = ImportingInstance.getInvocation().getLangOpts()->ModuleName; d1145 1 d1152 1 a1152 1 DesiredStackSize); d1169 1 a1169 14 static const FileEntry *getPublicModuleMap(const FileEntry *File, FileManager &FileMgr) { StringRef Filename = llvm::sys::path::filename(File->getName()); SmallString<128> PublicFilename(File->getDir()->getName()); if (Filename == "module_private.map") llvm::sys::path::append(PublicFilename, "module.map"); else if (Filename == "module.private.modulemap") llvm::sys::path::append(PublicFilename, "module.modulemap"); else return nullptr; return FileMgr.getFile(PublicFilename); } /// Compile a module file for the given module, using the options a1184 7 // Canonicalize compilation to start with the public module map. This is // vital for submodules declarations in the private module maps to be // correctly parsed when depending on a top level module in the public one. if (const FileEntry *PublicMMFile = getPublicModuleMap( ModuleMapFile, ImportingInstance.getFileManager())) ModuleMapFile = PublicMMFile; d1281 1 a1281 1 // Clear the lock file so that future invocations can make progress. d1311 1 a1311 1 /// Diagnose differences between the current definition of the given d1369 1 a1369 1 /// Write a new timestamp file with the given path. d1375 1 a1375 1 /// Prune the module cache of modules that haven't been accessed in a1562 7 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the // ASTReader to diagnose it, since it can produce better errors that we can. bool ConfigMismatchIsRecoverable = getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch, SourceLocation()) <= DiagnosticsEngine::Warning; d1569 3 a1571 3 switch (ModuleManager->ReadAST( FileName, serialization::MK_ExplicitModule, SourceLocation(), ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) { d1598 1 a1598 16 // FIXME: Should we be deciding whether this is a submodule (here and // below) based on -fmodules-ts or should we pass a flag and make the // caller decide? std::string ModuleName; if (getLangOpts().ModulesTS) { // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a // better place/way to do this. for (auto &Piece : Path) { if (!ModuleName.empty()) ModuleName += "."; ModuleName += Piece.first->getName(); } } else ModuleName = Path[0].first->getName(); a1622 8 /// FIXME: perhaps we should (a) look for a module using the module name // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found? //if (Module == nullptr) { // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) // << ModuleName; // ModuleBuildFailed = true; // return ModuleLoadResult(); //} d1644 3 a1646 4 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() || !HSOpts.PrebuiltModulePaths.empty())) { ModuleFileName = PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName); d1653 1 a1653 1 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module); d1813 1 a1813 2 bool MapPrivateSubModToTopLevel = false; if (!getLangOpts().ModulesTS && Path.size() > 1) { a1816 33 // If the user is requesting Foo.Private and it doesn't exist, try to // match Foo_Private and emit a warning asking for the user to write // @@import Foo_Private instead. FIXME: remove this when existing clients // migrate off of Foo.Private syntax. if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" && Module == Module->getTopLevelModule()) { SmallString<128> PrivateModule(Module->Name); PrivateModule.append("_Private"); SmallVector, 2> PrivPath; auto &II = PP->getIdentifierTable().get( PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID()); PrivPath.push_back(std::make_pair(&II, Path[0].second)); if (PP->getHeaderSearchInfo().lookupModule(PrivateModule)) Sub = loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective); if (Sub) { MapPrivateSubModToTopLevel = true; if (!getDiagnostics().isIgnored( diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) { getDiagnostics().Report(Path[I].second, diag::warn_no_priv_submodule_use_toplevel) << Path[I].first << Module->getFullModuleName() << PrivateModule << SourceRange(Path[0].second, Path[I].second) << FixItHint::CreateReplacement(SourceRange(Path[0].second), PrivateModule); getDiagnostics().Report(Sub->DefinitionLoc, diag::note_private_top_level_defined); } } } d1851 1 a1851 1 d1868 1 a1868 1 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) { a1901 6 // Resolve any remaining module using export_as for this one. getPreprocessor() .getHeaderSearchInfo() .getModuleMap() .resolveLinkAsDependencies(TopModule); @ 1.1.1.12 log @Import clang r337282 from trunk @ text @a18 1 #include "clang/Basic/Stack.h" d303 1 a303 1 FileManager *CompilerInstance::createFileManager() { d305 2 a306 3 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()); setVirtualFileSystem(VFS); a308 1 return FileMgr.get(); a384 1 getTarget().adjust(getLangOpts()); d462 1 a462 1 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) { d762 2 a763 6 // Insert -%%%%%%%% before the extension (if any), and because some tools // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build // artifacts, also append .tmp. StringRef OutputExtension = llvm::sys::path::extension(OutFile); SmallString<128> TempPath = StringRef(OutFile).drop_back(OutputExtension.size()); a764 2 TempPath += OutputExtension; TempPath += ".tmp"; d835 2 a836 2 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned, Input.getBuffer(), Kind)); d846 30 a875 1 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); d1000 2 a1001 11 if (NumWarnings || NumErrors) { OS << " generated"; if (getLangOpts().CUDA) { if (!getLangOpts().CUDAIsDevice) { OS << " when compiling for host"; } else { OS << " when compiling for " << getTargetOpts().CPU; } } OS << ".\n"; } d1027 1 a1027 1 /// Determine the appropriate source input kind based on language d1039 1 a1039 1 /// Compile a module file for the given module, using the options a1072 4 // If the original compiler invocation had -fmodule-name, pass it through. Invocation->getLangOpts()->ModuleName = ImportingInstance.getInvocation().getLangOpts()->ModuleName; d1145 1 d1152 1 a1152 1 DesiredStackSize); d1169 1 a1169 14 static const FileEntry *getPublicModuleMap(const FileEntry *File, FileManager &FileMgr) { StringRef Filename = llvm::sys::path::filename(File->getName()); SmallString<128> PublicFilename(File->getDir()->getName()); if (Filename == "module_private.map") llvm::sys::path::append(PublicFilename, "module.map"); else if (Filename == "module.private.modulemap") llvm::sys::path::append(PublicFilename, "module.modulemap"); else return nullptr; return FileMgr.getFile(PublicFilename); } /// Compile a module file for the given module, using the options a1184 7 // Canonicalize compilation to start with the public module map. This is // vital for submodules declarations in the private module maps to be // correctly parsed when depending on a top level module in the public one. if (const FileEntry *PublicMMFile = getPublicModuleMap( ModuleMapFile, ImportingInstance.getFileManager())) ModuleMapFile = PublicMMFile; d1281 1 a1281 1 // Clear the lock file so that future invocations can make progress. d1311 1 a1311 1 /// Diagnose differences between the current definition of the given d1369 1 a1369 1 /// Write a new timestamp file with the given path. d1375 1 a1375 1 /// Prune the module cache of modules that haven't been accessed in a1562 7 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the // ASTReader to diagnose it, since it can produce better errors that we can. bool ConfigMismatchIsRecoverable = getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch, SourceLocation()) <= DiagnosticsEngine::Warning; d1569 3 a1571 3 switch (ModuleManager->ReadAST( FileName, serialization::MK_ExplicitModule, SourceLocation(), ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) { d1598 1 a1598 16 // FIXME: Should we be deciding whether this is a submodule (here and // below) based on -fmodules-ts or should we pass a flag and make the // caller decide? std::string ModuleName; if (getLangOpts().ModulesTS) { // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a // better place/way to do this. for (auto &Piece : Path) { if (!ModuleName.empty()) ModuleName += "."; ModuleName += Piece.first->getName(); } } else ModuleName = Path[0].first->getName(); a1622 8 /// FIXME: perhaps we should (a) look for a module using the module name // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found? //if (Module == nullptr) { // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) // << ModuleName; // ModuleBuildFailed = true; // return ModuleLoadResult(); //} d1644 3 a1646 4 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() || !HSOpts.PrebuiltModulePaths.empty())) { ModuleFileName = PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName); d1653 1 a1653 1 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module); d1813 1 a1813 2 bool MapPrivateSubModToTopLevel = false; if (!getLangOpts().ModulesTS && Path.size() > 1) { a1816 33 // If the user is requesting Foo.Private and it doesn't exist, try to // match Foo_Private and emit a warning asking for the user to write // @@import Foo_Private instead. FIXME: remove this when existing clients // migrate off of Foo.Private syntax. if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" && Module == Module->getTopLevelModule()) { SmallString<128> PrivateModule(Module->Name); PrivateModule.append("_Private"); SmallVector, 2> PrivPath; auto &II = PP->getIdentifierTable().get( PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID()); PrivPath.push_back(std::make_pair(&II, Path[0].second)); if (PP->getHeaderSearchInfo().lookupModule(PrivateModule)) Sub = loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective); if (Sub) { MapPrivateSubModToTopLevel = true; if (!getDiagnostics().isIgnored( diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) { getDiagnostics().Report(Path[I].second, diag::warn_no_priv_submodule_use_toplevel) << Path[I].first << Module->getFullModuleName() << PrivateModule << SourceRange(Path[0].second, Path[I].second) << FixItHint::CreateReplacement(SourceRange(Path[0].second), PrivateModule); getDiagnostics().Report(Sub->DefinitionLoc, diag::note_private_top_level_defined); } } } d1851 1 a1851 1 d1868 1 a1868 1 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) { a1901 6 // Resolve any remaining module using export_as for this one. getPreprocessor() .getHeaderSearchInfo() .getModuleMap() .resolveLinkAsDependencies(TopModule); @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file CompilerInstance.cpp was added on branch tls-maxphys on 2014-08-19 23:47:28 +0000 @ text @d1 1611 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1611 //===--- CompilerInstance.cpp ---------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/Frontend/CompilerInstance.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/Version.h" #include "clang/Config/config.h" #include "clang/Frontend/ChainedDiagnosticConsumer.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/LogDiagnosticPrinter.h" #include "clang/Frontend/SerializedDiagnosticPrinter.h" #include "clang/Frontend/TextDiagnosticPrinter.h" #include "clang/Frontend/Utils.h" #include "clang/Frontend/VerifyDiagnosticConsumer.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/PTHManager.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "clang/Serialization/GlobalModuleIndex.h" #include "llvm/ADT/Statistic.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/Errc.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Host.h" #include "llvm/Support/LockFileManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/Program.h" #include "llvm/Support/Signals.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include #include #include using namespace clang; CompilerInstance::CompilerInstance(bool BuildingModule) : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()), ModuleManager(nullptr), BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), ModuleBuildFailed(false) { } CompilerInstance::~CompilerInstance() { assert(OutputFiles.empty() && "Still output files in flight?"); } void CompilerInstance::setInvocation(CompilerInvocation *Value) { Invocation = Value; } bool CompilerInstance::shouldBuildGlobalModuleIndex() const { return (BuildGlobalModuleIndex || (ModuleManager && ModuleManager->isGlobalIndexUnavailable() && getFrontendOpts().GenerateGlobalModuleIndex)) && !ModuleBuildFailed; } void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { Diagnostics = Value; } void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; } void CompilerInstance::setFileManager(FileManager *Value) { FileMgr = Value; if (Value) VirtualFileSystem = Value->getVirtualFileSystem(); else VirtualFileSystem.reset(); } void CompilerInstance::setSourceManager(SourceManager *Value) { SourceMgr = Value; } void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } void CompilerInstance::setSema(Sema *S) { TheSema.reset(S); } void CompilerInstance::setASTConsumer(ASTConsumer *Value) { Consumer.reset(Value); } void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { CompletionConsumer.reset(Value); } IntrusiveRefCntPtr CompilerInstance::getModuleManager() const { return ModuleManager; } void CompilerInstance::setModuleManager(IntrusiveRefCntPtr Reader) { ModuleManager = Reader; } std::shared_ptr CompilerInstance::getModuleDepCollector() const { return ModuleDepCollector; } void CompilerInstance::setModuleDepCollector( std::shared_ptr Collector) { ModuleDepCollector = Collector; } // Diagnostics static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags) { std::string ErrorInfo; bool OwnsStream = false; raw_ostream *OS = &llvm::errs(); if (DiagOpts->DiagnosticLogFile != "-") { // Create the output stream. llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream( DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo, llvm::sys::fs::F_Append | llvm::sys::fs::F_Text)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) << DiagOpts->DiagnosticLogFile << ErrorInfo; } else { FileOS->SetUnbuffered(); FileOS->SetUseAtomicWrites(true); OS = FileOS; OwnsStream = true; } } // Chain in the diagnostic client which will log the diagnostics. LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, OwnsStream); if (CodeGenOpts) Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); } static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile) { std::string ErrorInfo; std::unique_ptr OS; OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_None)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_serialized_diag_failure) << OutputFile << ErrorInfo; return; } DiagnosticConsumer *SerializedConsumer = clang::serialized_diags::create(OS.release(), DiagOpts); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), SerializedConsumer)); } void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, bool ShouldOwnClient) { Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient, &getCodeGenOpts()); } IntrusiveRefCntPtr CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient, const CodeGenOptions *CodeGenOpts) { IntrusiveRefCntPtr DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr Diags(new DiagnosticsEngine(DiagID, Opts)); // Create the diagnostic client for reporting errors or for // implementing -verify. if (Client) { Diags->setClient(Client, ShouldOwnClient); } else Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); // Chain in -verify checker, if requested. if (Opts->VerifyDiagnostics) Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); // Chain in -diagnostic-log-file dumper, if requested. if (!Opts->DiagnosticLogFile.empty()) SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); if (!Opts->DiagnosticSerializationFile.empty()) SetupSerializedDiagnostics(Opts, *Diags, Opts->DiagnosticSerializationFile); // Configure our handling of diagnostics. ProcessWarningOptions(*Diags, *Opts); return Diags; } // File Manager void CompilerInstance::createFileManager() { if (!hasVirtualFileSystem()) { // TODO: choose the virtual file system based on the CompilerInvocation. setVirtualFileSystem(vfs::getRealFileSystem()); } FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem); } // Source Manager void CompilerInstance::createSourceManager(FileManager &FileMgr) { SourceMgr = new SourceManager(getDiagnostics(), FileMgr); } // Initialize the remapping of files to alternative contents, e.g., // those specified through other files. static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts) { // Remap files in the source manager (with buffers). for (const auto &RB : InitOpts.RemappedFileBuffers) { // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first; if (!InitOpts.RetainRemappedFileBuffers) delete RB.second; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, RB.second, InitOpts.RetainRemappedFileBuffers); } // Remap files in the source manager (with other files). for (const auto &RF : InitOpts.RemappedFiles) { // Find the file that we're mapping to. const FileEntry *ToFile = FileMgr.getFile(RF.second); if (!ToFile) { Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second; continue; } // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, ToFile); } SourceMgr.setOverridenFilesKeepOriginalName( InitOpts.RemappedFilesKeepOriginalName); } // Preprocessor void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { const PreprocessorOptions &PPOpts = getPreprocessorOpts(); // Create a PTH manager if we are using some form of a token cache. PTHManager *PTHMgr = nullptr; if (!PPOpts.TokenCache.empty()) PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); // Create the Preprocessor. HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(), getSourceManager(), getDiagnostics(), getLangOpts(), &getTarget()); PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(), getSourceManager(), *HeaderInfo, *this, PTHMgr, /*OwnsHeaderSearch=*/true, TUKind); PP->Initialize(getTarget()); // Note that this is different then passing PTHMgr to Preprocessor's ctor. // That argument is used as the IdentifierInfoLookup argument to // IdentifierTable's ctor. if (PTHMgr) { PTHMgr->setPreprocessor(&*PP); PP->setPTHManager(PTHMgr); } if (PPOpts.DetailedRecord) PP->createPreprocessingRecord(); // Apply remappings to the source manager. InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(), PP->getFileManager(), PPOpts); // Predefine macros and configure the preprocessor. InitializePreprocessor(*PP, PPOpts, getFrontendOpts()); // Initialize the header search object. ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(), PP->getLangOpts(), PP->getTargetInfo().getTriple()); PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP); // Set up the module path, including the hash for the // module-creation options. SmallString<256> SpecificModuleCache( getHeaderSearchOpts().ModuleCachePath); if (!getHeaderSearchOpts().DisableModuleHash) llvm::sys::path::append(SpecificModuleCache, getInvocation().getModuleHash()); PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache); // Handle generating dependencies, if requested. const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); if (!DepOpts.OutputFile.empty()) TheDependencyFileGenerator.reset( DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts)); if (!DepOpts.DOTOutputFile.empty()) AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, getHeaderSearchOpts().Sysroot); for (auto &Listener : DependencyCollectors) Listener->attachToPreprocessor(*PP); // If we don't have a collector, but we are collecting module dependencies, // then we're the top level compiler instance and need to create one. if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) ModuleDepCollector = std::make_shared( DepOpts.ModuleDependencyOutputDir); // Handle generating header include information, if requested. if (DepOpts.ShowHeaderIncludes) AttachHeaderIncludeGen(*PP); if (!DepOpts.HeaderIncludeOutputFile.empty()) { StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; if (OutputPath == "-") OutputPath = ""; AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, /*ShowDepth=*/false); } if (DepOpts.PrintShowIncludes) { AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"", /*ShowDepth=*/true, /*MSStyle=*/true); } } // ASTContext void CompilerInstance::createASTContext() { Preprocessor &PP = getPreprocessor(); Context = new ASTContext(getLangOpts(), PP.getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); Context->InitBuiltinTypes(getTarget()); } // ExternalASTSource void CompilerInstance::createPCHExternalASTSource( StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener) { IntrusiveRefCntPtr Source; bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; Source = createPCHExternalASTSource( Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), DeserializationListener, OwnDeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex); ModuleManager = static_cast(Source.get()); getASTContext().setExternalSource(Source); } ExternalASTSource *CompilerInstance::createPCHExternalASTSource( StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, void *DeserializationListener, bool OwnDeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); std::unique_ptr Reader; Reader.reset(new ASTReader(PP, Context, Sysroot.empty() ? "" : Sysroot.c_str(), DisablePCHValidation, AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/false, HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex)); Reader->setDeserializationListener( static_cast(DeserializationListener), /*TakeOwnership=*/OwnDeserializationListener); switch (Reader->ReadAST(Path, Preamble ? serialization::MK_Preamble : serialization::MK_PCH, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: // Set the predefines buffer as suggested by the PCH reader. Typically, the // predefines buffer will be empty. PP.setPredefines(Reader->getSuggestedPredefines()); return Reader.release(); case ASTReader::Failure: // Unrecoverable failure: don't even try to process the input file. break; case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: // No suitable PCH file could be found. Return an error. break; } return nullptr; } // Code Completion static bool EnableCodeCompletion(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column) { // Tell the source manager to chop off the given file at a specific // line and column. const FileEntry *Entry = PP.getFileManager().getFile(Filename); if (!Entry) { PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) << Filename; return true; } // Truncate the named file at the given line/column. PP.SetCodeCompletionPoint(Entry, Line, Column); return false; } void CompilerInstance::createCodeCompletionConsumer() { const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; if (!CompletionConsumer) { setCodeCompletionConsumer( createCodeCompletionConsumer(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column, getFrontendOpts().CodeCompleteOpts, llvm::outs())); if (!CompletionConsumer) return; } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column)) { setCodeCompletionConsumer(nullptr); return; } if (CompletionConsumer->isOutputBinary() && llvm::sys::ChangeStdoutToBinary()) { getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); setCodeCompletionConsumer(nullptr); } } void CompilerInstance::createFrontendTimer() { FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); } CodeCompleteConsumer * CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column, const CodeCompleteOptions &Opts, raw_ostream &OS) { if (EnableCodeCompletion(PP, Filename, Line, Column)) return nullptr; // Set up the creation routine for code-completion. return new PrintingCodeCompleteConsumer(Opts, OS); } void CompilerInstance::createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer) { TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), TUKind, CompletionConsumer)); } // Output Files void CompilerInstance::addOutputFile(const OutputFile &OutFile) { assert(OutFile.OS && "Attempt to add empty stream to output list!"); OutputFiles.push_back(OutFile); } void CompilerInstance::clearOutputFiles(bool EraseFiles) { for (std::list::iterator it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { delete it->OS; if (!it->TempFilename.empty()) { if (EraseFiles) { llvm::sys::fs::remove(it->TempFilename); } else { SmallString<128> NewOutFile(it->Filename); // If '-working-directory' was passed, the output filename should be // relative to that. FileMgr->FixupRelativePath(NewOutFile); if (std::error_code ec = llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) { getDiagnostics().Report(diag::err_unable_to_rename_temp) << it->TempFilename << it->Filename << ec.message(); llvm::sys::fs::remove(it->TempFilename); } } } else if (!it->Filename.empty() && EraseFiles) llvm::sys::fs::remove(it->Filename); } OutputFiles.clear(); } llvm::raw_fd_ostream * CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile, StringRef Extension) { return createOutputFile(getFrontendOpts().OutputFile, Binary, /*RemoveFileOnSignal=*/true, InFile, Extension, /*UseTemporary=*/true); } llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() { llvm::raw_null_ostream *OS = new llvm::raw_null_ostream(); addOutputFile(OutputFile("", "", OS)); return OS; } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories) { std::string Error, OutputPathName, TempPathName; llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, RemoveFileOnSignal, InFile, Extension, UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName); if (!OS) { getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath << Error; return nullptr; } // Add the output file -- but don't try to remove "-", since this means we are // using stdin. addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName, OS)); return OS; } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, std::string &Error, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories, std::string *ResultPathName, std::string *TempPathName) { assert((!CreateMissingDirectories || UseTemporary) && "CreateMissingDirectories is only allowed when using temporary files"); std::string OutFile, TempFile; if (!OutputPath.empty()) { OutFile = OutputPath; } else if (InFile == "-") { OutFile = "-"; } else if (!Extension.empty()) { SmallString<128> Path(InFile); llvm::sys::path::replace_extension(Path, Extension); OutFile = Path.str(); } else { OutFile = "-"; } std::unique_ptr OS; std::string OSFile; if (UseTemporary) { if (OutFile == "-") UseTemporary = false; else { llvm::sys::fs::file_status Status; llvm::sys::fs::status(OutputPath, Status); if (llvm::sys::fs::exists(Status)) { // Fail early if we can't write to the final destination. if (!llvm::sys::fs::can_write(OutputPath)) return nullptr; // Don't use a temporary if the output is a special file. This handles // things like '-o /dev/null' if (!llvm::sys::fs::is_regular_file(Status)) UseTemporary = false; } } } if (UseTemporary) { // Create a temporary file. SmallString<128> TempPath; TempPath = OutFile; TempPath += "-%%%%%%%%"; int fd; std::error_code EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); if (CreateMissingDirectories && EC == llvm::errc::no_such_file_or_directory) { StringRef Parent = llvm::sys::path::parent_path(OutputPath); EC = llvm::sys::fs::create_directories(Parent); if (!EC) { EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); } } if (!EC) { OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); OSFile = TempFile = TempPath.str(); } // If we failed to create the temporary, fallback to writing to the file // directly. This handles the corner case where we cannot write to the // directory, but can write to the file. } if (!OS) { OSFile = OutFile; OS.reset(new llvm::raw_fd_ostream( OSFile.c_str(), Error, (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text))); if (!Error.empty()) return nullptr; } // Make sure the out stream file gets removed if we crash. if (RemoveFileOnSignal) llvm::sys::RemoveFileOnSignal(OSFile); if (ResultPathName) *ResultPathName = OutFile; if (TempPathName) *TempPathName = TempFile; return OS.release(); } // Initialization Utilities bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ return InitializeSourceManager(Input, getDiagnostics(), getFileManager(), getSourceManager(), getFrontendOpts()); } bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, DiagnosticsEngine &Diags, FileManager &FileMgr, SourceManager &SourceMgr, const FrontendOptions &Opts) { SrcMgr::CharacteristicKind Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; if (Input.isBuffer()) { SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind)); assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } StringRef InputFile = Input.getFile(); // Figure out where to get and map in the main file. if (InputFile != "-") { const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); if (!File) { Diags.Report(diag::err_fe_error_reading) << InputFile; return false; } // The natural SourceManager infrastructure can't currently handle named // pipes, but we would at least like to accept them for the main // file. Detect them here, read them with the volatile flag so FileMgr will // pick up the correct size, and simply override their contents as we do for // STDIN. if (File->isNamedPipe()) { std::string ErrorStr; if (llvm::MemoryBuffer *MB = FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) { // Create a new virtual file that will have the correct size. File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0); SourceMgr.overrideFileContents(File, MB); } else { Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr; return false; } } SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); } else { llvm::ErrorOr> SBOrErr = llvm::MemoryBuffer::getSTDIN(); if (std::error_code EC = SBOrErr.getError()) { Diags.Report(diag::err_fe_error_reading_stdin) << EC.message(); return false; } std::unique_ptr SB = std::move(SBOrErr.get()); const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), SB->getBufferSize(), 0); SourceMgr.setMainFileID( SourceMgr.createFileID(File, SourceLocation(), Kind)); SourceMgr.overrideFileContents(File, SB.release()); } assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } // High-Level Operations bool CompilerInstance::ExecuteAction(FrontendAction &Act) { assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); // FIXME: Take this as an argument, once all the APIs we used have moved to // taking it as an input instead of hard-coding llvm::errs. raw_ostream &OS = llvm::errs(); // Create the target instance. setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getInvocation().TargetOpts)); if (!hasTarget()) return false; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. getTarget().adjust(getLangOpts()); // rewriter project will change target built-in bool type from its default. if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) getTarget().noSignedCharForObjCBool(); // Validate/process some options. if (getHeaderSearchOpts().Verbose) OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon " << BACKEND_PACKAGE_STRING << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; if (getFrontendOpts().ShowTimers) createFrontendTimer(); if (getFrontendOpts().ShowStats) llvm::EnableStatistics(); for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { // Reset the ID tables if we are reusing the SourceManager. if (hasSourceManager()) getSourceManager().clearIDTables(); if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { Act.Execute(); Act.EndSourceFile(); } } // Notify the diagnostic client that all files were processed. getDiagnostics().getClient()->finish(); if (getDiagnosticOpts().ShowCarets) { // We can have multiple diagnostics sharing one diagnostic client. // Get the total number of warnings/errors from the client. unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); if (NumWarnings) OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); if (NumWarnings && NumErrors) OS << " and "; if (NumErrors) OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); if (NumWarnings || NumErrors) OS << " generated.\n"; } if (getFrontendOpts().ShowStats && hasFileManager()) { getFileManager().PrintStats(); OS << "\n"; } return !getDiagnostics().getClient()->getNumErrors(); } /// \brief Determine the appropriate source input kind based on language /// options. static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { if (LangOpts.OpenCL) return IK_OpenCL; if (LangOpts.CUDA) return IK_CUDA; if (LangOpts.ObjC1) return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; return LangOpts.CPlusPlus? IK_CXX : IK_C; } /// \brief Compile a module file for the given module, using the options /// provided by the importing compiler instance. Returns true if the module /// was built without errors. static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { ModuleMap &ModMap = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); // Construct a compiler invocation for creating this module. IntrusiveRefCntPtr Invocation (new CompilerInvocation(ImportingInstance.getInvocation())); PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); // For any options that aren't intended to affect how a module is built, // reset them to their default values. Invocation->getLangOpts()->resetNonModularOptions(); PPOpts.resetNonModularOptions(); // Remove any macro definitions that are explicitly ignored by the module. // They aren't supposed to affect how the module is built anyway. const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); PPOpts.Macros.erase( std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), [&HSOpts](const std::pair &def) { StringRef MacroDef = def.first; return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; }), PPOpts.Macros.end()); // Note the name of the module we're building. Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); // Make sure that the failed-module structure has been allocated in // the importing instance, and propagate the pointer to the newly-created // instance. PreprocessorOptions &ImportingPPOpts = ImportingInstance.getInvocation().getPreprocessorOpts(); if (!ImportingPPOpts.FailedModules) ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet; PPOpts.FailedModules = ImportingPPOpts.FailedModules; // If there is a module map file, build the module using the module map. // Set up the inputs/outputs so that we build the module from its umbrella // header. FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); FrontendOpts.OutputFile = ModuleFileName.str(); FrontendOpts.DisableFree = false; FrontendOpts.GenerateGlobalModuleIndex = false; FrontendOpts.Inputs.clear(); InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); // Don't free the remapped file buffers; they are owned by our caller. PPOpts.RetainRemappedFileBuffers = true; Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; assert(ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"); // Construct a compiler instance that will be used to actually create the // module. CompilerInstance Instance(/*BuildingModule=*/true); Instance.setInvocation(&*Invocation); Instance.createDiagnostics(new ForwardingDiagnosticConsumer( ImportingInstance.getDiagnosticClient()), /*ShouldOwnClient=*/true); Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem()); // Note that this module is part of the module build stack, so that we // can detect cycles in the module graph. Instance.setFileManager(&ImportingInstance.getFileManager()); Instance.createSourceManager(Instance.getFileManager()); SourceManager &SourceMgr = Instance.getSourceManager(); SourceMgr.setModuleBuildStack( ImportingInstance.getSourceManager().getModuleBuildStack()); SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(), FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); // If we're collecting module dependencies, we need to share a collector // between all of the module CompilerInstances. Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector()); // Get or create the module map that we'll use to build this module. std::string InferredModuleMapContent; if (const FileEntry *ModuleMapFile = ModMap.getContainingModuleMapFile(Module)) { // Use the module map where this module resides. FrontendOpts.Inputs.push_back( FrontendInputFile(ModuleMapFile->getName(), IK)); } else { llvm::raw_string_ostream OS(InferredModuleMapContent); Module->print(OS); OS.flush(); FrontendOpts.Inputs.push_back( FrontendInputFile("__inferred_module.map", IK)); llvm::MemoryBuffer *ModuleMapBuffer = llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); ModuleMapFile = Instance.getFileManager().getVirtualFile( "__inferred_module.map", InferredModuleMapContent.size(), 0); SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer); } // Construct a module-generating action. Passing through the module map is // safe because the FileManager is shared between the compiler instances. GenerateModuleAction CreateModuleAction( ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem); // Execute the action to actually build the module in-place. Use a separate // thread so that we get a stack large enough. const unsigned ThreadStackSize = 8 << 20; llvm::CrashRecoveryContext CRC; CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); }, ThreadStackSize); // Delete the temporary module map file. // FIXME: Even though we're executing under crash protection, it would still // be nice to do this with RemoveFileOnSignal when we can. However, that // doesn't make sense for all clients, so clean this up manually. Instance.clearOutputFiles(/*EraseFiles=*/true); // We've rebuilt a module. If we're allowed to generate or update the global // module index, record that fact in the importing compiler instance. if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { ImportingInstance.setBuildGlobalModuleIndex(true); } return !Instance.getDiagnostics().hasErrorOccurred(); } static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) { auto diagnoseBuildFailure = [&] { ImportingInstance.getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) << Module->Name << SourceRange(ImportLoc, ModuleNameLoc); }; // FIXME: have LockFileManager return an error_code so that we can // avoid the mkdir when the directory already exists. StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); llvm::sys::fs::create_directories(Dir); while (1) { unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing; llvm::LockFileManager Locked(ModuleFileName); switch (Locked) { case llvm::LockFileManager::LFS_Error: return false; case llvm::LockFileManager::LFS_Owned: // We're responsible for building the module ourselves. if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module, ModuleFileName)) { diagnoseBuildFailure(); return false; } break; case llvm::LockFileManager::LFS_Shared: // Someone else is responsible for building the module. Wait for them to // finish. if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied) continue; // try again to get the lock. ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate; break; } // Try to read the module file, now that we've compiled it. ASTReader::ASTReadResult ReadResult = ImportingInstance.getModuleManager()->ReadAST( ModuleFileName, serialization::MK_Module, ImportLoc, ModuleLoadCapabilities); if (ReadResult == ASTReader::OutOfDate && Locked == llvm::LockFileManager::LFS_Shared) { // The module may be out of date in the presence of file system races, // or if one of its imports depends on header search paths that are not // consistent with this ImportingInstance. Try again... continue; } else if (ReadResult == ASTReader::Missing) { diagnoseBuildFailure(); } return ReadResult == ASTReader::Success; } } /// \brief Diagnose differences between the current definition of the given /// configuration macro and the definition provided on the command line. static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc) { IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro); SourceManager &SourceMgr = PP.getSourceManager(); // If this identifier has never had a macro definition, then it could // not have changed. if (!Id->hadMacroDefinition()) return; // If this identifier does not currently have a macro definition, // check whether it had one on the command line. if (!Id->hasMacroDefinition()) { MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; // This macro was defined on the command line, then #undef'd later. // Complain. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << true << ConfigMacro << Mod->getFullModuleName(); if (LatestDef.isUndefined()) PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) << true; return; } // Okay: no definition in the predefines buffer. return; } // This identifier has a macro definition. Check whether we had a definition // on the command line. MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); MacroDirective::DefInfo PredefinedDef; for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; PredefinedDef = Def; break; } // If there was no definition for this macro in the predefines buffer, // complain. if (!PredefinedDef || (!PredefinedDef.getLocation().isValid() && PredefinedDef.getUndefLocation().isValid())) { PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; return; } // If the current macro definition is the same as the predefined macro // definition, it's okay. if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() || LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP, /*Syntactically=*/true)) return; // The macro definitions differ. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; } /// \brief Write a new timestamp file with the given path. static void writeTimestampFile(StringRef TimestampFile) { std::string ErrorInfo; llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_None); } /// \brief Prune the module cache of modules that haven't been accessed in /// a long time. static void pruneModuleCache(const HeaderSearchOptions &HSOpts) { struct stat StatBuf; llvm::SmallString<128> TimestampFile; TimestampFile = HSOpts.ModuleCachePath; llvm::sys::path::append(TimestampFile, "modules.timestamp"); // Try to stat() the timestamp file. if (::stat(TimestampFile.c_str(), &StatBuf)) { // If the timestamp file wasn't there, create one now. if (errno == ENOENT) { writeTimestampFile(TimestampFile); } return; } // Check whether the time stamp is older than our pruning interval. // If not, do nothing. time_t TimeStampModTime = StatBuf.st_mtime; time_t CurrentTime = time(nullptr); if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval)) return; // Write a new timestamp file so that nobody else attempts to prune. // There is a benign race condition here, if two Clang instances happen to // notice at the same time that the timestamp is out-of-date. writeTimestampFile(TimestampFile); // Walk the entire module cache, looking for unused module files and module // indices. std::error_code EC; SmallString<128> ModuleCachePathNative; llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative); for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative.str(), EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // If we don't have a directory, there's nothing to look into. if (!llvm::sys::fs::is_directory(Dir->path())) continue; // Walk all of the files within this directory. for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd; File != FileEnd && !EC; File.increment(EC)) { // We only care about module and global module index files. StringRef Extension = llvm::sys::path::extension(File->path()); if (Extension != ".pcm" && Extension != ".timestamp" && llvm::sys::path::filename(File->path()) != "modules.idx") continue; // Look at this file. If we can't stat it, there's nothing interesting // there. if (::stat(File->path().c_str(), &StatBuf)) continue; // If the file has been used recently enough, leave it there. time_t FileAccessTime = StatBuf.st_atime; if (CurrentTime - FileAccessTime <= time_t(HSOpts.ModuleCachePruneAfter)) { continue; } // Remove the file. llvm::sys::fs::remove(File->path()); // Remove the timestamp file. std::string TimpestampFilename = File->path() + ".timestamp"; llvm::sys::fs::remove(TimpestampFilename); } // If we removed all of the files in the directory, remove the directory // itself. if (llvm::sys::fs::directory_iterator(Dir->path(), EC) == llvm::sys::fs::directory_iterator() && !EC) llvm::sys::fs::remove(Dir->path()); } } void CompilerInstance::createModuleManager() { if (!ModuleManager) { if (!hasASTContext()) createASTContext(); // If we're not recursively building a module, check whether we // need to prune the module cache. if (getSourceManager().getModuleBuildStack().empty() && getHeaderSearchOpts().ModuleCachePruneInterval > 0 && getHeaderSearchOpts().ModuleCachePruneAfter > 0) { pruneModuleCache(getHeaderSearchOpts()); } HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); std::string Sysroot = HSOpts.Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); ModuleManager = new ASTReader(getPreprocessor(), *Context, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders, getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); getASTContext().setASTMutationListener( getASTConsumer().GetASTMutationListener()); } getASTContext().setExternalSource(ModuleManager); if (hasSema()) ModuleManager->InitializeSema(getSema()); if (hasASTConsumer()) ModuleManager->StartTranslationUnit(&getASTConsumer()); } } ModuleLoadResult CompilerInstance::loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) { // Determine what file we're searching from. StringRef ModuleName = Path[0].first->getName(); SourceLocation ModuleNameLoc = Path[0].second; // If we've already handled this import, just return the cached result. // This one-element cache is important to eliminate redundant diagnostics // when both the preprocessor and parser see the same import declaration. if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { // Make the named module visible. if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule && ModuleName != getLangOpts().ImplementationOfModule) ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility, ImportLoc, /*Complain=*/false); return LastModuleImportResult; } clang::Module *Module = nullptr; // If we don't already have information on this module, load the module now. llvm::DenseMap::iterator Known = KnownModules.find(Path[0].first); if (Known != KnownModules.end()) { // Retrieve the cached top-level module. Module = Known->second; } else if (ModuleName == getLangOpts().CurrentModule || ModuleName == getLangOpts().ImplementationOfModule) { // This is the module we're building. Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } else { // Search for a module with the given name. Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); if (!Module) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); // If we don't already have an ASTReader, create one now. if (!ModuleManager) createModuleManager(); if (TheDependencyFileGenerator) TheDependencyFileGenerator->AttachToASTReader(*ModuleManager); if (ModuleDepCollector) ModuleDepCollector->attachToASTReader(*ModuleManager); for (auto &Listener : DependencyCollectors) Listener->attachToASTReader(*ModuleManager); // Try to load the module file. unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, ImportLoc, ARRFlags)) { case ASTReader::Success: break; case ASTReader::OutOfDate: case ASTReader::Missing: { // The module file is missing or out-of-date. Build it. assert(Module && "missing module file"); // Check whether there is a cycle in the module graph. ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack(); ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end(); for (; Pos != PosEnd; ++Pos) { if (Pos->first == ModuleName) break; } if (Pos != PosEnd) { SmallString<256> CyclePath; for (; Pos != PosEnd; ++Pos) { CyclePath += Pos->first; CyclePath += " -> "; } CyclePath += ModuleName; getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) << ModuleName << CyclePath; return ModuleLoadResult(); } getDiagnostics().Report(ImportLoc, diag::remark_module_build) << ModuleName << ModuleFileName; // Check whether we have already attempted to build this module (but // failed). if (getPreprocessorOpts().FailedModules && getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } // Try to compile and then load the module. if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module, ModuleFileName)) { if (getPreprocessorOpts().FailedModules) getPreprocessorOpts().FailedModules->addFailed(ModuleName); KnownModules[Path[0].first] = nullptr; ModuleBuildFailed = true; return ModuleLoadResult(); } // Okay, we've rebuilt and now loaded the module. break; } case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: ModuleLoader::HadFatalFailure = true; // FIXME: The ASTReader will already have complained, but can we showhorn // that diagnostic information into a more useful form? KnownModules[Path[0].first] = nullptr; return ModuleLoadResult(); case ASTReader::Failure: ModuleLoader::HadFatalFailure = true; // Already complained, but note now that we failed. KnownModules[Path[0].first] = nullptr; ModuleBuildFailed = true; return ModuleLoadResult(); } // Cache the result of this top-level module lookup for later. Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } // If we never found the module, fail. if (!Module) return ModuleLoadResult(); // Verify that the rest of the module path actually corresponds to // a submodule. if (Path.size() > 1) { for (unsigned I = 1, N = Path.size(); I != N; ++I) { StringRef Name = Path[I].first->getName(); clang::Module *Sub = Module->findSubmodule(Name); if (!Sub) { // Attempt to perform typo correction to find a module name that works. SmallVector Best; unsigned BestEditDistance = (std::numeric_limits::max)(); for (clang::Module::submodule_iterator J = Module->submodule_begin(), JEnd = Module->submodule_end(); J != JEnd; ++J) { unsigned ED = Name.edit_distance((*J)->Name, /*AllowReplacements=*/true, BestEditDistance); if (ED <= BestEditDistance) { if (ED < BestEditDistance) { Best.clear(); BestEditDistance = ED; } Best.push_back((*J)->Name); } } // If there was a clear winner, user it. if (Best.size() == 1) { getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest) << Path[I].first << Module->getFullModuleName() << Best[0] << SourceRange(Path[0].second, Path[I-1].second) << FixItHint::CreateReplacement(SourceRange(Path[I].second), Best[0]); Sub = Module->findSubmodule(Best[0]); } } if (!Sub) { // No submodule by this name. Complain, and don't look for further // submodules. getDiagnostics().Report(Path[I].second, diag::err_no_submodule) << Path[I].first << Module->getFullModuleName() << SourceRange(Path[0].second, Path[I-1].second); break; } Module = Sub; } } // Don't make the module visible if we are in the implementation. if (ModuleName == getLangOpts().ImplementationOfModule) return ModuleLoadResult(Module, false); // Make the named module visible, if it's not already part of the module // we are parsing. if (ModuleName != getLangOpts().CurrentModule) { if (!Module->IsFromModuleFile) { // We have an umbrella header or directory that doesn't actually include // all of the headers within the directory it covers. Complain about // this missing submodule and recover by forgetting that we ever saw // this submodule. // FIXME: Should we detect this at module load time? It seems fairly // expensive (and rare). getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) << Module->getFullModuleName() << SourceRange(Path.front().second, Path.back().second); return ModuleLoadResult(nullptr, true); } // Check whether this module is available. clang::Module::Requirement Requirement; clang::Module::HeaderDirective MissingHeader; if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement, MissingHeader)) { if (MissingHeader.FileNameLoc.isValid()) { getDiagnostics().Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) << MissingHeader.IsUmbrella << MissingHeader.FileName; } else { getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) << Module->getFullModuleName() << Requirement.second << Requirement.first << SourceRange(Path.front().second, Path.back().second); } LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(); return ModuleLoadResult(); } ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc, /*Complain=*/true); } // Check for any configuration macros that have changed. clang::Module *TopModule = Module->getTopLevelModule(); for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) { checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I], Module, ImportLoc); } // If this module import was due to an inclusion directive, create an // implicit import declaration to capture it in the AST. if (IsInclusionDirective && hasASTContext()) { TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, ImportLoc, Module, Path.back().second); TU->addDecl(ImportD); if (Consumer) Consumer->HandleImplicitImportDecl(ImportD); } LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(Module, false); return LastModuleImportResult; } void CompilerInstance::makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc, bool Complain){ ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain); } GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( SourceLocation TriggerLoc) { if (!ModuleManager) createModuleManager(); // Can't do anything if we don't have the module manager. if (!ModuleManager) return nullptr; // Get an existing global index. This loads it if not already // loaded. ModuleManager->loadGlobalIndex(); GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex(); // If the global index doesn't exist, create it. if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() && hasPreprocessor()) { llvm::sys::fs::create_directories( getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } // For finding modules needing to be imported for fixit messages, // we need to make the global index cover all modules, so we do that here. if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) { ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap(); bool RecreateIndex = false; for (ModuleMap::module_iterator I = MMap.module_begin(), E = MMap.module_end(); I != E; ++I) { Module *TheModule = I->second; const FileEntry *Entry = TheModule->getASTFile(); if (!Entry) { SmallVector, 2> Path; Path.push_back(std::make_pair( getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); std::reverse(Path.begin(), Path.end()); // Load a module as hidden. This also adds it to the global index. loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false); RecreateIndex = true; } } if (RecreateIndex) { GlobalModuleIndex::writeIndex( getFileManager(), getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); } HaveFullGlobalModuleIndex = true; } return GlobalIndex; } // Check global module index for missing imports. bool CompilerInstance::lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) { // Look for the symbol in non-imported modules, but only if an error // actually occurred. if (!buildingModule()) { // Load global module index, or retrieve a previously loaded one. GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex( TriggerLoc); // Only if we have a global index. if (GlobalIndex) { GlobalModuleIndex::HitSet FoundModules; // Find the modules that reference the identifier. // Note that this only finds top-level modules. // We'll let diagnoseTypo find the actual declaration module. if (GlobalIndex->lookupIdentifier(Name, FoundModules)) return true; } } return false; } @ 1.1.1.5.4.1 log @file CompilerInstance.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 1414 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1414 //===--- CompilerInstance.cpp ---------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/Frontend/CompilerInstance.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/Version.h" #include "clang/Frontend/ChainedDiagnosticConsumer.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/LogDiagnosticPrinter.h" #include "clang/Frontend/SerializedDiagnosticPrinter.h" #include "clang/Frontend/TextDiagnosticPrinter.h" #include "clang/Frontend/Utils.h" #include "clang/Frontend/VerifyDiagnosticConsumer.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/PTHManager.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "llvm/ADT/Statistic.h" #include "llvm/Config/config.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Host.h" #include "llvm/Support/LockFileManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/Program.h" #include "llvm/Support/Signals.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #include #include using namespace clang; CompilerInstance::CompilerInstance() : Invocation(new CompilerInvocation()), ModuleManager(0), BuildGlobalModuleIndex(false), ModuleBuildFailed(false) { } CompilerInstance::~CompilerInstance() { assert(OutputFiles.empty() && "Still output files in flight?"); } void CompilerInstance::setInvocation(CompilerInvocation *Value) { Invocation = Value; } bool CompilerInstance::shouldBuildGlobalModuleIndex() const { return (BuildGlobalModuleIndex || (ModuleManager && ModuleManager->isGlobalIndexUnavailable() && getFrontendOpts().GenerateGlobalModuleIndex)) && !ModuleBuildFailed; } void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { Diagnostics = Value; } void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; } void CompilerInstance::setFileManager(FileManager *Value) { FileMgr = Value; if (Value) VirtualFileSystem = Value->getVirtualFileSystem(); else VirtualFileSystem.reset(); } void CompilerInstance::setSourceManager(SourceManager *Value) { SourceMgr = Value; } void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } void CompilerInstance::setSema(Sema *S) { TheSema.reset(S); } void CompilerInstance::setASTConsumer(ASTConsumer *Value) { Consumer.reset(Value); } void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { CompletionConsumer.reset(Value); } IntrusiveRefCntPtr CompilerInstance::getModuleManager() const { return ModuleManager; } void CompilerInstance::setModuleManager(IntrusiveRefCntPtr Reader) { ModuleManager = Reader; } // Diagnostics static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags) { std::string ErrorInfo; bool OwnsStream = false; raw_ostream *OS = &llvm::errs(); if (DiagOpts->DiagnosticLogFile != "-") { // Create the output stream. llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream( DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo, llvm::sys::fs::F_Append | llvm::sys::fs::F_Text)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) << DiagOpts->DiagnosticLogFile << ErrorInfo; } else { FileOS->SetUnbuffered(); FileOS->SetUseAtomicWrites(true); OS = FileOS; OwnsStream = true; } } // Chain in the diagnostic client which will log the diagnostics. LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, OwnsStream); if (CodeGenOpts) Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); } static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile) { std::string ErrorInfo; OwningPtr OS; OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_None)); if (!ErrorInfo.empty()) { Diags.Report(diag::warn_fe_serialized_diag_failure) << OutputFile << ErrorInfo; return; } DiagnosticConsumer *SerializedConsumer = clang::serialized_diags::create(OS.take(), DiagOpts); Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), SerializedConsumer)); } void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, bool ShouldOwnClient) { Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient, &getCodeGenOpts()); } IntrusiveRefCntPtr CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient, const CodeGenOptions *CodeGenOpts) { IntrusiveRefCntPtr DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr Diags(new DiagnosticsEngine(DiagID, Opts)); // Create the diagnostic client for reporting errors or for // implementing -verify. if (Client) { Diags->setClient(Client, ShouldOwnClient); } else Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); // Chain in -verify checker, if requested. if (Opts->VerifyDiagnostics) Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); // Chain in -diagnostic-log-file dumper, if requested. if (!Opts->DiagnosticLogFile.empty()) SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); if (!Opts->DiagnosticSerializationFile.empty()) SetupSerializedDiagnostics(Opts, *Diags, Opts->DiagnosticSerializationFile); // Configure our handling of diagnostics. ProcessWarningOptions(*Diags, *Opts); return Diags; } // File Manager void CompilerInstance::createFileManager() { if (!hasVirtualFileSystem()) { // TODO: choose the virtual file system based on the CompilerInvocation. setVirtualFileSystem(vfs::getRealFileSystem()); } FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem); } // Source Manager void CompilerInstance::createSourceManager(FileManager &FileMgr) { SourceMgr = new SourceManager(getDiagnostics(), FileMgr); } // Preprocessor void CompilerInstance::createPreprocessor() { const PreprocessorOptions &PPOpts = getPreprocessorOpts(); // Create a PTH manager if we are using some form of a token cache. PTHManager *PTHMgr = 0; if (!PPOpts.TokenCache.empty()) PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); // Create the Preprocessor. HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(), getSourceManager(), getDiagnostics(), getLangOpts(), &getTarget()); PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(), &getTarget(), getSourceManager(), *HeaderInfo, *this, PTHMgr, /*OwnsHeaderSearch=*/true); // Note that this is different then passing PTHMgr to Preprocessor's ctor. // That argument is used as the IdentifierInfoLookup argument to // IdentifierTable's ctor. if (PTHMgr) { PTHMgr->setPreprocessor(&*PP); PP->setPTHManager(PTHMgr); } if (PPOpts.DetailedRecord) PP->createPreprocessingRecord(); InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts()); PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP); // Set up the module path, including the hash for the // module-creation options. SmallString<256> SpecificModuleCache( getHeaderSearchOpts().ModuleCachePath); if (!getHeaderSearchOpts().DisableModuleHash) llvm::sys::path::append(SpecificModuleCache, getInvocation().getModuleHash()); PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache); // Handle generating dependencies, if requested. const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); if (!DepOpts.OutputFile.empty()) AttachDependencyFileGen(*PP, DepOpts); if (!DepOpts.DOTOutputFile.empty()) AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, getHeaderSearchOpts().Sysroot); // Handle generating header include information, if requested. if (DepOpts.ShowHeaderIncludes) AttachHeaderIncludeGen(*PP); if (!DepOpts.HeaderIncludeOutputFile.empty()) { StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; if (OutputPath == "-") OutputPath = ""; AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, /*ShowDepth=*/false); } if (DepOpts.PrintShowIncludes) { AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"", /*ShowDepth=*/true, /*MSStyle=*/true); } } // ASTContext void CompilerInstance::createASTContext() { Preprocessor &PP = getPreprocessor(); Context = new ASTContext(getLangOpts(), PP.getSourceManager(), &getTarget(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo(), /*size_reserve=*/ 0); } // ExternalASTSource void CompilerInstance::createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener){ IntrusiveRefCntPtr Source; bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; Source = createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), DeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex); ModuleManager = static_cast(Source.getPtr()); getASTContext().setExternalSource(Source); } ExternalASTSource * CompilerInstance::createPCHExternalASTSource(StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, void *DeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { OwningPtr Reader; Reader.reset(new ASTReader(PP, Context, Sysroot.empty() ? "" : Sysroot.c_str(), DisablePCHValidation, AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/false, /*ValidateSystemInputs*/false, UseGlobalModuleIndex)); Reader->setDeserializationListener( static_cast(DeserializationListener)); switch (Reader->ReadAST(Path, Preamble ? serialization::MK_Preamble : serialization::MK_PCH, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: // Set the predefines buffer as suggested by the PCH reader. Typically, the // predefines buffer will be empty. PP.setPredefines(Reader->getSuggestedPredefines()); return Reader.take(); case ASTReader::Failure: // Unrecoverable failure: don't even try to process the input file. break; case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: // No suitable PCH file could be found. Return an error. break; } return 0; } // Code Completion static bool EnableCodeCompletion(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column) { // Tell the source manager to chop off the given file at a specific // line and column. const FileEntry *Entry = PP.getFileManager().getFile(Filename); if (!Entry) { PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) << Filename; return true; } // Truncate the named file at the given line/column. PP.SetCodeCompletionPoint(Entry, Line, Column); return false; } void CompilerInstance::createCodeCompletionConsumer() { const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; if (!CompletionConsumer) { setCodeCompletionConsumer( createCodeCompletionConsumer(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column, getFrontendOpts().CodeCompleteOpts, llvm::outs())); if (!CompletionConsumer) return; } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column)) { setCodeCompletionConsumer(0); return; } if (CompletionConsumer->isOutputBinary() && llvm::sys::ChangeStdoutToBinary()) { getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); setCodeCompletionConsumer(0); } } void CompilerInstance::createFrontendTimer() { FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); } CodeCompleteConsumer * CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column, const CodeCompleteOptions &Opts, raw_ostream &OS) { if (EnableCodeCompletion(PP, Filename, Line, Column)) return 0; // Set up the creation routine for code-completion. return new PrintingCodeCompleteConsumer(Opts, OS); } void CompilerInstance::createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer) { TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), TUKind, CompletionConsumer)); } // Output Files void CompilerInstance::addOutputFile(const OutputFile &OutFile) { assert(OutFile.OS && "Attempt to add empty stream to output list!"); OutputFiles.push_back(OutFile); } void CompilerInstance::clearOutputFiles(bool EraseFiles) { for (std::list::iterator it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { delete it->OS; if (!it->TempFilename.empty()) { if (EraseFiles) { llvm::sys::fs::remove(it->TempFilename); } else { SmallString<128> NewOutFile(it->Filename); // If '-working-directory' was passed, the output filename should be // relative to that. FileMgr->FixupRelativePath(NewOutFile); if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) { getDiagnostics().Report(diag::err_unable_to_rename_temp) << it->TempFilename << it->Filename << ec.message(); llvm::sys::fs::remove(it->TempFilename); } } } else if (!it->Filename.empty() && EraseFiles) llvm::sys::fs::remove(it->Filename); } OutputFiles.clear(); } llvm::raw_fd_ostream * CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile, StringRef Extension) { return createOutputFile(getFrontendOpts().OutputFile, Binary, /*RemoveFileOnSignal=*/true, InFile, Extension, /*UseTemporary=*/true); } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories) { std::string Error, OutputPathName, TempPathName; llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, RemoveFileOnSignal, InFile, Extension, UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName); if (!OS) { getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath << Error; return 0; } // Add the output file -- but don't try to remove "-", since this means we are // using stdin. addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName, OS)); return OS; } llvm::raw_fd_ostream * CompilerInstance::createOutputFile(StringRef OutputPath, std::string &Error, bool Binary, bool RemoveFileOnSignal, StringRef InFile, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories, std::string *ResultPathName, std::string *TempPathName) { assert((!CreateMissingDirectories || UseTemporary) && "CreateMissingDirectories is only allowed when using temporary files"); std::string OutFile, TempFile; if (!OutputPath.empty()) { OutFile = OutputPath; } else if (InFile == "-") { OutFile = "-"; } else if (!Extension.empty()) { SmallString<128> Path(InFile); llvm::sys::path::replace_extension(Path, Extension); OutFile = Path.str(); } else { OutFile = "-"; } OwningPtr OS; std::string OSFile; if (UseTemporary) { if (OutFile == "-") UseTemporary = false; else { llvm::sys::fs::file_status Status; llvm::sys::fs::status(OutputPath, Status); if (llvm::sys::fs::exists(Status)) { // Fail early if we can't write to the final destination. if (!llvm::sys::fs::can_write(OutputPath)) return 0; // Don't use a temporary if the output is a special file. This handles // things like '-o /dev/null' if (!llvm::sys::fs::is_regular_file(Status)) UseTemporary = false; } } } if (UseTemporary) { // Create a temporary file. SmallString<128> TempPath; TempPath = OutFile; TempPath += "-%%%%%%%%"; int fd; llvm::error_code EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); if (CreateMissingDirectories && EC == llvm::errc::no_such_file_or_directory) { StringRef Parent = llvm::sys::path::parent_path(OutputPath); EC = llvm::sys::fs::create_directories(Parent); if (!EC) { EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); } } if (!EC) { OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); OSFile = TempFile = TempPath.str(); } // If we failed to create the temporary, fallback to writing to the file // directly. This handles the corner case where we cannot write to the // directory, but can write to the file. } if (!OS) { OSFile = OutFile; OS.reset(new llvm::raw_fd_ostream( OSFile.c_str(), Error, (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text))); if (!Error.empty()) return 0; } // Make sure the out stream file gets removed if we crash. if (RemoveFileOnSignal) llvm::sys::RemoveFileOnSignal(OSFile); if (ResultPathName) *ResultPathName = OutFile; if (TempPathName) *TempPathName = TempFile; return OS.take(); } // Initialization Utilities bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ return InitializeSourceManager(Input, getDiagnostics(), getFileManager(), getSourceManager(), getFrontendOpts()); } bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, DiagnosticsEngine &Diags, FileManager &FileMgr, SourceManager &SourceMgr, const FrontendOptions &Opts) { SrcMgr::CharacteristicKind Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; if (Input.isBuffer()) { SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind); assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } StringRef InputFile = Input.getFile(); // Figure out where to get and map in the main file. if (InputFile != "-") { const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); if (!File) { Diags.Report(diag::err_fe_error_reading) << InputFile; return false; } // The natural SourceManager infrastructure can't currently handle named // pipes, but we would at least like to accept them for the main // file. Detect them here, read them with the volatile flag so FileMgr will // pick up the correct size, and simply override their contents as we do for // STDIN. if (File->isNamedPipe()) { std::string ErrorStr; if (llvm::MemoryBuffer *MB = FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) { // Create a new virtual file that will have the correct size. File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0); SourceMgr.overrideFileContents(File, MB); } else { Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr; return false; } } SourceMgr.createMainFileID(File, Kind); } else { OwningPtr SB; if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) { Diags.Report(diag::err_fe_error_reading_stdin) << ec.message(); return false; } const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), SB->getBufferSize(), 0); SourceMgr.createMainFileID(File, Kind); SourceMgr.overrideFileContents(File, SB.take()); } assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; } // High-Level Operations bool CompilerInstance::ExecuteAction(FrontendAction &Act) { assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); // FIXME: Take this as an argument, once all the APIs we used have moved to // taking it as an input instead of hard-coding llvm::errs. raw_ostream &OS = llvm::errs(); // Create the target instance. setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts())); if (!hasTarget()) return false; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. getTarget().setForcedLangOptions(getLangOpts()); // rewriter project will change target built-in bool type from its default. if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) getTarget().noSignedCharForObjCBool(); // Validate/process some options. if (getHeaderSearchOpts().Verbose) OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon " << PACKAGE_STRING << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; if (getFrontendOpts().ShowTimers) createFrontendTimer(); if (getFrontendOpts().ShowStats) llvm::EnableStatistics(); for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { // Reset the ID tables if we are reusing the SourceManager. if (hasSourceManager()) getSourceManager().clearIDTables(); if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { Act.Execute(); Act.EndSourceFile(); } } // Notify the diagnostic client that all files were processed. getDiagnostics().getClient()->finish(); if (getDiagnosticOpts().ShowCarets) { // We can have multiple diagnostics sharing one diagnostic client. // Get the total number of warnings/errors from the client. unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); if (NumWarnings) OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); if (NumWarnings && NumErrors) OS << " and "; if (NumErrors) OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); if (NumWarnings || NumErrors) OS << " generated.\n"; } if (getFrontendOpts().ShowStats && hasFileManager()) { getFileManager().PrintStats(); OS << "\n"; } return !getDiagnostics().getClient()->getNumErrors(); } /// \brief Determine the appropriate source input kind based on language /// options. static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { if (LangOpts.OpenCL) return IK_OpenCL; if (LangOpts.CUDA) return IK_CUDA; if (LangOpts.ObjC1) return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; return LangOpts.CPlusPlus? IK_CXX : IK_C; } namespace { struct CompileModuleMapData { CompilerInstance &Instance; GenerateModuleAction &CreateModuleAction; }; } /// \brief Helper function that executes the module-generating action under /// a crash recovery context. static void doCompileMapModule(void *UserData) { CompileModuleMapData &Data = *reinterpret_cast(UserData); Data.Instance.ExecuteAction(Data.CreateModuleAction); } namespace { /// \brief Function object that checks with the given macro definition should /// be removed, because it is one of the ignored macros. class RemoveIgnoredMacro { const HeaderSearchOptions &HSOpts; public: explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts) : HSOpts(HSOpts) { } bool operator()(const std::pair &def) const { StringRef MacroDef = def.first; return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; } }; } /// \brief Compile a module file for the given module, using the options /// provided by the importing compiler instance. static void compileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName) { // FIXME: have LockFileManager return an error_code so that we can // avoid the mkdir when the directory already exists. StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); llvm::sys::fs::create_directories(Dir); llvm::LockFileManager Locked(ModuleFileName); switch (Locked) { case llvm::LockFileManager::LFS_Error: return; case llvm::LockFileManager::LFS_Owned: // We're responsible for building the module ourselves. Do so below. break; case llvm::LockFileManager::LFS_Shared: // Someone else is responsible for building the module. Wait for them to // finish. Locked.waitForUnlock(); return; } ModuleMap &ModMap = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); // Construct a compiler invocation for creating this module. IntrusiveRefCntPtr Invocation (new CompilerInvocation(ImportingInstance.getInvocation())); PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); // For any options that aren't intended to affect how a module is built, // reset them to their default values. Invocation->getLangOpts()->resetNonModularOptions(); PPOpts.resetNonModularOptions(); // Remove any macro definitions that are explicitly ignored by the module. // They aren't supposed to affect how the module is built anyway. const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), RemoveIgnoredMacro(HSOpts)), PPOpts.Macros.end()); // Note the name of the module we're building. Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); // Make sure that the failed-module structure has been allocated in // the importing instance, and propagate the pointer to the newly-created // instance. PreprocessorOptions &ImportingPPOpts = ImportingInstance.getInvocation().getPreprocessorOpts(); if (!ImportingPPOpts.FailedModules) ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet; PPOpts.FailedModules = ImportingPPOpts.FailedModules; // If there is a module map file, build the module using the module map. // Set up the inputs/outputs so that we build the module from its umbrella // header. FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); FrontendOpts.OutputFile = ModuleFileName.str(); FrontendOpts.DisableFree = false; FrontendOpts.GenerateGlobalModuleIndex = false; FrontendOpts.Inputs.clear(); InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); // Don't free the remapped file buffers; they are owned by our caller. PPOpts.RetainRemappedFileBuffers = true; Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; assert(ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"); // Construct a compiler instance that will be used to actually create the // module. CompilerInstance Instance; Instance.setInvocation(&*Invocation); Instance.createDiagnostics(new ForwardingDiagnosticConsumer( ImportingInstance.getDiagnosticClient()), /*ShouldOwnClient=*/true); Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem()); // Note that this module is part of the module build stack, so that we // can detect cycles in the module graph. Instance.setFileManager(&ImportingInstance.getFileManager()); Instance.createSourceManager(Instance.getFileManager()); SourceManager &SourceMgr = Instance.getSourceManager(); SourceMgr.setModuleBuildStack( ImportingInstance.getSourceManager().getModuleBuildStack()); SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(), FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); // Get or create the module map that we'll use to build this module. std::string InferredModuleMapContent; if (const FileEntry *ModuleMapFile = ModMap.getContainingModuleMapFile(Module)) { // Use the module map where this module resides. FrontendOpts.Inputs.push_back( FrontendInputFile(ModuleMapFile->getName(), IK)); } else { llvm::raw_string_ostream OS(InferredModuleMapContent); Module->print(OS); OS.flush(); FrontendOpts.Inputs.push_back( FrontendInputFile("__inferred_module.map", IK)); const llvm::MemoryBuffer *ModuleMapBuffer = llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); ModuleMapFile = Instance.getFileManager().getVirtualFile( "__inferred_module.map", InferredModuleMapContent.size(), 0); SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer); } // Construct a module-generating action. GenerateModuleAction CreateModuleAction(Module->IsSystem); // Execute the action to actually build the module in-place. Use a separate // thread so that we get a stack large enough. const unsigned ThreadStackSize = 8 << 20; llvm::CrashRecoveryContext CRC; CompileModuleMapData Data = { Instance, CreateModuleAction }; CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize); // Delete the temporary module map file. // FIXME: Even though we're executing under crash protection, it would still // be nice to do this with RemoveFileOnSignal when we can. However, that // doesn't make sense for all clients, so clean this up manually. Instance.clearOutputFiles(/*EraseFiles=*/true); // We've rebuilt a module. If we're allowed to generate or update the global // module index, record that fact in the importing compiler instance. if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { ImportingInstance.setBuildGlobalModuleIndex(true); } } /// \brief Diagnose differences between the current definition of the given /// configuration macro and the definition provided on the command line. static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc) { IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro); SourceManager &SourceMgr = PP.getSourceManager(); // If this identifier has never had a macro definition, then it could // not have changed. if (!Id->hadMacroDefinition()) return; // If this identifier does not currently have a macro definition, // check whether it had one on the command line. if (!Id->hasMacroDefinition()) { MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; // This macro was defined on the command line, then #undef'd later. // Complain. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << true << ConfigMacro << Mod->getFullModuleName(); if (LatestDef.isUndefined()) PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) << true; return; } // Okay: no definition in the predefines buffer. return; } // This identifier has a macro definition. Check whether we had a definition // on the command line. MacroDirective::DefInfo LatestDef = PP.getMacroDirectiveHistory(Id)->getDefinition(); MacroDirective::DefInfo PredefinedDef; for (MacroDirective::DefInfo Def = LatestDef; Def; Def = Def.getPreviousDefinition()) { FileID FID = SourceMgr.getFileID(Def.getLocation()); if (FID.isInvalid()) continue; // We only care about the predefines buffer. if (FID != PP.getPredefinesFileID()) continue; PredefinedDef = Def; break; } // If there was no definition for this macro in the predefines buffer, // complain. if (!PredefinedDef || (!PredefinedDef.getLocation().isValid() && PredefinedDef.getUndefLocation().isValid())) { PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; return; } // If the current macro definition is the same as the predefined macro // definition, it's okay. if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() || LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP, /*Syntactically=*/true)) return; // The macro definitions differ. PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) << false << ConfigMacro << Mod->getFullModuleName(); PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) << false; } /// \brief Write a new timestamp file with the given path. static void writeTimestampFile(StringRef TimestampFile) { std::string ErrorInfo; llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo, llvm::sys::fs::F_None); } /// \brief Prune the module cache of modules that haven't been accessed in /// a long time. static void pruneModuleCache(const HeaderSearchOptions &HSOpts) { struct stat StatBuf; llvm::SmallString<128> TimestampFile; TimestampFile = HSOpts.ModuleCachePath; llvm::sys::path::append(TimestampFile, "modules.timestamp"); // Try to stat() the timestamp file. if (::stat(TimestampFile.c_str(), &StatBuf)) { // If the timestamp file wasn't there, create one now. if (errno == ENOENT) { writeTimestampFile(TimestampFile); } return; } // Check whether the time stamp is older than our pruning interval. // If not, do nothing. time_t TimeStampModTime = StatBuf.st_mtime; time_t CurrentTime = time(0); if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval)) return; // Write a new timestamp file so that nobody else attempts to prune. // There is a benign race condition here, if two Clang instances happen to // notice at the same time that the timestamp is out-of-date. writeTimestampFile(TimestampFile); // Walk the entire module cache, looking for unused module files and module // indices. llvm::error_code EC; SmallString<128> ModuleCachePathNative; llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative); for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative.str(), EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // If we don't have a directory, there's nothing to look into. if (!llvm::sys::fs::is_directory(Dir->path())) continue; // Walk all of the files within this directory. for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd; File != FileEnd && !EC; File.increment(EC)) { // We only care about module and global module index files. StringRef Extension = llvm::sys::path::extension(File->path()); if (Extension != ".pcm" && Extension != ".timestamp" && llvm::sys::path::filename(File->path()) != "modules.idx") continue; // Look at this file. If we can't stat it, there's nothing interesting // there. if (::stat(File->path().c_str(), &StatBuf)) continue; // If the file has been used recently enough, leave it there. time_t FileAccessTime = StatBuf.st_atime; if (CurrentTime - FileAccessTime <= time_t(HSOpts.ModuleCachePruneAfter)) { continue; } // Remove the file. llvm::sys::fs::remove(File->path()); // Remove the timestamp file. std::string TimpestampFilename = File->path() + ".timestamp"; llvm::sys::fs::remove(TimpestampFilename); } // If we removed all of the files in the directory, remove the directory // itself. if (llvm::sys::fs::directory_iterator(Dir->path(), EC) == llvm::sys::fs::directory_iterator() && !EC) llvm::sys::fs::remove(Dir->path()); } } ModuleLoadResult CompilerInstance::loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) { // Determine what file we're searching from. StringRef ModuleName = Path[0].first->getName(); SourceLocation ModuleNameLoc = Path[0].second; // If we've already handled this import, just return the cached result. // This one-element cache is important to eliminate redundant diagnostics // when both the preprocessor and parser see the same import declaration. if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { // Make the named module visible. if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility, ImportLoc, /*Complain=*/false); return LastModuleImportResult; } clang::Module *Module = 0; // If we don't already have information on this module, load the module now. llvm::DenseMap::iterator Known = KnownModules.find(Path[0].first); if (Known != KnownModules.end()) { // Retrieve the cached top-level module. Module = Known->second; } else if (ModuleName == getLangOpts().CurrentModule) { // This is the module we're building. Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName); Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } else { // Search for a module with the given name. Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); if (!Module) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); // If we don't already have an ASTReader, create one now. if (!ModuleManager) { if (!hasASTContext()) createASTContext(); // If we're not recursively building a module, check whether we // need to prune the module cache. if (getSourceManager().getModuleBuildStack().empty() && getHeaderSearchOpts().ModuleCachePruneInterval > 0 && getHeaderSearchOpts().ModuleCachePruneAfter > 0) { pruneModuleCache(getHeaderSearchOpts()); } std::string Sysroot = getHeaderSearchOpts().Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); ModuleManager = new ASTReader(getPreprocessor(), *Context, Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, /*AllowASTWithCompilerErrors=*/false, /*AllowConfigurationMismatch=*/false, /*ValidateSystemInputs=*/false, getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); getASTContext().setASTMutationListener( getASTConsumer().GetASTMutationListener()); } getASTContext().setExternalSource(ModuleManager); if (hasSema()) ModuleManager->InitializeSema(getSema()); if (hasASTConsumer()) ModuleManager->StartTranslationUnit(&getASTConsumer()); } // Try to load the module file. unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, ImportLoc, ARRFlags)) { case ASTReader::Success: break; case ASTReader::OutOfDate: case ASTReader::Missing: { // The module file is missing or out-of-date. Build it. assert(Module && "missing module file"); // Check whether there is a cycle in the module graph. ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack(); ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end(); for (; Pos != PosEnd; ++Pos) { if (Pos->first == ModuleName) break; } if (Pos != PosEnd) { SmallString<256> CyclePath; for (; Pos != PosEnd; ++Pos) { CyclePath += Pos->first; CyclePath += " -> "; } CyclePath += ModuleName; getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) << ModuleName << CyclePath; return ModuleLoadResult(); } // Check whether we have already attempted to build this module (but // failed). if (getPreprocessorOpts().FailedModules && getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); ModuleBuildFailed = true; return ModuleLoadResult(); } // Try to compile the module. compileModule(*this, ModuleNameLoc, Module, ModuleFileName); // Try to read the module file, now that we've compiled it. ASTReader::ASTReadResult ReadResult = ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, ImportLoc, ASTReader::ARR_Missing); if (ReadResult != ASTReader::Success) { if (ReadResult == ASTReader::Missing) { getDiagnostics().Report(ModuleNameLoc, Module? diag::err_module_not_built : diag::err_module_not_found) << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); } if (getPreprocessorOpts().FailedModules) getPreprocessorOpts().FailedModules->addFailed(ModuleName); KnownModules[Path[0].first] = 0; ModuleBuildFailed = true; return ModuleLoadResult(); } // Okay, we've rebuilt and now loaded the module. break; } case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: ModuleLoader::HadFatalFailure = true; // FIXME: The ASTReader will already have complained, but can we showhorn // that diagnostic information into a more useful form? KnownModules[Path[0].first] = 0; return ModuleLoadResult(); case ASTReader::Failure: ModuleLoader::HadFatalFailure = true; // Already complained, but note now that we failed. KnownModules[Path[0].first] = 0; ModuleBuildFailed = true; return ModuleLoadResult(); } // Cache the result of this top-level module lookup for later. Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; } // If we never found the module, fail. if (!Module) return ModuleLoadResult(); // Verify that the rest of the module path actually corresponds to // a submodule. if (Path.size() > 1) { for (unsigned I = 1, N = Path.size(); I != N; ++I) { StringRef Name = Path[I].first->getName(); clang::Module *Sub = Module->findSubmodule(Name); if (!Sub) { // Attempt to perform typo correction to find a module name that works. SmallVector Best; unsigned BestEditDistance = (std::numeric_limits::max)(); for (clang::Module::submodule_iterator J = Module->submodule_begin(), JEnd = Module->submodule_end(); J != JEnd; ++J) { unsigned ED = Name.edit_distance((*J)->Name, /*AllowReplacements=*/true, BestEditDistance); if (ED <= BestEditDistance) { if (ED < BestEditDistance) { Best.clear(); BestEditDistance = ED; } Best.push_back((*J)->Name); } } // If there was a clear winner, user it. if (Best.size() == 1) { getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest) << Path[I].first << Module->getFullModuleName() << Best[0] << SourceRange(Path[0].second, Path[I-1].second) << FixItHint::CreateReplacement(SourceRange(Path[I].second), Best[0]); Sub = Module->findSubmodule(Best[0]); } } if (!Sub) { // No submodule by this name. Complain, and don't look for further // submodules. getDiagnostics().Report(Path[I].second, diag::err_no_submodule) << Path[I].first << Module->getFullModuleName() << SourceRange(Path[0].second, Path[I-1].second); break; } Module = Sub; } } // Make the named module visible, if it's not already part of the module // we are parsing. if (ModuleName != getLangOpts().CurrentModule) { if (!Module->IsFromModuleFile) { // We have an umbrella header or directory that doesn't actually include // all of the headers within the directory it covers. Complain about // this missing submodule and recover by forgetting that we ever saw // this submodule. // FIXME: Should we detect this at module load time? It seems fairly // expensive (and rare). getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) << Module->getFullModuleName() << SourceRange(Path.front().second, Path.back().second); return ModuleLoadResult(0, true); } // Check whether this module is available. clang::Module::Requirement Requirement; clang::Module::HeaderDirective MissingHeader; if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement, MissingHeader)) { if (MissingHeader.FileNameLoc.isValid()) { getDiagnostics().Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) << MissingHeader.IsUmbrella << MissingHeader.FileName; } else { getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) << Module->getFullModuleName() << Requirement.second << Requirement.first << SourceRange(Path.front().second, Path.back().second); } LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(); return ModuleLoadResult(); } ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc, /*Complain=*/true); } // Check for any configuration macros that have changed. clang::Module *TopModule = Module->getTopLevelModule(); for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) { checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I], Module, ImportLoc); } // If this module import was due to an inclusion directive, create an // implicit import declaration to capture it in the AST. if (IsInclusionDirective && hasASTContext()) { TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, ImportLoc, Module, Path.back().second); TU->addDecl(ImportD); if (Consumer) Consumer->HandleImplicitImportDecl(ImportD); } LastModuleImportLoc = ImportLoc; LastModuleImportResult = ModuleLoadResult(Module, false); return LastModuleImportResult; } void CompilerInstance::makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc, bool Complain){ ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain); } @