llvm-project

1
//====-- unittests/Frontend/PCHPreambleTest.cpp - FrontendAction tests ---====//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "clang/Frontend/ASTUnit.h"
10
#include "clang/Frontend/CompilerInvocation.h"
11
#include "clang/Frontend/CompilerInstance.h"
12
#include "clang/Frontend/FrontendActions.h"
13
#include "clang/Frontend/FrontendOptions.h"
14
#include "clang/Lex/PreprocessorOptions.h"
15
#include "clang/Basic/Diagnostic.h"
16
#include "clang/Basic/FileManager.h"
17
#include "llvm/Support/FileSystem.h"
18
#include "llvm/Support/MemoryBuffer.h"
19
#include "llvm/Support/Path.h"
20
#include "gtest/gtest.h"
21

22
using namespace llvm;
23
using namespace clang;
24

25
namespace {
26

27
std::string Canonicalize(const Twine &Path) {
28
  SmallVector<char, 128> PathVec;
29
  Path.toVector(PathVec);
30
  llvm::sys::path::remove_dots(PathVec, true);
31
  return std::string(PathVec.begin(), PathVec.end());
32
}
33

34
class ReadCountingInMemoryFileSystem : public vfs::InMemoryFileSystem
35
{
36
  std::map<std::string, unsigned> ReadCounts;
37

38
public:
39
  ErrorOr<std::unique_ptr<vfs::File>> openFileForRead(const Twine &Path) override
40
  {
41
    ++ReadCounts[Canonicalize(Path)];
42
    return InMemoryFileSystem::openFileForRead(Path);
43
  }
44

45
  unsigned GetReadCount(const Twine &Path) const
46
  {
47
    auto it = ReadCounts.find(Canonicalize(Path));
48
    return it == ReadCounts.end() ? 0 : it->second;
49
  }
50
};
51

52
class PCHPreambleTest : public ::testing::Test {
53
  IntrusiveRefCntPtr<ReadCountingInMemoryFileSystem> VFS;
54
  StringMap<std::string> RemappedFiles;
55
  std::shared_ptr<PCHContainerOperations> PCHContainerOpts;
56
  FileSystemOptions FSOpts;
57

58
public:
59
  void SetUp() override { ResetVFS(); }
60
  void TearDown() override {}
61

62
  void ResetVFS() {
63
    VFS = new ReadCountingInMemoryFileSystem();
64
    // We need the working directory to be set to something absolute,
65
    // otherwise it ends up being inadvertently set to the current
66
    // working directory in the real file system due to a series of
67
    // unfortunate conditions interacting badly.
68
    // What's more, this path *must* be absolute on all (real)
69
    // filesystems, so just '/' won't work (e.g. on Win32).
70
    VFS->setCurrentWorkingDirectory("//./");
71
  }
72

73
  void AddFile(const std::string &Filename, const std::string &Contents) {
74
    ::time_t now;
75
    ::time(&now);
76
    VFS->addFile(Filename, now, MemoryBuffer::getMemBufferCopy(Contents, Filename));
77
  }
78

79
  void RemapFile(const std::string &Filename, const std::string &Contents) {
80
    RemappedFiles[Filename] = Contents;
81
  }
82

83
  std::unique_ptr<ASTUnit> ParseAST(const std::string &EntryFile) {
84
    PCHContainerOpts = std::make_shared<PCHContainerOperations>();
85
    std::shared_ptr<CompilerInvocation> CI(new CompilerInvocation);
86
    CI->getFrontendOpts().Inputs.push_back(
87
      FrontendInputFile(EntryFile, FrontendOptions::getInputKindForExtension(
88
        llvm::sys::path::extension(EntryFile).substr(1))));
89

90
    CI->getTargetOpts().Triple = "i386-unknown-linux-gnu";
91

92
    CI->getPreprocessorOpts().RemappedFileBuffers = GetRemappedFiles();
93

94
    PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
95
    PPOpts.RemappedFilesKeepOriginalName = true;
96

97
    IntrusiveRefCntPtr<DiagnosticsEngine>
98
      Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions, new DiagnosticConsumer));
99

100
    FileManager *FileMgr = new FileManager(FSOpts, VFS);
101

102
    std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
103
        CI, PCHContainerOpts, Diags, FileMgr, false, CaptureDiagsKind::None,
104
        /*PrecompilePreambleAfterNParses=*/1);
105
    return AST;
106
  }
107

108
  bool ReparseAST(const std::unique_ptr<ASTUnit> &AST) {
109
    bool reparseFailed = AST->Reparse(PCHContainerOpts, GetRemappedFiles(), VFS);
110
    return !reparseFailed;
111
  }
112

113
  unsigned GetFileReadCount(const std::string &Filename) const {
114
    return VFS->GetReadCount(Filename);
115
  }
116

117
private:
118
  std::vector<std::pair<std::string, llvm::MemoryBuffer *>>
119
  GetRemappedFiles() const {
120
    std::vector<std::pair<std::string, llvm::MemoryBuffer *>> Remapped;
121
    for (const auto &RemappedFile : RemappedFiles) {
122
      std::unique_ptr<MemoryBuffer> buf = MemoryBuffer::getMemBufferCopy(
123
        RemappedFile.second, RemappedFile.first());
124
      Remapped.emplace_back(std::string(RemappedFile.first()), buf.release());
125
    }
126
    return Remapped;
127
  }
128
};
129

