Coverage Report

Created: 2020-02-15 09:57

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/PrecompiledPreamble.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- PrecompiledPreamble.cpp - Build precompiled preambles --*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// Helper class to build precompiled preamble.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#include "clang/Frontend/PrecompiledPreamble.h"
14
#include "clang/AST/DeclObjC.h"
15
#include "clang/Basic/LangStandard.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/Preprocessor.h"
23
#include "clang/Lex/PreprocessorOptions.h"
24
#include "clang/Serialization/ASTWriter.h"
25
#include "llvm/ADT/StringExtras.h"
26
#include "llvm/ADT/StringSet.h"
27
#include "llvm/Config/llvm-config.h"
28
#include "llvm/Support/CrashRecoveryContext.h"
29
#include "llvm/Support/FileSystem.h"
30
#include "llvm/Support/Process.h"
31
#include "llvm/Support/VirtualFileSystem.h"
32
#include <limits>
33
#include <mutex>
34
#include <utility>
35
36
using namespace clang;
37
38
namespace {
39
40
0
StringRef getInMemoryPreamblePath() {
41
0
#if defined(LLVM_ON_UNIX)
42
0
  return "/__clang_tmp/___clang_inmemory_preamble___";
43
#elif defined(_WIN32)
44
  return "C:\\__clang_tmp\\___clang_inmemory_preamble___";
45
#else
46
#warning "Unknown platform. Defaulting to UNIX-style paths for in-memory PCHs"
47
  return "/__clang_tmp/___clang_inmemory_preamble___";
48
#endif
49
}
50
51
IntrusiveRefCntPtr<llvm::vfs::FileSystem>
52
createVFSOverlayForPreamblePCH(StringRef PCHFilename,
53
                               std::unique_ptr<llvm::MemoryBuffer> PCHBuffer,
54
12
                               IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
55
12
  // We want only the PCH file from the real filesystem to be available,
56
12
  // so we create an in-memory VFS with just that and overlay it on top.
57
12
  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> PCHFS(
58
12
      new llvm::vfs::InMemoryFileSystem());
59
12
  PCHFS->addFile(PCHFilename, 0, std::move(PCHBuffer));
60
12
  IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> Overlay(
61
12
      new llvm::vfs::OverlayFileSystem(VFS));
62
12
  Overlay->pushOverlay(PCHFS);
63
12
  return Overlay;
64
12
}
65
66
class PreambleDependencyCollector : public DependencyCollector {
67
public:
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
72
  // headers).
73
289
  bool needSystemDependencies() override { return true; }
74
};
75
76
/// Keeps a track of files to be deleted in destructor.
77
class TemporaryFiles {
78
public:
79
  // A static instance to be used by all clients.
80
  static TemporaryFiles &getInstance();
81
82
private:
83
  // Disallow constructing the class directly.
84
81
  TemporaryFiles() = default;
85
  // Disallow copy.
86
  TemporaryFiles(const TemporaryFiles &) = delete;
87
88
public:
89
  ~TemporaryFiles();
90
91
  /// Adds \p File to a set of tracked files.
92
  void addFile(StringRef File);
93
94
  /// Remove \p File from disk and from the set of tracked files.
95
  void removeFile(StringRef File);
96
97
private:
98
  std::mutex Mutex;
99
  llvm::StringSet<> Files;
100
};
101
102
175
TemporaryFiles &TemporaryFiles::getInstance() {
103
175
  static TemporaryFiles Instance;
104
175
  return Instance;
105
175
}
106
107
81
TemporaryFiles::~TemporaryFiles() {
108
81
  std::lock_guard<std::mutex> Guard(Mutex);
109
81
  for (const auto &File : Files)
110
1
    llvm::sys::fs::remove(File.getKey());
111
81
}
112
113
88
void TemporaryFiles::addFile(StringRef File) {
114
88
  std::lock_guard<std::mutex> Guard(Mutex);
115
88
  auto IsInserted = Files.insert(File).second;
116
88
  (void)IsInserted;
117
88
  assert(IsInserted && "File has already been added");
118
88
}
119
120
87
void TemporaryFiles::removeFile(StringRef File) {
121
87
  std::lock_guard<std::mutex> Guard(Mutex);
122
87
  auto WasPresent = Files.erase(File);
123
87
  (void)WasPresent;
124
87
  assert(WasPresent && "File was not tracked");
125
87
  llvm::sys::fs::remove(File);
126
87
}
127
128
class PrecompilePreambleAction : public ASTFrontendAction {
129
public:
130
  PrecompilePreambleAction(std::string *InMemStorage,
131
                           PreambleCallbacks &Callbacks)
132
88
      : InMemStorage(InMemStorage), Callbacks(Callbacks) {}
133
134
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
135
                                                 StringRef InFile) override;
136
137
176
  bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; }
