1 //===- llvm/unittest/Support/MemoryBufferTest.cpp - MemoryBuffer 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 // This file implements unit tests for the MemoryBuffer support class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Support/SmallVectorMemoryBuffer.h"
15 #include "llvm/ADT/ScopeExit.h"
16 #include "llvm/Support/FileSystem.h"
17 #include "llvm/Support/FileUtilities.h"
18 #include "llvm/Support/Process.h"
19 #include "llvm/Support/raw_ostream.h"
20 #include "llvm/Testing/Support/Error.h"
21 #include "gtest/gtest.h"
22 #if LLVM_ENABLE_THREADS
23 #include <thread>
24 #endif
25 #if LLVM_ON_UNIX
26 #include <unistd.h>
27 #endif
28 #if _WIN32
29 #include <windows.h>
30 #endif
31
32 using namespace llvm;
33
34 #define ASSERT_NO_ERROR(x) \
35 if (std::error_code ASSERT_NO_ERROR_ec = x) { \
36 SmallString<128> MessageStorage; \
37 raw_svector_ostream Message(MessageStorage); \
38 Message << #x ": did not return errc::success.\n" \
39 << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \
40 << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \
41 GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \
42 } else { \
43 }
44
45 #define ASSERT_ERROR(x) \
46 if (!x) { \
47 SmallString<128> MessageStorage; \
48 raw_svector_ostream Message(MessageStorage); \
49 Message << #x ": did not return a failure error code.\n"; \
50 GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \
51 }
52
53 namespace {
54
55 class MemoryBufferTest : public testing::Test {
56 protected:
MemoryBufferTest()57 MemoryBufferTest()
58 : data("this is some data")
59 { }
60
SetUp()61 void SetUp() override {}
62
63 /// Common testing for different modes of getOpenFileSlice.
64 /// Creates a temporary file with known contents, and uses
65 /// MemoryBuffer::getOpenFileSlice to map it.
66 /// If \p Reopen is true, the file is closed after creating and reopened
67 /// anew before using MemoryBuffer.
68 void testGetOpenFileSlice(bool Reopen);
69
70 typedef std::unique_ptr<MemoryBuffer> OwningBuffer;
71
72 std::string data;
73 };
74
TEST_F(MemoryBufferTest,get)75 TEST_F(MemoryBufferTest, get) {
76 // Default name and null-terminator flag
77 OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
78 EXPECT_NE(nullptr, MB1.get());
79
80 // RequiresNullTerminator = false
81 OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
82 EXPECT_NE(nullptr, MB2.get());
83
84 // RequiresNullTerminator = true
85 OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
86 EXPECT_NE(nullptr, MB3.get());
87
88 // verify all 3 buffers point to the same address
89 EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
90 EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
91
92 // verify the original data is unmodified after deleting the buffers
93 MB1.reset();
94 MB2.reset();
95 MB3.reset();
96 EXPECT_EQ("this is some data", data);
97 }
98
TEST_F(MemoryBufferTest,getOpenFile)99 TEST_F(MemoryBufferTest, getOpenFile) {
100 int FD;
101 SmallString<64> TestPath;
102 ASSERT_EQ(sys::fs::createTemporaryFile("MemoryBufferTest_getOpenFile", "temp",
103 FD, TestPath),
104 std::error_code());
105
106 FileRemover Cleanup(TestPath);
107 raw_fd_ostream OF(FD, /*shouldClose*/ true);
108 OF << "12345678";
109 OF.close();
110
111 {
112 Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath);
113 ASSERT_THAT_EXPECTED(File, Succeeded());
114 auto OnExit =
115 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
116 ErrorOr<OwningBuffer> MB = MemoryBuffer::getOpenFile(*File, TestPath, 6);
117 ASSERT_NO_ERROR(MB.getError());
118 EXPECT_EQ("123456", MB.get()->getBuffer());
119 }
120 {
121 Expected<sys::fs::file_t> File = sys::fs::openNativeFileForWrite(
122 TestPath, sys::fs::CD_OpenExisting, sys::fs::OF_None);
123 ASSERT_THAT_EXPECTED(File, Succeeded());
124 auto OnExit =
125 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
126 ASSERT_ERROR(MemoryBuffer::getOpenFile(*File, TestPath, 6).getError());
127 }
128 }
129
TEST_F(MemoryBufferTest,NullTerminator4K)130 TEST_F(MemoryBufferTest, NullTerminator4K) {
131 // Test that a file with size that is a multiple of the page size can be null
132 // terminated correctly by MemoryBuffer.
133 int TestFD;
134 SmallString<64> TestPath;
135 sys::fs::createTemporaryFile("MemoryBufferTest_NullTerminator4K", "temp",
136 TestFD, TestPath);
137 FileRemover Cleanup(TestPath);
138 raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true);
139 for (unsigned i = 0; i < 4096 / 16; ++i) {
140 OF << "0123456789abcdef";
141 }
142 OF.close();
143
144 ErrorOr<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str());
145 std::error_code EC = MB.getError();
146 ASSERT_FALSE(EC);
147
148 const char *BufData = MB.get()->getBufferStart();
149 EXPECT_EQ('f', BufData[4095]);
150 EXPECT_EQ('\0', BufData[4096]);
151 }
152
TEST_F(MemoryBufferTest,copy)153 TEST_F(MemoryBufferTest, copy) {
154 // copy with no name
155 OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
156 EXPECT_NE(nullptr, MBC1.get());
157
158 // copy with a name
159 OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
160 EXPECT_NE(nullptr, MBC2.get());
161
162 // verify the two copies do not point to the same place
163 EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
164 }
165
166 #if LLVM_ENABLE_THREADS
TEST_F(MemoryBufferTest,createFromPipe)167 TEST_F(MemoryBufferTest, createFromPipe) {
168 sys::fs::file_t pipes[2];
169 #if LLVM_ON_UNIX
170 ASSERT_EQ(::pipe(pipes), 0) << strerror(errno);
171 #else
172 ASSERT_TRUE(::CreatePipe(&pipes[0], &pipes[1], nullptr, 0))
173 << ::GetLastError();
174 #endif
175 auto ReadCloser = make_scope_exit([&] { sys::fs::closeFile(pipes[0]); });
176 std::thread Writer([&] {
177 auto WriteCloser = make_scope_exit([&] { sys::fs::closeFile(pipes[1]); });
178 for (unsigned i = 0; i < 5; ++i) {
179 std::this_thread::sleep_for(std::chrono::milliseconds(10));
180 #if LLVM_ON_UNIX
181 ASSERT_EQ(::write(pipes[1], "foo", 3), 3) << strerror(errno);
182 #else
183 DWORD Written;
184 ASSERT_TRUE(::WriteFile(pipes[1], "foo", 3, &Written, nullptr))
185 << ::GetLastError();
186 ASSERT_EQ(Written, 3u);
187 #endif
188 }
189 });
190 ErrorOr<OwningBuffer> MB =
191 MemoryBuffer::getOpenFile(pipes[0], "pipe", /*FileSize*/ -1);
192 Writer.join();
193 ASSERT_NO_ERROR(MB.getError());
194 EXPECT_EQ(MB.get()->getBuffer(), "foofoofoofoofoo");
195 }
196 #endif
197
TEST_F(MemoryBufferTest,make_new)198 TEST_F(MemoryBufferTest, make_new) {
199 // 0-sized buffer
200 OwningBuffer Zero(WritableMemoryBuffer::getNewUninitMemBuffer(0));
201 EXPECT_NE(nullptr, Zero.get());
202
203 // uninitialized buffer with no name
204 OwningBuffer One(WritableMemoryBuffer::getNewUninitMemBuffer(321));
205 EXPECT_NE(nullptr, One.get());
206
207 // uninitialized buffer with name
208 OwningBuffer Two(WritableMemoryBuffer::getNewUninitMemBuffer(123, "bla"));
209 EXPECT_NE(nullptr, Two.get());
210
211 // 0-initialized buffer with no name
212 OwningBuffer Three(WritableMemoryBuffer::getNewMemBuffer(321, data));
213 EXPECT_NE(nullptr, Three.get());
214 for (size_t i = 0; i < 321; ++i)
215 EXPECT_EQ(0, Three->getBufferStart()[0]);
216
217 // 0-initialized buffer with name
218 OwningBuffer Four(WritableMemoryBuffer::getNewMemBuffer(123, "zeros"));
219 EXPECT_NE(nullptr, Four.get());
220 for (size_t i = 0; i < 123; ++i)
221 EXPECT_EQ(0, Four->getBufferStart()[0]);
222
223 // uninitialized buffer with rollover size
224 OwningBuffer Five(
225 WritableMemoryBuffer::getNewUninitMemBuffer(SIZE_MAX, "huge"));
226 EXPECT_EQ(nullptr, Five.get());
227 }
228
testGetOpenFileSlice(bool Reopen)229 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
230 // Test that MemoryBuffer::getOpenFile works properly when no null
231 // terminator is requested and the size is large enough to trigger
232 // the usage of memory mapping.
233 int TestFD;
234 SmallString<64> TestPath;
235 // Create a temporary file and write data into it.
236 sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath);
237 FileRemover Cleanup(TestPath);
238 // OF is responsible for closing the file; If the file is not
239 // reopened, it will be unbuffered so that the results are
240 // immediately visible through the fd.
241 raw_fd_ostream OF(TestFD, true, !Reopen);
242 for (int i = 0; i < 60000; ++i) {
243 OF << "0123456789";
244 }
245
246 if (Reopen) {
247 OF.close();
248 EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
249 }
250
251 ErrorOr<OwningBuffer> Buf = MemoryBuffer::getOpenFileSlice(
252 sys::fs::convertFDToNativeFile(TestFD), TestPath.c_str(),
253 40000, // Size
254 80000 // Offset
255 );
256
257 std::error_code EC = Buf.getError();
258 EXPECT_FALSE(EC);
259
260 StringRef BufData = Buf.get()->getBuffer();
261 EXPECT_EQ(BufData.size(), 40000U);
262 EXPECT_EQ(BufData[0], '0');
263 EXPECT_EQ(BufData[9], '9');
264 }
265
TEST_F(MemoryBufferTest,getOpenFileNoReopen)266 TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
267 testGetOpenFileSlice(false);
268 }
269
TEST_F(MemoryBufferTest,getOpenFileReopened)270 TEST_F(MemoryBufferTest, getOpenFileReopened) {
271 testGetOpenFileSlice(true);
272 }
273
TEST_F(MemoryBufferTest,slice)274 TEST_F(MemoryBufferTest, slice) {
275 // Create a file that is six pages long with different data on each page.
276 int FD;
277 SmallString<64> TestPath;
278 sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath);
279 FileRemover Cleanup(TestPath);
280 raw_fd_ostream OF(FD, true, /*unbuffered=*/true);
281 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
282 OF << "12345678";
283 }
284 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
285 OF << "abcdefgh";
286 }
287 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
288 OF << "ABCDEFGH";
289 }
290 OF.close();
291
292 // Try offset of one page.
293 ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(),
294 0x4000, 0x1000);
295 std::error_code EC = MB.getError();
296 ASSERT_FALSE(EC);
297 EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
298
299 StringRef BufData = MB.get()->getBuffer();
300 EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
301 EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
302 EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
303 EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
304 EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
305 EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
306
307 // Try non-page aligned.
308 ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(),
309 0x3000, 0x0800);
310 EC = MB2.getError();
311 ASSERT_FALSE(EC);
312 EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
313
314 StringRef BufData2 = MB2.get()->getBuffer();
315 EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
316 EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
317 EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
318 EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
319 }
320
TEST_F(MemoryBufferTest,writableSlice)321 TEST_F(MemoryBufferTest, writableSlice) {
322 // Create a file initialized with some data
323 int FD;
324 SmallString<64> TestPath;
325 sys::fs::createTemporaryFile("MemoryBufferTest_WritableSlice", "temp", FD,
326 TestPath);
327 FileRemover Cleanup(TestPath);
328 raw_fd_ostream OF(FD, true);
329 for (unsigned i = 0; i < 0x1000; ++i)
330 OF << "0123456789abcdef";
331 OF.close();
332
333 {
334 auto MBOrError =
335 WritableMemoryBuffer::getFileSlice(TestPath.str(), 0x6000, 0x2000);
336 ASSERT_FALSE(MBOrError.getError());
337 // Write some data. It should be mapped private, so that upon completion
338 // the original file contents are not modified.
339 WritableMemoryBuffer &MB = **MBOrError;
340 ASSERT_EQ(0x6000u, MB.getBufferSize());
341 char *Start = MB.getBufferStart();
342 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
343 ::memset(Start, 'x', MB.getBufferSize());
344 }
345
346 auto MBOrError = MemoryBuffer::getFile(TestPath);
347 ASSERT_FALSE(MBOrError.getError());
348 auto &MB = **MBOrError;
349 ASSERT_EQ(0x10000u, MB.getBufferSize());
350 for (size_t i = 0; i < MB.getBufferSize(); i += 0x10)
351 EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i;
352 }
353
TEST_F(MemoryBufferTest,writeThroughFile)354 TEST_F(MemoryBufferTest, writeThroughFile) {
355 // Create a file initialized with some data
356 int FD;
357 SmallString<64> TestPath;
358 sys::fs::createTemporaryFile("MemoryBufferTest_WriteThrough", "temp", FD,
359 TestPath);
360 FileRemover Cleanup(TestPath);
361 raw_fd_ostream OF(FD, true);
362 OF << "0123456789abcdef";
363 OF.close();
364 {
365 auto MBOrError = WriteThroughMemoryBuffer::getFile(TestPath);
366 ASSERT_FALSE(MBOrError.getError());
367 // Write some data. It should be mapped readwrite, so that upon completion
368 // the original file contents are modified.
369 WriteThroughMemoryBuffer &MB = **MBOrError;
370 ASSERT_EQ(16u, MB.getBufferSize());
371 char *Start = MB.getBufferStart();
372 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
373 ::memset(Start, 'x', MB.getBufferSize());
374 }
375
376 auto MBOrError = MemoryBuffer::getFile(TestPath);
377 ASSERT_FALSE(MBOrError.getError());
378 auto &MB = **MBOrError;
379 ASSERT_EQ(16u, MB.getBufferSize());
380 EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer());
381 }
382
TEST_F(MemoryBufferTest,mmapVolatileNoNull)383 TEST_F(MemoryBufferTest, mmapVolatileNoNull) {
384 // Verify that `MemoryBuffer::getOpenFile` will use mmap when
385 // `RequiresNullTerminator = false`, `IsVolatile = true`, and the file is
386 // large enough to use mmap.
387 //
388 // This is done because Clang should use this mode to open module files, and
389 // falling back to malloc for them causes a huge memory usage increase.
390
391 int FD;
392 SmallString<64> TestPath;
393 ASSERT_NO_ERROR(sys::fs::createTemporaryFile(
394 "MemoryBufferTest_mmapVolatileNoNull", "temp", FD, TestPath));
395 FileRemover Cleanup(TestPath);
396 raw_fd_ostream OF(FD, true);
397 // Create a file large enough to mmap. 4 pages should be enough.
398 unsigned PageSize = sys::Process::getPageSizeEstimate();
399 unsigned FileWrites = (PageSize * 4) / 8;
400 for (unsigned i = 0; i < FileWrites; ++i)
401 OF << "01234567";
402 OF.close();
403
404 Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath);
405 ASSERT_THAT_EXPECTED(File, Succeeded());
406 auto OnExit =
407 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
408
409 auto MBOrError = MemoryBuffer::getOpenFile(*File, TestPath,
410 /*FileSize=*/-1, /*RequiresNullTerminator=*/false, /*IsVolatile=*/true);
411 ASSERT_NO_ERROR(MBOrError.getError())
412 OwningBuffer MB = std::move(*MBOrError);
413 EXPECT_EQ(MB->getBufferKind(), MemoryBuffer::MemoryBuffer_MMap);
414 EXPECT_EQ(MB->getBufferSize(), std::size_t(FileWrites * 8));
415 EXPECT_TRUE(MB->getBuffer().startswith("01234567"));
416 }
417
418 // Test that SmallVector without a null terminator gets one.
TEST(SmallVectorMemoryBufferTest,WithoutNullTerminatorRequiresNullTerminator)419 TEST(SmallVectorMemoryBufferTest, WithoutNullTerminatorRequiresNullTerminator) {
420 SmallString<0> Data("some data");
421
422 SmallVectorMemoryBuffer MB(std::move(Data),
423 /*RequiresNullTerminator=*/true);
424 EXPECT_EQ(MB.getBufferSize(), 9u);
425 EXPECT_EQ(MB.getBufferEnd()[0], '\0');
426 }
427
428 // Test that SmallVector with a null terminator keeps it.
TEST(SmallVectorMemoryBufferTest,WithNullTerminatorRequiresNullTerminator)429 TEST(SmallVectorMemoryBufferTest, WithNullTerminatorRequiresNullTerminator) {
430 SmallString<0> Data("some data");
431 Data.push_back('\0');
432 Data.pop_back();
433
434 SmallVectorMemoryBuffer MB(std::move(Data),
435 /*RequiresNullTerminator=*/true);
436 EXPECT_EQ(MB.getBufferSize(), 9u);
437 EXPECT_EQ(MB.getBufferEnd()[0], '\0');
438 }
439
440 } // namespace
441