| //===--- PrecompiledPreamble.cpp - Build precompiled preambles --*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Helper class to build precompiled preamble. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/Frontend/PrecompiledPreamble.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/Basic/VirtualFileSystem.h" |
| #include "clang/Frontend/CompilerInstance.h" |
| #include "clang/Frontend/CompilerInvocation.h" |
| #include "clang/Frontend/FrontendActions.h" |
| #include "clang/Frontend/FrontendOptions.h" |
| #include "clang/Lex/Lexer.h" |
| #include "clang/Lex/PreprocessorOptions.h" |
| #include "clang/Serialization/ASTWriter.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/ADT/StringSet.h" |
| #include "llvm/Config/llvm-config.h" |
| #include "llvm/Support/CrashRecoveryContext.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/Mutex.h" |
| #include "llvm/Support/MutexGuard.h" |
| #include "llvm/Support/Process.h" |
| #include <limits> |
| #include <utility> |
| |
| using namespace clang; |
| |
| namespace { |
| |
| StringRef getInMemoryPreamblePath() { |
| #if defined(LLVM_ON_UNIX) |
| return "/__clang_tmp/___clang_inmemory_preamble___"; |
| #elif defined(LLVM_ON_WIN32) |
| return "C:\\__clang_tmp\\___clang_inmemory_preamble___"; |
| #else |
| #warning "Unknown platform. Defaulting to UNIX-style paths for in-memory PCHs" |
| return "/__clang_tmp/___clang_inmemory_preamble___"; |
| #endif |
| } |
| |
| IntrusiveRefCntPtr<vfs::FileSystem> |
| createVFSOverlayForPreamblePCH(StringRef PCHFilename, |
| std::unique_ptr<llvm::MemoryBuffer> PCHBuffer, |
| IntrusiveRefCntPtr<vfs::FileSystem> VFS) { |
| // We want only the PCH file from the real filesystem to be available, |
| // so we create an in-memory VFS with just that and overlay it on top. |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> PCHFS( |
| new vfs::InMemoryFileSystem()); |
| PCHFS->addFile(PCHFilename, 0, std::move(PCHBuffer)); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> Overlay( |
| new vfs::OverlayFileSystem(VFS)); |
| Overlay->pushOverlay(PCHFS); |
| return Overlay; |
| } |
| |
| /// Keeps a track of files to be deleted in destructor. |
| class TemporaryFiles { |
| public: |
| // A static instance to be used by all clients. |
| static TemporaryFiles &getInstance(); |
| |
| private: |
| // Disallow constructing the class directly. |
| TemporaryFiles() = default; |
| // Disallow copy. |
| TemporaryFiles(const TemporaryFiles &) = delete; |
| |
| public: |
| ~TemporaryFiles(); |
| |
| /// Adds \p File to a set of tracked files. |
| void addFile(StringRef File); |
| |
| /// Remove \p File from disk and from the set of tracked files. |
| void removeFile(StringRef File); |
| |
| private: |
| llvm::sys::SmartMutex<false> Mutex; |
| llvm::StringSet<> Files; |
| }; |
| |
| TemporaryFiles &TemporaryFiles::getInstance() { |
| static TemporaryFiles Instance; |
| return Instance; |
| } |
| |
| TemporaryFiles::~TemporaryFiles() { |
| llvm::MutexGuard Guard(Mutex); |
| for (const auto &File : Files) |
| llvm::sys::fs::remove(File.getKey()); |
| } |
| |
| void TemporaryFiles::addFile(StringRef File) { |
| llvm::MutexGuard Guard(Mutex); |
| auto IsInserted = Files.insert(File).second; |
| (void)IsInserted; |
| assert(IsInserted && "File has already been added"); |
| } |
| |
| void TemporaryFiles::removeFile(StringRef File) { |
| llvm::MutexGuard Guard(Mutex); |
| auto WasPresent = Files.erase(File); |
| (void)WasPresent; |
| assert(WasPresent && "File was not tracked"); |
| llvm::sys::fs::remove(File); |
| } |
| |
| class PrecompilePreambleAction : public ASTFrontendAction { |
| public: |
| PrecompilePreambleAction(std::string *InMemStorage, |
| PreambleCallbacks &Callbacks) |
| : InMemStorage(InMemStorage), Callbacks(Callbacks) {} |
| |
| std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, |
| StringRef InFile) override; |
| |
| bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } |
| |
| void setEmittedPreamblePCH(ASTWriter &Writer) { |
| this->HasEmittedPreamblePCH = true; |
| Callbacks.AfterPCHEmitted(Writer); |
| } |
| |
| bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } |
| bool hasCodeCompletionSupport() const override { return false; } |
| bool hasASTFileSupport() const override { return false; } |
| TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; } |
| |
| private: |
| friend class PrecompilePreambleConsumer; |
| |
| bool HasEmittedPreamblePCH = false; |
| std::string *InMemStorage; |
| PreambleCallbacks &Callbacks; |
| }; |
| |
| class PrecompilePreambleConsumer : public PCHGenerator { |
| public: |
| PrecompilePreambleConsumer(PrecompilePreambleAction &Action, |
| const Preprocessor &PP, StringRef isysroot, |
| std::unique_ptr<raw_ostream> Out) |
| : PCHGenerator(PP, "", isysroot, std::make_shared<PCHBuffer>(), |
| ArrayRef<std::shared_ptr<ModuleFileExtension>>(), |
| /*AllowASTWithErrors=*/true), |
| Action(Action), Out(std::move(Out)) {} |
| |
| bool HandleTopLevelDecl(DeclGroupRef DG) override { |
| Action.Callbacks.HandleTopLevelDecl(DG); |
| return true; |
| } |
| |
| void HandleTranslationUnit(ASTContext &Ctx) override { |
| PCHGenerator::HandleTranslationUnit(Ctx); |
| if (!hasEmittedPCH()) |
| return; |
| |
| // Write the generated bitstream to "Out". |
| *Out << getPCH(); |
| // Make sure it hits disk now. |
| Out->flush(); |
| // Free the buffer. |
| llvm::SmallVector<char, 0> Empty; |
| getPCH() = std::move(Empty); |
| |
| Action.setEmittedPreamblePCH(getWriter()); |
| } |
| |
| private: |
| PrecompilePreambleAction &Action; |
| std::unique_ptr<raw_ostream> Out; |
| }; |
| |
| std::unique_ptr<ASTConsumer> |
| PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, |
| StringRef InFile) { |
| std::string Sysroot; |
| if (!GeneratePCHAction::ComputeASTConsumerArguments(CI, Sysroot)) |
| return nullptr; |
| |
| std::unique_ptr<llvm::raw_ostream> OS; |
| if (InMemStorage) { |
| OS = llvm::make_unique<llvm::raw_string_ostream>(*InMemStorage); |
| } else { |
| std::string OutputFile; |
| OS = GeneratePCHAction::CreateOutputFile(CI, InFile, OutputFile); |
| } |
| if (!OS) |
| return nullptr; |
| |
| if (!CI.getFrontendOpts().RelocatablePCH) |
| Sysroot.clear(); |
| |
| return llvm::make_unique<PrecompilePreambleConsumer>( |
| *this, CI.getPreprocessor(), Sysroot, std::move(OS)); |
| } |
| |
| template <class T> bool moveOnNoError(llvm::ErrorOr<T> Val, T &Output) { |
| if (!Val) |
| return false; |
| Output = std::move(*Val); |
| return true; |
| } |
| |
| } // namespace |
| |
| PreambleBounds clang::ComputePreambleBounds(const LangOptions &LangOpts, |
| llvm::MemoryBuffer *Buffer, |
| unsigned MaxLines) { |
| return Lexer::ComputePreamble(Buffer->getBuffer(), LangOpts, MaxLines); |
| } |
| |
| llvm::ErrorOr<PrecompiledPreamble> PrecompiledPreamble::Build( |
| const CompilerInvocation &Invocation, |
| const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds, |
| DiagnosticsEngine &Diagnostics, IntrusiveRefCntPtr<vfs::FileSystem> VFS, |
| std::shared_ptr<PCHContainerOperations> PCHContainerOps, bool StoreInMemory, |
| PreambleCallbacks &Callbacks) { |
| assert(VFS && "VFS is null"); |
| |
| if (!Bounds.Size) |
| return BuildPreambleError::PreambleIsEmpty; |
| |
| auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation); |
| FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); |
| PreprocessorOptions &PreprocessorOpts = |
| PreambleInvocation->getPreprocessorOpts(); |
| |
| llvm::Optional<TempPCHFile> TempFile; |
| if (!StoreInMemory) { |
| // Create a temporary file for the precompiled preamble. In rare |
| // circumstances, this can fail. |
| llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> PreamblePCHFile = |
| PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile(); |
| if (!PreamblePCHFile) |
| return BuildPreambleError::CouldntCreateTempFile; |
| TempFile = std::move(*PreamblePCHFile); |
| } |
| |
| PCHStorage Storage = StoreInMemory ? PCHStorage(InMemoryPreamble()) |
| : PCHStorage(std::move(*TempFile)); |
| |
| // Save the preamble text for later; we'll need to compare against it for |
| // subsequent reparses. |
| std::vector<char> PreambleBytes(MainFileBuffer->getBufferStart(), |
| MainFileBuffer->getBufferStart() + |
| Bounds.Size); |
| bool PreambleEndsAtStartOfLine = Bounds.PreambleEndsAtStartOfLine; |
| |
| // Tell the compiler invocation to generate a temporary precompiled header. |
| FrontendOpts.ProgramAction = frontend::GeneratePCH; |
| FrontendOpts.OutputFile = StoreInMemory ? getInMemoryPreamblePath() |
| : Storage.asFile().getFilePath(); |
| PreprocessorOpts.PrecompiledPreambleBytes.first = 0; |
| PreprocessorOpts.PrecompiledPreambleBytes.second = false; |
| // Inform preprocessor to record conditional stack when building the preamble. |
| PreprocessorOpts.GeneratePreamble = true; |
| |
| // Create the compiler instance to use for building the precompiled preamble. |
| std::unique_ptr<CompilerInstance> Clang( |
| new CompilerInstance(std::move(PCHContainerOps))); |
| |
| // Recover resources if we crash before exiting this method. |
| llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> CICleanup( |
| Clang.get()); |
| |
| Clang->setInvocation(std::move(PreambleInvocation)); |
| Clang->setDiagnostics(&Diagnostics); |
| |
| // Create the target instance. |
| Clang->setTarget(TargetInfo::CreateTargetInfo( |
| Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); |
| if (!Clang->hasTarget()) |
| return BuildPreambleError::CouldntCreateTargetInfo; |
| |
| // 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. |
| Clang->getTarget().adjust(Clang->getLangOpts()); |
| |
| assert(Clang->getFrontendOpts().Inputs.size() == 1 && |
| "Invocation must have exactly one source file!"); |
| assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() == |
| InputKind::Source && |
| "FIXME: AST inputs not yet supported here!"); |
| assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() != |
| InputKind::LLVM_IR && |
| "IR inputs not support here!"); |
| |
| // Clear out old caches and data. |
| Diagnostics.Reset(); |
| ProcessWarningOptions(Diagnostics, Clang->getDiagnosticOpts()); |
| |
| VFS = |
| createVFSFromCompilerInvocation(Clang->getInvocation(), Diagnostics, VFS); |
| if (!VFS) |
| return BuildPreambleError::CouldntCreateVFSOverlay; |
| |
| // Create a file manager object to provide access to and cache the filesystem. |
| Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS)); |
| |
| // Create the source manager. |
| Clang->setSourceManager( |
| new SourceManager(Diagnostics, Clang->getFileManager())); |
| |
| auto PreambleDepCollector = std::make_shared<DependencyCollector>(); |
| Clang->addDependencyCollector(PreambleDepCollector); |
| |
| // Remap the main source file to the preamble buffer. |
| StringRef MainFilePath = FrontendOpts.Inputs[0].getFile(); |
| auto PreambleInputBuffer = llvm::MemoryBuffer::getMemBufferCopy( |
| MainFileBuffer->getBuffer().slice(0, Bounds.Size), MainFilePath); |
| if (PreprocessorOpts.RetainRemappedFileBuffers) { |
| // MainFileBuffer will be deleted by unique_ptr after leaving the method. |
| PreprocessorOpts.addRemappedFile(MainFilePath, PreambleInputBuffer.get()); |
| } else { |
| // In that case, remapped buffer will be deleted by CompilerInstance on |
| // BeginSourceFile, so we call release() to avoid double deletion. |
| PreprocessorOpts.addRemappedFile(MainFilePath, |
| PreambleInputBuffer.release()); |
| } |
| |
| std::unique_ptr<PrecompilePreambleAction> Act; |
| Act.reset(new PrecompilePreambleAction( |
| StoreInMemory ? &Storage.asMemory().Data : nullptr, Callbacks)); |
| Callbacks.BeforeExecute(*Clang); |
| if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) |
| return BuildPreambleError::BeginSourceFileFailed; |
| |
| std::unique_ptr<PPCallbacks> DelegatedPPCallbacks = |
| Callbacks.createPPCallbacks(); |
| if (DelegatedPPCallbacks) |
| Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks)); |
| |
| Act->Execute(); |
| |
| // Run the callbacks. |
| Callbacks.AfterExecute(*Clang); |
| |
| Act->EndSourceFile(); |
| |
| if (!Act->hasEmittedPreamblePCH()) |
| return BuildPreambleError::CouldntEmitPCH; |
| |
| // Keep track of all of the files that the source manager knows about, |
| // so we can verify whether they have changed or not. |
| llvm::StringMap<PrecompiledPreamble::PreambleFileHash> FilesInPreamble; |
| |
| SourceManager &SourceMgr = Clang->getSourceManager(); |
| for (auto &Filename : PreambleDepCollector->getDependencies()) { |
| const FileEntry *File = Clang->getFileManager().getFile(Filename); |
| if (!File || File == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())) |
| continue; |
| if (time_t ModTime = File->getModificationTime()) { |
| FilesInPreamble[File->getName()] = |
| PrecompiledPreamble::PreambleFileHash::createForFile(File->getSize(), |
| ModTime); |
| } else { |
| llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File); |
| FilesInPreamble[File->getName()] = |
| PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(Buffer); |
| } |
| } |
| |
| return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes), |
| PreambleEndsAtStartOfLine, |
| std::move(FilesInPreamble)); |
| } |
| |
| PreambleBounds PrecompiledPreamble::getBounds() const { |
| return PreambleBounds(PreambleBytes.size(), PreambleEndsAtStartOfLine); |
| } |
| |
| std::size_t PrecompiledPreamble::getSize() const { |
| switch (Storage.getKind()) { |
| case PCHStorage::Kind::Empty: |
| assert(false && "Calling getSize() on invalid PrecompiledPreamble. " |
| "Was it std::moved?"); |
| return 0; |
| case PCHStorage::Kind::InMemory: |
| return Storage.asMemory().Data.size(); |
| case PCHStorage::Kind::TempFile: { |
| uint64_t Result; |
| if (llvm::sys::fs::file_size(Storage.asFile().getFilePath(), Result)) |
| return 0; |
| |
| assert(Result <= std::numeric_limits<std::size_t>::max() && |
| "file size did not fit into size_t"); |
| return Result; |
| } |
| } |
| llvm_unreachable("Unhandled storage kind"); |
| } |
| |
| bool PrecompiledPreamble::CanReuse(const CompilerInvocation &Invocation, |
| const llvm::MemoryBuffer *MainFileBuffer, |
| PreambleBounds Bounds, |
| vfs::FileSystem *VFS) const { |
| |
| assert( |
| Bounds.Size <= MainFileBuffer->getBufferSize() && |
| "Buffer is too large. Bounds were calculated from a different buffer?"); |
| |
| auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation); |
| PreprocessorOptions &PreprocessorOpts = |
| PreambleInvocation->getPreprocessorOpts(); |
| |
| if (!Bounds.Size) |
| return false; |
| |
| // We've previously computed a preamble. Check whether we have the same |
| // preamble now that we did before, and that there's enough space in |
| // the main-file buffer within the precompiled preamble to fit the |
| // new main file. |
| if (PreambleBytes.size() != Bounds.Size || |
| PreambleEndsAtStartOfLine != Bounds.PreambleEndsAtStartOfLine || |
| memcmp(PreambleBytes.data(), MainFileBuffer->getBufferStart(), |
| Bounds.Size) != 0) |
| return false; |
| // The preamble has not changed. We may be able to re-use the precompiled |
| // preamble. |
| |
| // Check that none of the files used by the preamble have changed. |
| // First, make a record of those files that have been overridden via |
| // remapping or unsaved_files. |
| std::map<llvm::sys::fs::UniqueID, PreambleFileHash> OverriddenFiles; |
| for (const auto &R : PreprocessorOpts.RemappedFiles) { |
| vfs::Status Status; |
| if (!moveOnNoError(VFS->status(R.second), Status)) { |
| // If we can't stat the file we're remapping to, assume that something |
| // horrible happened. |
| return false; |
| } |
| |
| OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile( |
| Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime())); |
| } |
| |
| for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { |
| vfs::Status Status; |
| if (!moveOnNoError(VFS->status(RB.first), Status)) |
| return false; |
| |
| OverriddenFiles[Status.getUniqueID()] = |
| PreambleFileHash::createForMemoryBuffer(RB.second); |
| } |
| |
| // Check whether anything has changed. |
| for (const auto &F : FilesInPreamble) { |
| vfs::Status Status; |
| if (!moveOnNoError(VFS->status(F.first()), Status)) { |
| // If we can't stat the file, assume that something horrible happened. |
| return false; |
| } |
| |
| std::map<llvm::sys::fs::UniqueID, PreambleFileHash>::iterator Overridden = |
| OverriddenFiles.find(Status.getUniqueID()); |
| if (Overridden != OverriddenFiles.end()) { |
| // This file was remapped; check whether the newly-mapped file |
| // matches up with the previous mapping. |
| if (Overridden->second != F.second) |
| return false; |
| continue; |
| } |
| |
| // The file was not remapped; check whether it has changed on disk. |
| if (Status.getSize() != uint64_t(F.second.Size) || |
| llvm::sys::toTimeT(Status.getLastModificationTime()) != |
| F.second.ModTime) |
| return false; |
| } |
| return true; |
| } |
| |
| void PrecompiledPreamble::AddImplicitPreamble( |
| CompilerInvocation &CI, IntrusiveRefCntPtr<vfs::FileSystem> &VFS, |
| llvm::MemoryBuffer *MainFileBuffer) const { |
| assert(VFS && "VFS must not be null"); |
| |
| auto &PreprocessorOpts = CI.getPreprocessorOpts(); |
| |
| // Remap main file to point to MainFileBuffer. |
| auto MainFilePath = CI.getFrontendOpts().Inputs[0].getFile(); |
| PreprocessorOpts.addRemappedFile(MainFilePath, MainFileBuffer); |
| |
| // Configure ImpicitPCHInclude. |
| PreprocessorOpts.PrecompiledPreambleBytes.first = PreambleBytes.size(); |
| PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; |
| PreprocessorOpts.DisablePCHValidation = true; |
| |
| setupPreambleStorage(Storage, PreprocessorOpts, VFS); |
| } |
| |
| PrecompiledPreamble::PrecompiledPreamble( |
| PCHStorage Storage, std::vector<char> PreambleBytes, |
| bool PreambleEndsAtStartOfLine, |
| llvm::StringMap<PreambleFileHash> FilesInPreamble) |
| : Storage(std::move(Storage)), FilesInPreamble(std::move(FilesInPreamble)), |
| PreambleBytes(std::move(PreambleBytes)), |
| PreambleEndsAtStartOfLine(PreambleEndsAtStartOfLine) { |
| assert(this->Storage.getKind() != PCHStorage::Kind::Empty); |
| } |
| |
| llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> |
| PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile() { |
| // FIXME: This is a hack so that we can override the preamble file during |
| // crash-recovery testing, which is the only case where the preamble files |
| // are not necessarily cleaned up. |
| const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); |
| if (TmpFile) |
| return TempPCHFile::createFromCustomPath(TmpFile); |
| return TempPCHFile::createInSystemTempDir("preamble", "pch"); |
| } |
| |
| llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> |
| PrecompiledPreamble::TempPCHFile::createInSystemTempDir(const Twine &Prefix, |
| StringRef Suffix) { |
| llvm::SmallString<64> File; |
| // Using a version of createTemporaryFile with a file descriptor guarantees |
| // that we would never get a race condition in a multi-threaded setting |
| // (i.e., multiple threads getting the same temporary path). |
| int FD; |
| auto EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, FD, File); |
| if (EC) |
| return EC; |
| // We only needed to make sure the file exists, close the file right away. |
| llvm::sys::Process::SafelyCloseFileDescriptor(FD); |
| return TempPCHFile(std::move(File).str()); |
| } |
| |
| llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> |
| PrecompiledPreamble::TempPCHFile::createFromCustomPath(const Twine &Path) { |
| return TempPCHFile(Path.str()); |
| } |
| |
| PrecompiledPreamble::TempPCHFile::TempPCHFile(std::string FilePath) |
| : FilePath(std::move(FilePath)) { |
| TemporaryFiles::getInstance().addFile(*this->FilePath); |
| } |
| |
| PrecompiledPreamble::TempPCHFile::TempPCHFile(TempPCHFile &&Other) { |
| FilePath = std::move(Other.FilePath); |
| Other.FilePath = None; |
| } |
| |
| PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::TempPCHFile:: |
| operator=(TempPCHFile &&Other) { |
| RemoveFileIfPresent(); |
| |
| FilePath = std::move(Other.FilePath); |
| Other.FilePath = None; |
| return *this; |
| } |
| |
| PrecompiledPreamble::TempPCHFile::~TempPCHFile() { RemoveFileIfPresent(); } |
| |
| void PrecompiledPreamble::TempPCHFile::RemoveFileIfPresent() { |
| if (FilePath) { |
| TemporaryFiles::getInstance().removeFile(*FilePath); |
| FilePath = None; |
| } |
| } |
| |
| llvm::StringRef PrecompiledPreamble::TempPCHFile::getFilePath() const { |
| assert(FilePath && "TempPCHFile doesn't have a FilePath. Had it been moved?"); |
| return *FilePath; |
| } |
| |
| PrecompiledPreamble::PCHStorage::PCHStorage(TempPCHFile File) |
| : StorageKind(Kind::TempFile) { |
| new (&asFile()) TempPCHFile(std::move(File)); |
| } |
| |
| PrecompiledPreamble::PCHStorage::PCHStorage(InMemoryPreamble Memory) |
| : StorageKind(Kind::InMemory) { |
| new (&asMemory()) InMemoryPreamble(std::move(Memory)); |
| } |
| |
| PrecompiledPreamble::PCHStorage::PCHStorage(PCHStorage &&Other) : PCHStorage() { |
| *this = std::move(Other); |
| } |
| |
| PrecompiledPreamble::PCHStorage &PrecompiledPreamble::PCHStorage:: |
| operator=(PCHStorage &&Other) { |
| destroy(); |
| |
| StorageKind = Other.StorageKind; |
| switch (StorageKind) { |
| case Kind::Empty: |
| // do nothing; |
| break; |
| case Kind::TempFile: |
| new (&asFile()) TempPCHFile(std::move(Other.asFile())); |
| break; |
| case Kind::InMemory: |
| new (&asMemory()) InMemoryPreamble(std::move(Other.asMemory())); |
| break; |
| } |
| |
| Other.setEmpty(); |
| return *this; |
| } |
| |
| PrecompiledPreamble::PCHStorage::~PCHStorage() { destroy(); } |
| |
| PrecompiledPreamble::PCHStorage::Kind |
| PrecompiledPreamble::PCHStorage::getKind() const { |
| return StorageKind; |
| } |
| |
| PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::PCHStorage::asFile() { |
| assert(getKind() == Kind::TempFile); |
| return *reinterpret_cast<TempPCHFile *>(Storage.buffer); |
| } |
| |
| const PrecompiledPreamble::TempPCHFile & |
| PrecompiledPreamble::PCHStorage::asFile() const { |
| return const_cast<PCHStorage *>(this)->asFile(); |
| } |
| |
| PrecompiledPreamble::InMemoryPreamble & |
| PrecompiledPreamble::PCHStorage::asMemory() { |
| assert(getKind() == Kind::InMemory); |
| return *reinterpret_cast<InMemoryPreamble *>(Storage.buffer); |
| } |
| |
| const PrecompiledPreamble::InMemoryPreamble & |
| PrecompiledPreamble::PCHStorage::asMemory() const { |
| return const_cast<PCHStorage *>(this)->asMemory(); |
| } |
| |
| void PrecompiledPreamble::PCHStorage::destroy() { |
| switch (StorageKind) { |
| case Kind::Empty: |
| return; |
| case Kind::TempFile: |
| asFile().~TempPCHFile(); |
| return; |
| case Kind::InMemory: |
| asMemory().~InMemoryPreamble(); |
| return; |
| } |
| } |
| |
| void PrecompiledPreamble::PCHStorage::setEmpty() { |
| destroy(); |
| StorageKind = Kind::Empty; |
| } |
| |
| PrecompiledPreamble::PreambleFileHash |
| PrecompiledPreamble::PreambleFileHash::createForFile(off_t Size, |
| time_t ModTime) { |
| PreambleFileHash Result; |
| Result.Size = Size; |
| Result.ModTime = ModTime; |
| Result.MD5 = {}; |
| return Result; |
| } |
| |
| PrecompiledPreamble::PreambleFileHash |
| PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer( |
| const llvm::MemoryBuffer *Buffer) { |
| PreambleFileHash Result; |
| Result.Size = Buffer->getBufferSize(); |
| Result.ModTime = 0; |
| |
| llvm::MD5 MD5Ctx; |
| MD5Ctx.update(Buffer->getBuffer().data()); |
| MD5Ctx.final(Result.MD5); |
| |
| return Result; |
| } |
| |
| void PrecompiledPreamble::setupPreambleStorage( |
| const PCHStorage &Storage, PreprocessorOptions &PreprocessorOpts, |
| IntrusiveRefCntPtr<vfs::FileSystem> &VFS) { |
| if (Storage.getKind() == PCHStorage::Kind::TempFile) { |
| const TempPCHFile &PCHFile = Storage.asFile(); |
| PreprocessorOpts.ImplicitPCHInclude = PCHFile.getFilePath(); |
| |
| // Make sure we can access the PCH file even if we're using a VFS |
| IntrusiveRefCntPtr<vfs::FileSystem> RealFS = vfs::getRealFileSystem(); |
| auto PCHPath = PCHFile.getFilePath(); |
| if (VFS == RealFS || VFS->exists(PCHPath)) |
| return; |
| auto Buf = RealFS->getBufferForFile(PCHPath); |
| if (!Buf) { |
| // We can't read the file even from RealFS, this is clearly an error, |
| // but we'll just leave the current VFS as is and let clang's code |
| // figure out what to do with missing PCH. |
| return; |
| } |
| |
| // We have a slight inconsistency here -- we're using the VFS to |
| // read files, but the PCH was generated in the real file system. |
| VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(*Buf), VFS); |
| } else { |
| assert(Storage.getKind() == PCHStorage::Kind::InMemory); |
| // For in-memory preamble, we have to provide a VFS overlay that makes it |
| // accessible. |
| StringRef PCHPath = getInMemoryPreamblePath(); |
| PreprocessorOpts.ImplicitPCHInclude = PCHPath; |
| |
| auto Buf = llvm::MemoryBuffer::getMemBuffer(Storage.asMemory().Data); |
| VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS); |
| } |
| } |
| |
| void PreambleCallbacks::BeforeExecute(CompilerInstance &CI) {} |
| void PreambleCallbacks::AfterExecute(CompilerInstance &CI) {} |
| void PreambleCallbacks::AfterPCHEmitted(ASTWriter &Writer) {} |
| void PreambleCallbacks::HandleTopLevelDecl(DeclGroupRef DG) {} |
| std::unique_ptr<PPCallbacks> PreambleCallbacks::createPPCallbacks() { |
| return nullptr; |
| } |
| |
| std::error_code clang::make_error_code(BuildPreambleError Error) { |
| return std::error_code(static_cast<int>(Error), BuildPreambleErrorCategory()); |
| } |
| |
| const char *BuildPreambleErrorCategory::name() const noexcept { |
| return "build-preamble.error"; |
| } |
| |
| std::string BuildPreambleErrorCategory::message(int condition) const { |
| switch (static_cast<BuildPreambleError>(condition)) { |
| case BuildPreambleError::PreambleIsEmpty: |
| return "Preamble is empty"; |
| case BuildPreambleError::CouldntCreateTempFile: |
| return "Could not create temporary file for PCH"; |
| case BuildPreambleError::CouldntCreateTargetInfo: |
| return "CreateTargetInfo() return null"; |
| case BuildPreambleError::CouldntCreateVFSOverlay: |
| return "Could not create VFS Overlay"; |
| case BuildPreambleError::BeginSourceFileFailed: |
| return "BeginSourceFile() return an error"; |
| case BuildPreambleError::CouldntEmitPCH: |
| return "Could not emit PCH"; |
| } |
| llvm_unreachable("unexpected BuildPreambleError"); |
| } |