138
139
88
  void setEmittedPreamblePCH(ASTWriter &Writer) {
140
88
    this->HasEmittedPreamblePCH = true;
141
88
    Callbacks.AfterPCHEmitted(Writer);
142
88
  }
143
144
88
  bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); }
145
88
  bool hasCodeCompletionSupport() const override { return false; }
146
0
  bool hasASTFileSupport() const override { return false; }
147
176
  TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; }
148
149
private:
150
  friend class PrecompilePreambleConsumer;
151
152
  bool HasEmittedPreamblePCH = false;
153
  std::string *InMemStorage;
154
  PreambleCallbacks &Callbacks;
155
};
156
157
class PrecompilePreambleConsumer : public PCHGenerator {
158
public:
159
  PrecompilePreambleConsumer(PrecompilePreambleAction &Action,
160
                             const Preprocessor &PP,
161
                             InMemoryModuleCache &ModuleCache,
162
                             StringRef isysroot,
163
                             std::unique_ptr<raw_ostream> Out)
164
      : PCHGenerator(PP, ModuleCache, "", isysroot,
165
                     std::make_shared<PCHBuffer>(),
166
                     ArrayRef<std::shared_ptr<ModuleFileExtension>>(),
167
                     /*AllowASTWithErrors=*/true),
168
88
        Action(Action), Out(std::move(Out)) {}
169
170
85
  bool HandleTopLevelDecl(DeclGroupRef DG) override {
171
85
    Action.Callbacks.HandleTopLevelDecl(DG);
172
85
    return true;
173
85
  }
174
175
88
  void HandleTranslationUnit(ASTContext &Ctx) override {
176
88
    PCHGenerator::HandleTranslationUnit(Ctx);
177
88
    if (!hasEmittedPCH())
178
0
      return;
179
88
180
88
    // Write the generated bitstream to "Out".
181
88
    *Out << getPCH();
182
88
    // Make sure it hits disk now.
183
88
    Out->flush();
184
88
    // Free the buffer.
185
88
    llvm::SmallVector<char, 0> Empty;
186
88
    getPCH() = std::move(Empty);
187
88
188
88
    Action.setEmittedPreamblePCH(getWriter());
189
88
  }
190
191
private:
192
  PrecompilePreambleAction &Action;
193
  std::unique_ptr<raw_ostream> Out;
194
};
195
196
std::unique_ptr<ASTConsumer>
197
PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
198
88
                                            StringRef InFile) {
199
88
  std::string Sysroot;
200
88
  if (!GeneratePCHAction::ComputeASTConsumerArguments(CI, Sysroot))
201
0
    return nullptr;
202
88
203
88
  std::unique_ptr<llvm::raw_ostream> OS;
204
88
  if (InMemStorage) {
205
0
    OS = std::make_unique<llvm::raw_string_ostream>(*InMemStorage);
206
88
  } else {
207
88
    std::string OutputFile;
208
88
    OS = GeneratePCHAction::CreateOutputFile(CI, InFile, OutputFile);
209
88
  }
210
88
  if (!OS)
211
0
    return nullptr;
212
88
213
88
  if (!CI.getFrontendOpts().RelocatablePCH)
214
88
    Sysroot.clear();
215
88
216
88
  return std::make_unique<PrecompilePreambleConsumer>(
217
88
      *this, CI.getPreprocessor(), CI.getModuleCache(), Sysroot, std::move(OS));
218
88
}
219
220
465
template <class T> bool moveOnNoError(llvm::ErrorOr<T> Val, T &Output) {
221
465
  if (!Val)
222
2
    return false;
223
463
  Output = std::move(*Val);
224
463
  return true;
225
463
}
226
227
} // namespace
228
229
PreambleBounds clang::ComputePreambleBounds(const LangOptions &LangOpts,
230
                                            llvm::MemoryBuffer *Buffer,
231
499
                                            unsigned MaxLines) {
232
499
  return Lexer::ComputePreamble(Buffer->getBuffer(), LangOpts, MaxLines);
233
499
}
234
235
llvm::ErrorOr<PrecompiledPreamble> PrecompiledPreamble::Build(
236
    const CompilerInvocation &Invocation,
237
    const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds,
238
    DiagnosticsEngine &Diagnostics,
239
    IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
240
    std::shared_ptr<PCHContainerOperations> PCHContainerOps, bool StoreInMemory,
241
88
    PreambleCallbacks &Callbacks) {
242
88
  assert(VFS && "VFS is null");
243
88
244
88
  auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
245
88
  FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
246
88
  PreprocessorOptions &PreprocessorOpts =
247
88
      PreambleInvocation->getPreprocessorOpts();
248
88
249
88
  llvm::Optional<TempPCHFile> TempFile;
250
88
  if (!StoreInMemory) {
251
88
    // Create a temporary file for the precompiled preamble. In rare
252
88
    // circumstances, this can fail.
253
88
    llvm::ErrorOr<PrecompiledPreamble::TempPCHFile> PreamblePCHFile =
254
88
        PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile();
255
88
    if (!PreamblePCHFile)
256
0
      return BuildPreambleError::CouldntCreateTempFile;
257
88
    TempFile = std::move(*PreamblePCHFile);
258
88
  }
259
88
260
88
  PCHStorage Storage = StoreInMemory ? 
PCHStorage(InMemoryPreamble())0
261
88
                                     : PCHStorage(std::move(*TempFile));
262
88
263
88
  // Save the preamble text for later; we'll need to compare against it for
264
88
  // subsequent reparses.
265
88
  std::vector<char> PreambleBytes(MainFileBuffer->getBufferStart(),
266
88
                                  MainFileBuffer->getBufferStart() +
267
88
                                      Bounds.Size);
268
88
  bool PreambleEndsAtStartOfLine = Bounds.PreambleEndsAtStartOfLine;
269
88
270
88
  // Tell the compiler invocation to generate a temporary precompiled header.
271
88
  FrontendOpts.ProgramAction = frontend::GeneratePCH;
272
88
  FrontendOpts.OutputFile =
273
88
      std::string(StoreInMemory ? 
getInMemoryPreamblePath()0
274
88
                                : Storage.asFile().getFilePath());
275
88
  PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
276
88
  PreprocessorOpts.PrecompiledPreambleBytes.second = false;
277
88
  // Inform preprocessor to record conditional stack when building the preamble.
278
88
  PreprocessorOpts.GeneratePreamble = true;
279
88
280
88
  // Create the compiler instance to use for building the precompiled preamble.
281
88
  std::unique_ptr<CompilerInstance> Clang(
282
88
      new CompilerInstance(std::move(PCHContainerOps)));
283
88
284
88
  // Recover resources if we crash before exiting this method.
285
88
  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> CICleanup(
286
88
      Clang.get());
287
88
288
88
  Clang->setInvocation(std::move(PreambleInvocation));
289
88
  Clang->setDiagnostics(&Diagnostics);
290
88
291
88
  // Create the target instance.
292
88
  Clang->setTarget(TargetInfo::CreateTargetInfo(
293
88
      Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
294
88
  if (!Clang->hasTarget())
295
0
    return BuildPreambleError::CouldntCreateTargetInfo;
296
88
297
88
  // Inform the target of the language options.
298
88
  //
299
88
  // FIXME: We shouldn't need to do this, the target should be immutable once
300
88
  // created. This complexity should be lifted elsewhere.
301
88
  Clang->getTarget().adjust(Clang->getLangOpts());
302
88
303
88
  if (Clang->getFrontendOpts().Inputs.size() != 1 ||
304
88
      Clang->getFrontendOpts().Inputs[0].getKind().getFormat() !=
305
88
          InputKind::Source ||
306
88
      Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() ==
307
88
          Language::LLVM_IR) {
308
0
    return BuildPreambleError::BadInputs;
309
0
  }
310
88
311
88
  // Clear out old caches and data.
312
88
  Diagnostics.Reset();
313
88
  ProcessWarningOptions(Diagnostics, Clang->getDiagnosticOpts());
314
88
315
88
  VFS =
316
88
      createVFSFromCompilerInvocation(Clang->getInvocation(), Diagnostics, VFS);
317
88
318
88
  // Create a file manager object to provide access to and cache the filesystem.
319
88
  Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS));
320
88
321
88
  // Create the source manager.
322
88
  Clang->setSourceManager(
323
88
      new SourceManager(Diagnostics, Clang->getFileManager()));
324
88
325
88
  auto PreambleDepCollector = std::make_shared<PreambleDependencyCollector>();
326
88
  Clang->addDependencyCollector(PreambleDepCollector);
327
88
328
88
  // Remap the main source file to the preamble buffer.
329
88
  StringRef MainFilePath = FrontendOpts.Inputs[0].getFile();
330
88
  auto PreambleInputBuffer = llvm::MemoryBuffer::getMemBufferCopy(
331
88
      MainFileBuffer->getBuffer().slice(0, Bounds.Size), MainFilePath);
332
88
  if (PreprocessorOpts.RetainRemappedFileBuffers) {
333
88
    // MainFileBuffer will be deleted by unique_ptr after leaving the method.
334
88
    PreprocessorOpts.addRemappedFile(MainFilePath, PreambleInputBuffer.get());
335
88
  } else {
336
0
    // In that case, remapped buffer will be deleted by CompilerInstance on
337
0
    // BeginSourceFile, so we call release() to avoid double deletion.
338
0
    PreprocessorOpts.addRemappedFile(MainFilePath,
339
0
                                     PreambleInputBuffer.release());
340
0
  }
341
88
342
88
  std::unique_ptr<PrecompilePreambleAction> Act;
343
88
  Act.reset(new PrecompilePreambleAction(
344
88
      StoreInMemory ? 
&Storage.asMemory().Data0
: nullptr, Callbacks));
345
88
  Callbacks.BeforeExecute(*Clang);
346
88
  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
347
0
    return BuildPreambleError::BeginSourceFileFailed;
348
88
349
88
  std::unique_ptr<PPCallbacks> DelegatedPPCallbacks =
350
88
      Callbacks.createPPCallbacks();
351
88
  if (DelegatedPPCallbacks)
352
88
    Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks));
