1 //===--- PrecompiledPreamble.cpp - Build precompiled preambles --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Helper class to build precompiled preamble.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Frontend/PrecompiledPreamble.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Frontend/CompilerInstance.h"
18 #include "clang/Frontend/CompilerInvocation.h"
19 #include "clang/Frontend/FrontendActions.h"
20 #include "clang/Frontend/FrontendOptions.h"
21 #include "clang/Lex/Lexer.h"
22 #include "clang/Lex/PreprocessorOptions.h"
23 #include "clang/Serialization/ASTWriter.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/ADT/StringSet.h"
26 #include "llvm/Config/llvm-config.h"
27 #include "llvm/Support/CrashRecoveryContext.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/Mutex.h"
30 #include "llvm/Support/MutexGuard.h"
31 #include "llvm/Support/Process.h"
32 #include "llvm/Support/VirtualFileSystem.h"
36 using namespace clang;
40 StringRef getInMemoryPreamblePath() {
41 #if defined(LLVM_ON_UNIX)
42 return "/__clang_tmp/___clang_inmemory_preamble___";
44 return "C:\\__clang_tmp\\___clang_inmemory_preamble___";
46 #warning "Unknown platform. Defaulting to UNIX-style paths for in-memory PCHs"
47 return "/__clang_tmp/___clang_inmemory_preamble___";
51 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
52 createVFSOverlayForPreamblePCH(StringRef PCHFilename,
53 std::unique_ptr<llvm::MemoryBuffer> PCHBuffer,
54 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
55 // We want only the PCH file from the real filesystem to be available,
56 // so we create an in-memory VFS with just that and overlay it on top.
57 IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> PCHFS(
58 new llvm::vfs::InMemoryFileSystem());
59 PCHFS->addFile(PCHFilename, 0, std::move(PCHBuffer));
60 IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> Overlay(
61 new llvm::vfs::OverlayFileSystem(VFS));
62 Overlay->pushOverlay(PCHFS);
66 class PreambleDependencyCollector : public DependencyCollector {
68 // We want to collect all dependencies for correctness. Avoiding the real
69 // system dependencies (e.g. stl from /usr/lib) would probably be a good idea,
70 // but there is no way to distinguish between those and the ones that can be
71 // spuriously added by '-isystem' (e.g. to suppress warnings from those
73 bool needSystemDependencies() override { return true; }
76 /// Keeps a track of files to be deleted in destructor.
77 class TemporaryFiles {
79 // A static instance to be used by all clients.
80 static TemporaryFiles &getInstance();
83 // Disallow constructing the class directly.
84 TemporaryFiles() = default;
86 TemporaryFiles(const TemporaryFiles &) = delete;
91 /// Adds \p File to a set of tracked files.
92 void addFile(StringRef File);
94 /// Remove \p File from disk and from the set of tracked files.
95 void removeFile(StringRef File);
98 llvm::sys::SmartMutex<false> Mutex;
99 llvm::StringSet<> Files;
102 TemporaryFiles &TemporaryFiles::getInstance() {
103 static TemporaryFiles Instance;
107 TemporaryFiles::~TemporaryFiles() {
108 llvm::MutexGuard Guard(Mutex);
109 for (const auto &File : Files)
110 llvm::sys::fs::remove(File.getKey());
113 void TemporaryFiles::addFile(StringRef File) {
114 llvm::MutexGuard Guard(Mutex);
115 auto IsInserted = Files.insert(File).second;
117 assert(IsInserted && "File has already been added");
120 void TemporaryFiles::removeFile(StringRef File) {
121 llvm::MutexGuard Guard(Mutex);
122 auto WasPresent = Files.erase(File);
124 assert(WasPresent && "File was not tracked");
125 llvm::sys::fs::remove(File);
128 class PrecompilePreambleAction : public ASTFrontendAction {
130 PrecompilePreambleAction(std::string *InMemStorage,
131 PreambleCallbacks &Callbacks)
132 : InMemStorage(InMemStorage), Callbacks(Callbacks) {}
134 std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
135 StringRef InFile) override;
137 bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; }
139 void setEmittedPreamblePCH(ASTWriter &Writer) {
140 this->HasEmittedPreamblePCH = true;
141 Callbacks.AfterPCHEmitted(Writer);
144 bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); }
145 bool hasCodeCompletionSupport() const override { return false; }
146 bool hasASTFileSupport() const override { return false; }
147 TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; }
150 friend class PrecompilePreambleConsumer;
152 bool HasEmittedPreamblePCH = false;
153 std::string *InMemStorage;
154 PreambleCallbacks &Callbacks;
157 class PrecompilePreambleConsumer : public PCHGenerator {
159 PrecompilePreambleConsumer(PrecompilePreambleAction &Action,
160 const Preprocessor &PP, StringRef isysroot,
161 std::unique_ptr<raw_ostream> Out)
162 : PCHGenerator(PP, "", isysroot, std::make_shared<PCHBuffer>(),
163 ArrayRef<std::shared_ptr<ModuleFileExtension>>(),
164 /*AllowASTWithErrors=*/true),
165 Action(Action), Out(std::move(Out)) {}
167 bool HandleTopLevelDecl(DeclGroupRef DG) override {
168 Action.Callbacks.HandleTopLevelDecl(DG);
172 void HandleTranslationUnit(ASTContext &Ctx) override {
173 PCHGenerator::HandleTranslationUnit(Ctx);
174 if (!hasEmittedPCH())
177 // Write the generated bitstream to "Out".
179 // Make sure it hits disk now.
182 llvm::SmallVector<char, 0> Empty;
183 getPCH() = std::move(Empty);
185 Action.setEmittedPreamblePCH(getWriter());
189 PrecompilePreambleAction &Action;
190 std::unique_ptr<raw_ostream> Out;
193 std::unique_ptr<ASTConsumer>
194 PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
197 if (!GeneratePCHAction::ComputeASTConsumerArguments(CI, Sysroot))
200 std::unique_ptr<llvm::raw_ostream> OS;
202 OS = llvm::make_unique<llvm::raw_string_ostream>(*InMemStorage);
204 std::string OutputFile;
205 OS = GeneratePCHAction::CreateOutputFile(CI, InFile, OutputFile);
210 if (!CI.getFrontendOpts().RelocatablePCH)
213 return llvm::make_unique<PrecompilePreambleConsumer>(
214 *this, CI.getPreprocessor(), Sysroot, std::move(OS));
217 template <class T> bool moveOnNoError(llvm::ErrorOr<T> Val, T &Output) {
220 Output = std::move(*Val);
226 PreambleBounds clang::ComputePreambleBounds(const LangOptions &LangOpts,
227 llvm::MemoryBuffer *Buffer,
229 return Lexer::ComputePreamble(Buffer->getBuffer(), LangOpts, MaxLines);
232 llvm::ErrorOr<PrecompiledPreamble> PrecompiledPreamble::Build(
233 const CompilerInvocation &Invocation,
234 const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds,
235 DiagnosticsEngine &Diagnostics,
236 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
237 std::shared_ptr<PCHContainerOperations> PCHContainerOps, bool StoreInMemory,
238 PreambleCallbacks &Callbacks) {
239 assert(VFS && "VFS is null");
241 auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
242 FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
243 PreprocessorOptions &PreprocessorOpts =
244 PreambleInvocation->getPreprocessorOpts();
246 llvm::Optional<TempPCHFile> TempFile;
247 if (!StoreInMemory) {
248 // Create a temporary file for the precompiled preamble. In rare
249 // circumstances, this can fail.
250 llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> PreamblePCHFile =
251 PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile();
252 if (!PreamblePCHFile)
253 return BuildPreambleError::CouldntCreateTempFile;
254 TempFile = std::move(*PreamblePCHFile);
257 PCHStorage Storage = StoreInMemory ? PCHStorage(InMemoryPreamble())
258 : PCHStorage(std::move(*TempFile));
260 // Save the preamble text for later; we'll need to compare against it for
261 // subsequent reparses.
262 std::vector<char> PreambleBytes(MainFileBuffer->getBufferStart(),
263 MainFileBuffer->getBufferStart() +
265 bool PreambleEndsAtStartOfLine = Bounds.PreambleEndsAtStartOfLine;
267 // Tell the compiler invocation to generate a temporary precompiled header.
268 FrontendOpts.ProgramAction = frontend::GeneratePCH;
269 FrontendOpts.OutputFile = StoreInMemory ? getInMemoryPreamblePath()
270 : Storage.asFile().getFilePath();
271 PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
272 PreprocessorOpts.PrecompiledPreambleBytes.second = false;
273 // Inform preprocessor to record conditional stack when building the preamble.
274 PreprocessorOpts.GeneratePreamble = true;
276 // Create the compiler instance to use for building the precompiled preamble.
277 std::unique_ptr<CompilerInstance> Clang(
278 new CompilerInstance(std::move(PCHContainerOps)));
280 // Recover resources if we crash before exiting this method.
281 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> CICleanup(
284 Clang->setInvocation(std::move(PreambleInvocation));
285 Clang->setDiagnostics(&Diagnostics);
287 // Create the target instance.
288 Clang->setTarget(TargetInfo::CreateTargetInfo(
289 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
290 if (!Clang->hasTarget())
291 return BuildPreambleError::CouldntCreateTargetInfo;
293 // Inform the target of the language options.
295 // FIXME: We shouldn't need to do this, the target should be immutable once
296 // created. This complexity should be lifted elsewhere.
297 Clang->getTarget().adjust(Clang->getLangOpts());
299 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
300 "Invocation must have exactly one source file!");
301 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
303 "FIXME: AST inputs not yet supported here!");
304 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
305 InputKind::LLVM_IR &&
306 "IR inputs not support here!");
308 // Clear out old caches and data.
310 ProcessWarningOptions(Diagnostics, Clang->getDiagnosticOpts());
313 createVFSFromCompilerInvocation(Clang->getInvocation(), Diagnostics, VFS);
315 // Create a file manager object to provide access to and cache the filesystem.
316 Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS));
318 // Create the source manager.
319 Clang->setSourceManager(
320 new SourceManager(Diagnostics, Clang->getFileManager()));
322 auto PreambleDepCollector = std::make_shared<PreambleDependencyCollector>();
323 Clang->addDependencyCollector(PreambleDepCollector);
325 // Remap the main source file to the preamble buffer.
326 StringRef MainFilePath = FrontendOpts.Inputs[0].getFile();
327 auto PreambleInputBuffer = llvm::MemoryBuffer::getMemBufferCopy(
328 MainFileBuffer->getBuffer().slice(0, Bounds.Size), MainFilePath);
329 if (PreprocessorOpts.RetainRemappedFileBuffers) {
330 // MainFileBuffer will be deleted by unique_ptr after leaving the method.
331 PreprocessorOpts.addRemappedFile(MainFilePath, PreambleInputBuffer.get());
333 // In that case, remapped buffer will be deleted by CompilerInstance on
334 // BeginSourceFile, so we call release() to avoid double deletion.
335 PreprocessorOpts.addRemappedFile(MainFilePath,
336 PreambleInputBuffer.release());
339 std::unique_ptr<PrecompilePreambleAction> Act;
340 Act.reset(new PrecompilePreambleAction(
341 StoreInMemory ? &Storage.asMemory().Data : nullptr, Callbacks));
342 Callbacks.BeforeExecute(*Clang);
343 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
344 return BuildPreambleError::BeginSourceFileFailed;
346 std::unique_ptr<PPCallbacks> DelegatedPPCallbacks =
347 Callbacks.createPPCallbacks();
348 if (DelegatedPPCallbacks)
349 Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks));
353 // Run the callbacks.
354 Callbacks.AfterExecute(*Clang);
356 Act->EndSourceFile();
358 if (!Act->hasEmittedPreamblePCH())
359 return BuildPreambleError::CouldntEmitPCH;
361 // Keep track of all of the files that the source manager knows about,
362 // so we can verify whether they have changed or not.
363 llvm::StringMap<PrecompiledPreamble::PreambleFileHash> FilesInPreamble;
365 SourceManager &SourceMgr = Clang->getSourceManager();
366 for (auto &Filename : PreambleDepCollector->getDependencies()) {
367 const FileEntry *File = Clang->getFileManager().getFile(Filename);
368 if (!File || File == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))
370 if (time_t ModTime = File->getModificationTime()) {
371 FilesInPreamble[File->getName()] =
372 PrecompiledPreamble::PreambleFileHash::createForFile(File->getSize(),
375 llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File);
376 FilesInPreamble[File->getName()] =
377 PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(Buffer);
381 return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes),
382 PreambleEndsAtStartOfLine,
383 std::move(FilesInPreamble));
386 PreambleBounds PrecompiledPreamble::getBounds() const {
387 return PreambleBounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);
390 std::size_t PrecompiledPreamble::getSize() const {
391 switch (Storage.getKind()) {
392 case PCHStorage::Kind::Empty:
393 assert(false && "Calling getSize() on invalid PrecompiledPreamble. "
394 "Was it std::moved?");
396 case PCHStorage::Kind::InMemory:
397 return Storage.asMemory().Data.size();
398 case PCHStorage::Kind::TempFile: {
400 if (llvm::sys::fs::file_size(Storage.asFile().getFilePath(), Result))
403 assert(Result <= std::numeric_limits<std::size_t>::max() &&
404 "file size did not fit into size_t");
408 llvm_unreachable("Unhandled storage kind");
411 bool PrecompiledPreamble::CanReuse(const CompilerInvocation &Invocation,
412 const llvm::MemoryBuffer *MainFileBuffer,
413 PreambleBounds Bounds,
414 llvm::vfs::FileSystem *VFS) const {
417 Bounds.Size <= MainFileBuffer->getBufferSize() &&
418 "Buffer is too large. Bounds were calculated from a different buffer?");
420 auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
421 PreprocessorOptions &PreprocessorOpts =
422 PreambleInvocation->getPreprocessorOpts();
424 // We've previously computed a preamble. Check whether we have the same
425 // preamble now that we did before, and that there's enough space in
426 // the main-file buffer within the precompiled preamble to fit the
428 if (PreambleBytes.size() != Bounds.Size ||
429 PreambleEndsAtStartOfLine != Bounds.PreambleEndsAtStartOfLine ||
430 !std::equal(PreambleBytes.begin(), PreambleBytes.end(),
431 MainFileBuffer->getBuffer().begin()))
433 // The preamble has not changed. We may be able to re-use the precompiled
436 // Check that none of the files used by the preamble have changed.
437 // First, make a record of those files that have been overridden via
438 // remapping or unsaved_files.
439 std::map<llvm::sys::fs::UniqueID, PreambleFileHash> OverriddenFiles;
440 for (const auto &R : PreprocessorOpts.RemappedFiles) {
441 llvm::vfs::Status Status;
442 if (!moveOnNoError(VFS->status(R.second), Status)) {
443 // If we can't stat the file we're remapping to, assume that something
444 // horrible happened.
448 OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile(
449 Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime()));
452 for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
453 llvm::vfs::Status Status;
454 if (!moveOnNoError(VFS->status(RB.first), Status))
457 OverriddenFiles[Status.getUniqueID()] =
458 PreambleFileHash::createForMemoryBuffer(RB.second);
461 // Check whether anything has changed.
462 for (const auto &F : FilesInPreamble) {
463 llvm::vfs::Status Status;
464 if (!moveOnNoError(VFS->status(F.first()), Status)) {
465 // If we can't stat the file, assume that something horrible happened.
469 std::map<llvm::sys::fs::UniqueID, PreambleFileHash>::iterator Overridden =
470 OverriddenFiles.find(Status.getUniqueID());
471 if (Overridden != OverriddenFiles.end()) {
472 // This file was remapped; check whether the newly-mapped file
473 // matches up with the previous mapping.
474 if (Overridden->second != F.second)
479 // The file was not remapped; check whether it has changed on disk.
480 if (Status.getSize() != uint64_t(F.second.Size) ||
481 llvm::sys::toTimeT(Status.getLastModificationTime()) !=
488 void PrecompiledPreamble::AddImplicitPreamble(
489 CompilerInvocation &CI, IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
490 llvm::MemoryBuffer *MainFileBuffer) const {
491 PreambleBounds Bounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);
492 configurePreamble(Bounds, CI, VFS, MainFileBuffer);
495 void PrecompiledPreamble::OverridePreamble(
496 CompilerInvocation &CI, IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
497 llvm::MemoryBuffer *MainFileBuffer) const {
498 auto Bounds = ComputePreambleBounds(*CI.getLangOpts(), MainFileBuffer, 0);
499 configurePreamble(Bounds, CI, VFS, MainFileBuffer);
502 PrecompiledPreamble::PrecompiledPreamble(
503 PCHStorage Storage, std::vector<char> PreambleBytes,
504 bool PreambleEndsAtStartOfLine,
505 llvm::StringMap<PreambleFileHash> FilesInPreamble)
506 : Storage(std::move(Storage)), FilesInPreamble(std::move(FilesInPreamble)),
507 PreambleBytes(std::move(PreambleBytes)),
508 PreambleEndsAtStartOfLine(PreambleEndsAtStartOfLine) {
509 assert(this->Storage.getKind() != PCHStorage::Kind::Empty);
512 llvm::ErrorOr<PrecompiledPreamble::TempPCHFile>
513 PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile() {
514 // FIXME: This is a hack so that we can override the preamble file during
515 // crash-recovery testing, which is the only case where the preamble files
516 // are not necessarily cleaned up.
517 const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE");
519 return TempPCHFile::createFromCustomPath(TmpFile);
520 return TempPCHFile::createInSystemTempDir("preamble", "pch");
523 llvm::ErrorOr<PrecompiledPreamble::TempPCHFile>
524 PrecompiledPreamble::TempPCHFile::createInSystemTempDir(const Twine &Prefix,
526 llvm::SmallString<64> File;
527 // Using a version of createTemporaryFile with a file descriptor guarantees
528 // that we would never get a race condition in a multi-threaded setting
529 // (i.e., multiple threads getting the same temporary path).
531 auto EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, FD, File);
534 // We only needed to make sure the file exists, close the file right away.
535 llvm::sys::Process::SafelyCloseFileDescriptor(FD);
536 return TempPCHFile(std::move(File).str());
539 llvm::ErrorOr<PrecompiledPreamble::TempPCHFile>
540 PrecompiledPreamble::TempPCHFile::createFromCustomPath(const Twine &Path) {
541 return TempPCHFile(Path.str());
544 PrecompiledPreamble::TempPCHFile::TempPCHFile(std::string FilePath)
545 : FilePath(std::move(FilePath)) {
546 TemporaryFiles::getInstance().addFile(*this->FilePath);
549 PrecompiledPreamble::TempPCHFile::TempPCHFile(TempPCHFile &&Other) {
550 FilePath = std::move(Other.FilePath);
551 Other.FilePath = None;
554 PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::TempPCHFile::
555 operator=(TempPCHFile &&Other) {
556 RemoveFileIfPresent();
558 FilePath = std::move(Other.FilePath);
559 Other.FilePath = None;
563 PrecompiledPreamble::TempPCHFile::~TempPCHFile() { RemoveFileIfPresent(); }
565 void PrecompiledPreamble::TempPCHFile::RemoveFileIfPresent() {
567 TemporaryFiles::getInstance().removeFile(*FilePath);
572 llvm::StringRef PrecompiledPreamble::TempPCHFile::getFilePath() const {
573 assert(FilePath && "TempPCHFile doesn't have a FilePath. Had it been moved?");
577 PrecompiledPreamble::PCHStorage::PCHStorage(TempPCHFile File)
578 : StorageKind(Kind::TempFile) {
579 new (&asFile()) TempPCHFile(std::move(File));
582 PrecompiledPreamble::PCHStorage::PCHStorage(InMemoryPreamble Memory)
583 : StorageKind(Kind::InMemory) {
584 new (&asMemory()) InMemoryPreamble(std::move(Memory));
587 PrecompiledPreamble::PCHStorage::PCHStorage(PCHStorage &&Other) : PCHStorage() {
588 *this = std::move(Other);
591 PrecompiledPreamble::PCHStorage &PrecompiledPreamble::PCHStorage::
592 operator=(PCHStorage &&Other) {
595 StorageKind = Other.StorageKind;
596 switch (StorageKind) {
601 new (&asFile()) TempPCHFile(std::move(Other.asFile()));
604 new (&asMemory()) InMemoryPreamble(std::move(Other.asMemory()));
612 PrecompiledPreamble::PCHStorage::~PCHStorage() { destroy(); }
614 PrecompiledPreamble::PCHStorage::Kind
615 PrecompiledPreamble::PCHStorage::getKind() const {
619 PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::PCHStorage::asFile() {
620 assert(getKind() == Kind::TempFile);
621 return *reinterpret_cast<TempPCHFile *>(Storage.buffer);
624 const PrecompiledPreamble::TempPCHFile &
625 PrecompiledPreamble::PCHStorage::asFile() const {
626 return const_cast<PCHStorage *>(this)->asFile();
629 PrecompiledPreamble::InMemoryPreamble &
630 PrecompiledPreamble::PCHStorage::asMemory() {
631 assert(getKind() == Kind::InMemory);
632 return *reinterpret_cast<InMemoryPreamble *>(Storage.buffer);
635 const PrecompiledPreamble::InMemoryPreamble &
636 PrecompiledPreamble::PCHStorage::asMemory() const {
637 return const_cast<PCHStorage *>(this)->asMemory();
640 void PrecompiledPreamble::PCHStorage::destroy() {
641 switch (StorageKind) {
645 asFile().~TempPCHFile();
648 asMemory().~InMemoryPreamble();
653 void PrecompiledPreamble::PCHStorage::setEmpty() {
655 StorageKind = Kind::Empty;
658 PrecompiledPreamble::PreambleFileHash
659 PrecompiledPreamble::PreambleFileHash::createForFile(off_t Size,
661 PreambleFileHash Result;
663 Result.ModTime = ModTime;
668 PrecompiledPreamble::PreambleFileHash
669 PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(
670 const llvm::MemoryBuffer *Buffer) {
671 PreambleFileHash Result;
672 Result.Size = Buffer->getBufferSize();
676 MD5Ctx.update(Buffer->getBuffer().data());
677 MD5Ctx.final(Result.MD5);
682 void PrecompiledPreamble::configurePreamble(
683 PreambleBounds Bounds, CompilerInvocation &CI,
684 IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
685 llvm::MemoryBuffer *MainFileBuffer) const {
688 auto &PreprocessorOpts = CI.getPreprocessorOpts();
690 // Remap main file to point to MainFileBuffer.
691 auto MainFilePath = CI.getFrontendOpts().Inputs[0].getFile();
692 PreprocessorOpts.addRemappedFile(MainFilePath, MainFileBuffer);
694 // Configure ImpicitPCHInclude.
695 PreprocessorOpts.PrecompiledPreambleBytes.first = Bounds.Size;
696 PreprocessorOpts.PrecompiledPreambleBytes.second =
697 Bounds.PreambleEndsAtStartOfLine;
698 PreprocessorOpts.DisablePCHValidation = true;
700 setupPreambleStorage(Storage, PreprocessorOpts, VFS);
703 void PrecompiledPreamble::setupPreambleStorage(
704 const PCHStorage &Storage, PreprocessorOptions &PreprocessorOpts,
705 IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS) {
706 if (Storage.getKind() == PCHStorage::Kind::TempFile) {
707 const TempPCHFile &PCHFile = Storage.asFile();
708 PreprocessorOpts.ImplicitPCHInclude = PCHFile.getFilePath();
710 // Make sure we can access the PCH file even if we're using a VFS
711 IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS =
712 llvm::vfs::getRealFileSystem();
713 auto PCHPath = PCHFile.getFilePath();
714 if (VFS == RealFS || VFS->exists(PCHPath))
716 auto Buf = RealFS->getBufferForFile(PCHPath);
718 // We can't read the file even from RealFS, this is clearly an error,
719 // but we'll just leave the current VFS as is and let clang's code
720 // figure out what to do with missing PCH.
724 // We have a slight inconsistency here -- we're using the VFS to
725 // read files, but the PCH was generated in the real file system.
726 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(*Buf), VFS);
728 assert(Storage.getKind() == PCHStorage::Kind::InMemory);
729 // For in-memory preamble, we have to provide a VFS overlay that makes it
731 StringRef PCHPath = getInMemoryPreamblePath();
732 PreprocessorOpts.ImplicitPCHInclude = PCHPath;
734 auto Buf = llvm::MemoryBuffer::getMemBuffer(Storage.asMemory().Data);
735 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS);
739 void PreambleCallbacks::BeforeExecute(CompilerInstance &CI) {}
740 void PreambleCallbacks::AfterExecute(CompilerInstance &CI) {}
741 void PreambleCallbacks::AfterPCHEmitted(ASTWriter &Writer) {}
742 void PreambleCallbacks::HandleTopLevelDecl(DeclGroupRef DG) {}
743 std::unique_ptr<PPCallbacks> PreambleCallbacks::createPPCallbacks() {
747 static llvm::ManagedStatic<BuildPreambleErrorCategory> BuildPreambleErrCategory;
749 std::error_code clang::make_error_code(BuildPreambleError Error) {
750 return std::error_code(static_cast<int>(Error), *BuildPreambleErrCategory);
753 const char *BuildPreambleErrorCategory::name() const noexcept {
754 return "build-preamble.error";
757 std::string BuildPreambleErrorCategory::message(int condition) const {
758 switch (static_cast<BuildPreambleError>(condition)) {
759 case BuildPreambleError::CouldntCreateTempFile:
760 return "Could not create temporary file for PCH";
761 case BuildPreambleError::CouldntCreateTargetInfo:
762 return "CreateTargetInfo() return null";
763 case BuildPreambleError::BeginSourceFileFailed:
764 return "BeginSourceFile() return an error";
765 case BuildPreambleError::CouldntEmitPCH:
766 return "Could not emit PCH";
768 llvm_unreachable("unexpected BuildPreambleError");