130
TEST_F(PCHPreambleTest, ReparseReusesPreambleWithUnsavedFileNotExistingOnDisk) {
131
  std::string Header1 = "//./header1.h";
132
  std::string MainName = "//./main.cpp";
133
  AddFile(MainName, R"cpp(
134
#include "//./header1.h"
135
int main() { return ZERO; }
136
)cpp");
137
  RemapFile(Header1, "#define ZERO 0\n");
138

139
  // Parse with header file provided as unsaved file, which does not exist on
140
  // disk.
141
  std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
142
  ASSERT_TRUE(AST.get());
143
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
144

145
  // Reparse and check that the preamble was reused.
146
  ASSERT_TRUE(ReparseAST(AST));
147
  ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
148
}
149

150
TEST_F(PCHPreambleTest, ReparseReusesPreambleAfterUnsavedFileWasCreatedOnDisk) {
151
  std::string Header1 = "//./header1.h";
152
  std::string MainName = "//./main.cpp";
153
  AddFile(MainName, R"cpp(
154
#include "//./header1.h"
155
int main() { return ZERO; }
156
)cpp");
157
  RemapFile(Header1, "#define ZERO 0\n");
158

159
  // Parse with header file provided as unsaved file, which does not exist on
160
  // disk.
161
  std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
162
  ASSERT_TRUE(AST.get());
163
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
164

165
  // Create the unsaved file also on disk and check that preamble was reused.
166
  AddFile(Header1, "#define ZERO 0\n");
167
  ASSERT_TRUE(ReparseAST(AST));
168
  ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
169
}
170

171
TEST_F(PCHPreambleTest,
172
       ReparseReusesPreambleAfterUnsavedFileWasRemovedFromDisk) {
173
  std::string Header1 = "//./foo/header1.h";
174
  std::string MainName = "//./main.cpp";
175
  std::string MainFileContent = R"cpp(
176
#include "//./foo/header1.h"
177
int main() { return ZERO; }
178
)cpp";
179
  AddFile(MainName, MainFileContent);
180
  AddFile(Header1, "#define ZERO 0\n");
181
  RemapFile(Header1, "#define ZERO 0\n");
182

183
  // Parse with header file provided as unsaved file, which exists on disk.
184
  std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
185
  ASSERT_TRUE(AST.get());
186
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
187
  ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
188

189
  // Remove the unsaved file from disk and check that the preamble was reused.
190
  ResetVFS();
191
  AddFile(MainName, MainFileContent);
192
  ASSERT_TRUE(ReparseAST(AST));
193
  ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
194
}
195

196
TEST_F(PCHPreambleTest, ReparseWithOverriddenFileDoesNotInvalidatePreamble) {
197
  std::string Header1 = "//./header1.h";
198
  std::string Header2 = "//./header2.h";
199
  std::string MainName = "//./main.cpp";
200
  AddFile(Header1, "");
201
  AddFile(Header2, "#pragma once");
202
  AddFile(MainName,
203
    "#include \"//./foo/../header1.h\"\n"
204
    "#include \"//./foo/../header2.h\"\n"
205
    "int main() { return ZERO; }");
206
  RemapFile(Header1, "static const int ZERO = 0;\n");
207

208
  std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
209
  ASSERT_TRUE(AST.get());
210
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
211

212
  unsigned initialCounts[] = {
213
    GetFileReadCount(MainName),
214
    GetFileReadCount(Header1),
215
    GetFileReadCount(Header2)
216
  };
217

218
  ASSERT_TRUE(ReparseAST(AST));
219

220
  ASSERT_NE(initialCounts[0], GetFileReadCount(MainName));
221
  ASSERT_EQ(initialCounts[1], GetFileReadCount(Header1));
222
  ASSERT_EQ(initialCounts[2], GetFileReadCount(Header2));
223
}
224

225
TEST_F(PCHPreambleTest, ParseWithBom) {
226
  std::string Header = "//./header.h";
227
  std::string Main = "//./main.cpp";
228
  AddFile(Header, "int random() { return 4; }");
229
  AddFile(Main,
230
    "\xef\xbb\xbf"
231
    "#include \"//./header.h\"\n"
232
    "int main() { return random() -2; }");
233

234
  std::unique_ptr<ASTUnit> AST(ParseAST(Main));
235
  ASSERT_TRUE(AST.get());
236
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
237

238
  unsigned HeaderReadCount = GetFileReadCount(Header);
239

240
  ASSERT_TRUE(ReparseAST(AST));
241
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
242
  
243
  // Check preamble PCH was really reused
244
  ASSERT_EQ(HeaderReadCount, GetFileReadCount(Header));
245

246
  // Remove BOM
247
  RemapFile(Main,
248
    "#include \"//./header.h\"\n"
249
    "int main() { return random() -2; }");
250

251
  ASSERT_TRUE(ReparseAST(AST));
252
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
253

254
  ASSERT_LE(HeaderReadCount, GetFileReadCount(Header));
255
  HeaderReadCount = GetFileReadCount(Header);
256

257
  // Add BOM back
258
  RemapFile(Main,
259
    "\xef\xbb\xbf"
260
    "#include \"//./header.h\"\n"
261
    "int main() { return random() -2; }");
262

263
  ASSERT_TRUE(ReparseAST(AST));
264
  ASSERT_FALSE(AST->getDiagnostics().hasErrorOccurred());
265

266
  ASSERT_LE(HeaderReadCount, GetFileReadCount(Header));
267
}
268

269
} // anonymous namespace
270