353
88
  if (auto CommentHandler = Callbacks.getCommentHandler())
354
0
    Clang->getPreprocessor().addCommentHandler(CommentHandler);
355
88
356
88
  if (llvm::Error Err = Act->Execute())
357
0
    return errorToErrorCode(std::move(Err));
358
88
359
88
  // Run the callbacks.
360
88
  Callbacks.AfterExecute(*Clang);
361
88
362
88
  Act->EndSourceFile();
363
88
364
88
  if (!Act->hasEmittedPreamblePCH())
365
0
    return BuildPreambleError::CouldntEmitPCH;
366
88
367
88
  // Keep track of all of the files that the source manager knows about,
368
88
  // so we can verify whether they have changed or not.
369
88
  llvm::StringMap<PrecompiledPreamble::PreambleFileHash> FilesInPreamble;
370
88
371
88
  SourceManager &SourceMgr = Clang->getSourceManager();
372
244
  for (auto &Filename : PreambleDepCollector->getDependencies()) {
373
244
    auto FileOrErr = Clang->getFileManager().getFile(Filename);
374
244
    if (!FileOrErr ||
375
244
        
*FileOrErr == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())243
)
376
89
      continue;
377
155
    auto File = *FileOrErr;
378
155
    if (time_t ModTime = File->getModificationTime()) {
379
147
      FilesInPreamble[File->getName()] =
380
147
          PrecompiledPreamble::PreambleFileHash::createForFile(File->getSize(),
381
147
                                                               ModTime);
382
147
    } else {
383
8
      const llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File);
384
8
      FilesInPreamble[File->getName()] =
385
8
          PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(Buffer);
386
8
    }
387
155
  }
388
88
389
88
  return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes),
390
88
                             PreambleEndsAtStartOfLine,
391
88
                             std::move(FilesInPreamble));
392
88
}
393
394
539
PreambleBounds PrecompiledPreamble::getBounds() const {
395
539
  return PreambleBounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);
396
539
}
397
398
0
std::size_t PrecompiledPreamble::getSize() const {
399
0
  switch (Storage.getKind()) {
400
0
  case PCHStorage::Kind::Empty:
401
0
    assert(false && "Calling getSize() on invalid PrecompiledPreamble. "
402
0
                    "Was it std::moved?");
403
0
    return 0;
404
0
  case PCHStorage::Kind::InMemory:
405
0
    return Storage.asMemory().Data.size();
406
0
  case PCHStorage::Kind::TempFile: {
407
0
    uint64_t Result;
408
0
    if (llvm::sys::fs::file_size(Storage.asFile().getFilePath(), Result))
409
0
      return 0;
410
0
411
0
    assert(Result <= std::numeric_limits<std::size_t>::max() &&
412
0
           "file size did not fit into size_t");
413
0
    return Result;
414
0
  }
415
0
  }
416
0
  llvm_unreachable("Unhandled storage kind");
417
0
}
418
419
bool PrecompiledPreamble::CanReuse(const CompilerInvocation &Invocation,
420
                                   const llvm::MemoryBuffer *MainFileBuffer,
421
                                   PreambleBounds Bounds,
422
251
                                   llvm::vfs::FileSystem *VFS) const {
423
251
424
251
  assert(
425
251
      Bounds.Size <= MainFileBuffer->getBufferSize() &&
426
251
      "Buffer is too large. Bounds were calculated from a different buffer?");
427
251
428
251
  auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
429
251
  PreprocessorOptions &PreprocessorOpts =
430
251
      PreambleInvocation->getPreprocessorOpts();
431
251
432
251
  // We've previously computed a preamble. Check whether we have the same
433
251
  // preamble now that we did before, and that there's enough space in
434
251
  // the main-file buffer within the precompiled preamble to fit the
435
251
  // new main file.
436
251
  if (PreambleBytes.size() != Bounds.Size ||
437
251
      
PreambleEndsAtStartOfLine != Bounds.PreambleEndsAtStartOfLine245
||
438
251
      !std::equal(PreambleBytes.begin(), PreambleBytes.end(),
439
245
                  MainFileBuffer->getBuffer().begin()))
440
6
    return false;
441
245
  // The preamble has not changed. We may be able to re-use the precompiled
442
245
  // preamble.
443
245
444
245
  // Check that none of the files used by the preamble have changed.
445
245
  // First, make a record of those files that have been overridden via
446
245
  // remapping or unsaved_files.
447
245
  std::map<llvm::sys::fs::UniqueID, PreambleFileHash> OverriddenFiles;
448
245
  for (const auto &R : PreprocessorOpts.RemappedFiles) {
449
0
    llvm::vfs::Status Status;
450
0
    if (!moveOnNoError(VFS->status(R.second), Status)) {
451
0
      // If we can't stat the file we're remapping to, assume that something
452
0
      // horrible happened.
453
0
      return false;
454
0
    }
455
0
456
0
    OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile(
457
0
        Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime()));
458
0
  }
459
245
460
245
  // OverridenFileBuffers tracks only the files not found in VFS.
461
245
  llvm::StringMap<PreambleFileHash> OverridenFileBuffers;
462
245
  for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
463
6
    const PrecompiledPreamble::PreambleFileHash PreambleHash =
464
6
        PreambleFileHash::createForMemoryBuffer(RB.second);
465
6
    llvm::vfs::Status Status;
466
6
    if (moveOnNoError(VFS->status(RB.first), Status))
467
4
      OverriddenFiles[Status.getUniqueID()] = PreambleHash;
468
2
    else
469
2
      OverridenFileBuffers[RB.first] = PreambleHash;
470
6
  }
471
245
472
245
  // Check whether anything has changed.
473
461
  for (const auto &F : FilesInPreamble) {
474
461
    auto OverridenFileBuffer = OverridenFileBuffers.find(F.first());
475
461
    if (OverridenFileBuffer != OverridenFileBuffers.end()) {
476
2
      // The file's buffer was remapped and the file was not found in VFS.
477
2
      // Check whether it matches up with the previous mapping.
478
2
      if (OverridenFileBuffer->second != F.second)
479
0
        return false;
480
2
      continue;
481
2
    }
482
459
483
459
    llvm::vfs::Status Status;
484
459
    if (!moveOnNoError(VFS->status(F.first()), Status)) {
485
0
      // If the file's buffer is not remapped and we can't stat it,
486
0
      // assume that something horrible happened.
487
0
      return false;
488
0
    }
489
459
490
459
    std::map<llvm::sys::fs::UniqueID, PreambleFileHash>::iterator Overridden =
491
459
        OverriddenFiles.find(Status.getUniqueID());
492
459
    if (Overridden != OverriddenFiles.end()) {
493
4
      // This file was remapped; check whether the newly-mapped file
494
4
      // matches up with the previous mapping.
495
4
      if (Overridden->second != F.second)
496
2
        return false;
497
2
      continue;
498
2
    }
499
455
500
455
    // Neither the file's buffer nor the file itself was remapped;
501
455
    // check whether it has changed on disk.
502
455
    if (Status.getSize() != uint64_t(F.second.Size) ||
503
455
        llvm::sys::toTimeT(Status.getLastModificationTime()) !=
504
453
            F.second.ModTime)
505
2
      return false;
506
455
  }
507
245
  
return true241
;
508
245
}
509
510
void PrecompiledPreamble::AddImplicitPreamble(
511
    CompilerInvocation &CI, IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
512
329
    llvm::MemoryBuffer *MainFileBuffer) const {
513
329
  PreambleBounds Bounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);
514
329
  configurePreamble(Bounds, CI, VFS, MainFileBuffer);
515
329
}
516
517
void PrecompiledPreamble::OverridePreamble(
518
    CompilerInvocation &CI, IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
519
0
    llvm::MemoryBuffer *MainFileBuffer) const {
520
0
  auto Bounds = ComputePreambleBounds(*CI.getLangOpts(), MainFileBuffer, 0);
521
0
  configurePreamble(Bounds, CI, VFS, MainFileBuffer);
522
0
}
523
524
PrecompiledPreamble::PrecompiledPreamble(
525
    PCHStorage Storage, std::vector<char> PreambleBytes,
526
    bool PreambleEndsAtStartOfLine,
527
    llvm::StringMap<PreambleFileHash> FilesInPreamble)
528
    : Storage(std::move(Storage)), FilesInPreamble(std::move(FilesInPreamble)),
529
      PreambleBytes(std::move(PreambleBytes)),
530
88
      PreambleEndsAtStartOfLine(PreambleEndsAtStartOfLine) {
531
88
  assert(this->Storage.getKind() != PCHStorage::Kind::Empty);
532
88
}
533
534
llvm::ErrorOr<PrecompiledPreamble::TempPCHFile>
535
88
PrecompiledPreamble::TempPCHFile::CreateNewPreamblePCHFile() {
536
88
  // FIXME: This is a hack so that we can override the preamble file during
537
88
  // crash-recovery testing, which is the only case where the preamble files
538
88
  // are not necessarily cleaned up.
539
88
  if (const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"))
540
2
    return TempPCHFile(TmpFile);
541
86
542
86
  llvm::SmallString<64> File;
543
86
  // Using a version of createTemporaryFile with a file descriptor guarantees
544
86
  // that we would never get a race condition in a multi-threaded setting
545
86
  // (i.e., multiple threads getting the same temporary path).
546
86
  int FD;
547
86
  auto EC = llvm::sys::fs::createTemporaryFile("preamble", "pch", FD, File);
548
86
  if (EC)
549
0
    return EC;
550
86
  // We only needed to make sure the file exists, close the file right away.
551
86
  llvm::sys::Process::SafelyCloseFileDescriptor(FD);
552
86
  return TempPCHFile(std::string(std::move(File).str()));
553
86
}
554
555
PrecompiledPreamble::TempPCHFile::TempPCHFile(std::string FilePath)
556
88
    : FilePath(std::move(FilePath)) {
557
88
  TemporaryFiles::getInstance().addFile(*this->FilePath);
558
88
}
559
560
704
PrecompiledPreamble::TempPCHFile::TempPCHFile(TempPCHFile &&Other) {
561
704
  FilePath = std::move(Other.FilePath);
562
704
  Other.FilePath = None;
563
704
}
564
565
PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::TempPCHFile::
566
0
operator=(TempPCHFile &&Other) {
567
0
  RemoveFileIfPresent();
568
0
569
0
  FilePath = std::move(Other.FilePath);
570
0
  Other.FilePath = None;
571
0
  return *this;
572
0
}
573
574
791
PrecompiledPreamble::TempPCHFile::~TempPCHFile() { RemoveFileIfPresent(); }
575
576
791
void PrecompiledPreamble::TempPCHFile::RemoveFileIfPresent() {
577
791
  if (FilePath) {
578
87
    TemporaryFiles::getInstance().removeFile(*FilePath);
579
87
    FilePath = None;
580
87
  }
581
791
}
582
583
746
llvm::StringRef PrecompiledPreamble::TempPCHFile::getFilePath() const {
584
746
  assert(FilePath && "TempPCHFile doesn't have a FilePath. Had it been moved?");
585
746
  return *FilePath;
586
746
}
587
588
PrecompiledPreamble::PCHStorage::PCHStorage(TempPCHFile File)
589
88
    : StorageKind(Kind::TempFile) {
590
88
  new (&asFile()) TempPCHFile(std::move(File));
591
88
}
592
593
PrecompiledPreamble::PCHStorage::PCHStorage(InMemoryPreamble Memory)
594
0
    : StorageKind(Kind::InMemory) {
595
0
  new (&asMemory()) InMemoryPreamble(std::move(Memory));
596
0
}
597
598
352
PrecompiledPreamble::PCHStorage::PCHStorage(PCHStorage &&Other) : PCHStorage() {
599
352
  *this = std::move(Other);
600
352
}
Unexecuted instantiation: clang::PrecompiledPreamble::PCHStorage::PCHStorage(clang::PrecompiledPreamble::PCHStorage&&)
clang::PrecompiledPreamble::PCHStorage::PCHStorage(clang::PrecompiledPreamble::PCHStorage&&)
Line
Count
Source
598
352
PrecompiledPreamble::PCHStorage::PCHStorage(PCHStorage &&Other) : PCHStorage() {
599
352
  *this = std::move(Other);
600
352
}
601
602
PrecompiledPreamble::PCHStorage &PrecompiledPreamble::PCHStorage::
603
352
operator=(PCHStorage &&Other) {
604
352
  destroy();
605
352
606
352
  StorageKind = Other.StorageKind;
607
352
  switch (StorageKind) {
608
0
  case Kind::Empty:
609
0
    // do nothing;
610
0
    break;
611
352
  case Kind::TempFile:
612
352
    new (&asFile()) TempPCHFile(std::move(Other.asFile()));
613
352
    break;
614
0
  case Kind::InMemory:
615
0
    new (&asMemory()) InMemoryPreamble(std::move(Other.asMemory()));
616
0
    break;
617
352
  }
618
352
619
352
  Other.setEmpty();
620
352
  return *this;
621
352
}
622
623
439
PrecompiledPreamble::PCHStorage::~PCHStorage() { destroy(); }
624
625
PrecompiledPreamble::PCHStorage::Kind
626
2.06k
PrecompiledPreamble::PCHStorage::getKind() const {
627
2.06k
  return StorageKind;
628
2.06k
}
629
630
1.64k
PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::PCHStorage::asFile() {
631
1.64k
  assert(getKind() == Kind::TempFile);
632
1.64k
  return *reinterpret_cast<TempPCHFile *>(Storage.buffer);
633
1.64k
}
634
635
const PrecompiledPreamble::TempPCHFile &
636
329
PrecompiledPreamble::PCHStorage::asFile() const {
637
329
  return const_cast<PCHStorage *>(this)->asFile();
638
329
}
639
640
PrecompiledPreamble::InMemoryPreamble &
641
0
PrecompiledPreamble::PCHStorage::asMemory() {
642
0
  assert(getKind() == Kind::InMemory);
643
0
  return *reinterpret_cast<InMemoryPreamble *>(Storage.buffer);
644
0
}
645
646
const PrecompiledPreamble::InMemoryPreamble &
647
0
PrecompiledPreamble::PCHStorage::asMemory() const {
648
0
  return const_cast<PCHStorage *>(this)->asMemory();
649
0
}
650
651
1.14k
void PrecompiledPreamble::PCHStorage::destroy() {
652
1.14k
  switch (StorageKind) {
653
704
  case Kind::Empty:
654
704
    return;
655
439
  case Kind::TempFile:
656
439
    asFile().~TempPCHFile();
657
439
    return;
658
0
  case Kind::InMemory:
659
0
    asMemory().~InMemoryPreamble();
660
0
    return;
661
1.14k
  }
662
1.14k
}
663
664
352
void PrecompiledPreamble::PCHStorage::setEmpty() {
665
352
  destroy();
666
352
  StorageKind = Kind::Empty;
667
352
}
668
669
PrecompiledPreamble::PreambleFileHash
670
PrecompiledPreamble::PreambleFileHash::createForFile(off_t Size,
671
147
                                                     time_t ModTime) {
672
147
  PreambleFileHash Result;
673
147
  Result.Size = Size;
674
147
  Result.ModTime = ModTime;
675
147
  Result.MD5 = {};
676
147
  return Result;
677
147
}
678
679
PrecompiledPreamble::PreambleFileHash
680
PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(
681
14
    const llvm::MemoryBuffer *Buffer) {
682
14
  PreambleFileHash Result;
683
14
  Result.Size = Buffer->getBufferSize();
684
14
  Result.ModTime = 0;
685
14
686
14
  llvm::MD5 MD5Ctx;
687
14
  MD5Ctx.update(Buffer->getBuffer().data());
688
14
  MD5Ctx.final(Result.MD5);
689
14
690
14
  return Result;
691
14
}
692
693
void PrecompiledPreamble::configurePreamble(
694
    PreambleBounds Bounds, CompilerInvocation &CI,
695
    IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,
696
329
    llvm::MemoryBuffer *MainFileBuffer) const {
697
329
  assert(VFS);
698
329
699
329
  auto &PreprocessorOpts = CI.getPreprocessorOpts();
700
329
701
329
  // Remap main file to point to MainFileBuffer.
702
329
  auto MainFilePath = CI.getFrontendOpts().Inputs[0].getFile();
703
329
  PreprocessorOpts.addRemappedFile(MainFilePath, MainFileBuffer);
704
329
705
329
  // Configure ImpicitPCHInclude.
706
329
  PreprocessorOpts.PrecompiledPreambleBytes.first = Bounds.Size;
707
329
  PreprocessorOpts.PrecompiledPreambleBytes.second =
708
329
      Bounds.PreambleEndsAtStartOfLine;
709
329
  PreprocessorOpts.DisablePCHValidation = true;
710
329
711
329
  setupPreambleStorage(Storage, PreprocessorOpts, VFS);
712
329
}
713
714
void PrecompiledPreamble::setupPreambleStorage(
715
    const PCHStorage &Storage, PreprocessorOptions &PreprocessorOpts,
716
329
    IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS) {
717
329
  if (Storage.getKind() == PCHStorage::Kind::TempFile) {
718
329
    const TempPCHFile &PCHFile = Storage.asFile();
719
329
    PreprocessorOpts.ImplicitPCHInclude = std::string(PCHFile.getFilePath());
720
329
721
329
    // Make sure we can access the PCH file even if we're using a VFS
722
329
    IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS =
723
329
        llvm::vfs::getRealFileSystem();
724
329
    auto PCHPath = PCHFile.getFilePath();
725
329
    if (VFS == RealFS || 
VFS->exists(PCHPath)12
)
726
317
      return;
727
12
    auto Buf = RealFS->getBufferForFile(PCHPath);
728
12
    if (!Buf) {
729
0
      // We can't read the file even from RealFS, this is clearly an error,
730
0
      // but we'll just leave the current VFS as is and let clang's code
731
0
      // figure out what to do with missing PCH.
732
0
      return;
733
0
    }
734
12
735
12
    // We have a slight inconsistency here -- we're using the VFS to
736
12
    // read files, but the PCH was generated in the real file system.
737
12
    VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(*Buf), VFS);
738
12
  } else {
739
0
    assert(Storage.getKind() == PCHStorage::Kind::InMemory);
740
0
    // For in-memory preamble, we have to provide a VFS overlay that makes it
741
0
    // accessible.
742
0
    StringRef PCHPath = getInMemoryPreamblePath();
743
0
    PreprocessorOpts.ImplicitPCHInclude = std::string(PCHPath);
744
0
745
0
    auto Buf = llvm::MemoryBuffer::getMemBuffer(Storage.asMemory().Data);
746
0
    VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS);
747
0
  }
748
329
}
749
750
88
void PreambleCallbacks::BeforeExecute(CompilerInstance &CI) {}
751
88
void PreambleCallbacks::AfterExecute(CompilerInstance &CI) {}
752
0
void PreambleCallbacks::AfterPCHEmitted(ASTWriter &Writer) {}
753
0
void PreambleCallbacks::HandleTopLevelDecl(DeclGroupRef DG) {}
754
0
std::unique_ptr<PPCallbacks> PreambleCallbacks::createPPCallbacks() {
755
0
  return nullptr;
756
0
}
757
88
CommentHandler *PreambleCallbacks::getCommentHandler() { return nullptr; }
758
759
static llvm::ManagedStatic<BuildPreambleErrorCategory> BuildPreambleErrCategory;
760
761
0
std::error_code clang::make_error_code(BuildPreambleError Error) {
762
0
  return std::error_code(static_cast<int>(Error), *BuildPreambleErrCategory);
763
0
}
764
765
0
const char *BuildPreambleErrorCategory::name() const noexcept {
766
0
  return "build-preamble.error";
767
0
}
768
769
0
std::string BuildPreambleErrorCategory::message(int condition) const {
770
0
  switch (static_cast<BuildPreambleError>(condition)) {
771
0
  case BuildPreambleError::CouldntCreateTempFile:
772
0
    return "Could not create temporary file for PCH";
773
0
  case BuildPreambleError::CouldntCreateTargetInfo:
774
0
    return "CreateTargetInfo() return null";
775
0
  case BuildPreambleError::BeginSourceFileFailed:
776
0
    return "BeginSourceFile() return an error";
777
0
  case BuildPreambleError::CouldntEmitPCH:
778
0
    return "Could not emit PCH";
779
0
  case BuildPreambleError::BadInputs:
780
0
    return "Command line arguments must contain exactly one source file";
781
0
  }
782
0
  llvm_unreachable("unexpected BuildPreambleError");
783
0
}