Debian Codegraph @

llvm-project/llvm/unittests/Support/MemoryBufferTest.cpp

raw
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:
57 MemoryBufferTest()
58 : data("this is some data")
59 { }
60
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
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
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
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
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
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
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
229 TEST_F(MemoryBufferTest, getNewAligned) {
230 auto CheckAlignment = [](size_t AlignmentValue) {
231 Align Alignment(AlignmentValue);
232 OwningBuffer AlignedBuffer =
233 WritableMemoryBuffer::getNewUninitMemBuffer(0, "", Alignment);
234 EXPECT_TRUE(isAddrAligned(Alignment, AlignedBuffer->getBufferStart()));
235 };
236
237 // Test allocation with different alignments.
238 CheckAlignment(16);
239 CheckAlignment(32);
240 CheckAlignment(64);
241 CheckAlignment(128);
242 CheckAlignment(256);
243 }
244
245 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
246 // Test that MemoryBuffer::getOpenFile works properly when no null
247 // terminator is requested and the size is large enough to trigger
248 // the usage of memory mapping.
249 int TestFD;
250 SmallString<64> TestPath;
251 // Create a temporary file and write data into it.
252 sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath);
253 FileRemover Cleanup(TestPath);
254 // OF is responsible for closing the file; If the file is not
255 // reopened, it will be unbuffered so that the results are
256 // immediately visible through the fd.
257 raw_fd_ostream OF(TestFD, true, !Reopen);
258 for (int i = 0; i < 60000; ++i) {
259 OF << "0123456789";
260 }
261
262 if (Reopen) {
263 OF.close();
264 EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
265 }
266
267 ErrorOr<OwningBuffer> Buf = MemoryBuffer::getOpenFileSlice(
268 sys::fs::convertFDToNativeFile(TestFD), TestPath.c_str(),
269 40000, // Size
270 80000 // Offset
271 );
272
273 std::error_code EC = Buf.getError();
274 EXPECT_FALSE(EC);
275
276 StringRef BufData = Buf.get()->getBuffer();
277 EXPECT_EQ(BufData.size(), 40000U);
278 EXPECT_EQ(BufData[0], '0');
279 EXPECT_EQ(BufData[9], '9');
280 }
281
282 TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
283 testGetOpenFileSlice(false);
284 }
285
286 TEST_F(MemoryBufferTest, getOpenFileReopened) {
287 testGetOpenFileSlice(true);
288 }
289
290 TEST_F(MemoryBufferTest, slice) {
291 // Create a file that is six pages long with different data on each page.
292 int FD;
293 SmallString<64> TestPath;
294 sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath);
295 FileRemover Cleanup(TestPath);
296 raw_fd_ostream OF(FD, true, /*unbuffered=*/true);
297 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
298 OF << "12345678";
299 }
300 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
301 OF << "abcdefgh";
302 }
303 for (unsigned i = 0; i < 0x2000 / 8; ++i) {
304 OF << "ABCDEFGH";
305 }
306 OF.close();
307
308 // Try offset of one page.
309 ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(),
310 0x4000, 0x1000);
311 std::error_code EC = MB.getError();
312 ASSERT_FALSE(EC);
313 EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
314
315 StringRef BufData = MB.get()->getBuffer();
316 EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
317 EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
318 EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
319 EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
320 EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
321 EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
322
323 // Try non-page aligned.
324 ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(),
325 0x3000, 0x0800);
326 EC = MB2.getError();
327 ASSERT_FALSE(EC);
328 EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
329
330 StringRef BufData2 = MB2.get()->getBuffer();
331 EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
332 EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
333 EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
334 EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
335 }
336
337 TEST_F(MemoryBufferTest, writableSlice) {
338 // Create a file initialized with some data
339 int FD;
340 SmallString<64> TestPath;
341 sys::fs::createTemporaryFile("MemoryBufferTest_WritableSlice", "temp", FD,
342 TestPath);
343 FileRemover Cleanup(TestPath);
344 raw_fd_ostream OF(FD, true);
345 for (unsigned i = 0; i < 0x1000; ++i)
346 OF << "0123456789abcdef";
347 OF.close();
348
349 {
350 auto MBOrError =
351 WritableMemoryBuffer::getFileSlice(TestPath.str(), 0x6000, 0x2000);
352 ASSERT_FALSE(MBOrError.getError());
353 // Write some data. It should be mapped private, so that upon completion
354 // the original file contents are not modified.
355 WritableMemoryBuffer &MB = **MBOrError;
356 ASSERT_EQ(0x6000u, MB.getBufferSize());
357 char *Start = MB.getBufferStart();
358 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
359 ::memset(Start, 'x', MB.getBufferSize());
360 }
361
362 auto MBOrError = MemoryBuffer::getFile(TestPath);
363 ASSERT_FALSE(MBOrError.getError());
364 auto &MB = **MBOrError;
365 ASSERT_EQ(0x10000u, MB.getBufferSize());
366 for (size_t i = 0; i < MB.getBufferSize(); i += 0x10)
367 EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i;
368 }
369
370 TEST_F(MemoryBufferTest, writeThroughFile) {
371 // Create a file initialized with some data
372 int FD;
373 SmallString<64> TestPath;
374 sys::fs::createTemporaryFile("MemoryBufferTest_WriteThrough", "temp", FD,
375 TestPath);
376 FileRemover Cleanup(TestPath);
377 raw_fd_ostream OF(FD, true);
378 OF << "0123456789abcdef";
379 OF.close();
380 {
381 auto MBOrError = WriteThroughMemoryBuffer::getFile(TestPath);
382 ASSERT_FALSE(MBOrError.getError());
383 // Write some data. It should be mapped readwrite, so that upon completion
384 // the original file contents are modified.
385 WriteThroughMemoryBuffer &MB = **MBOrError;
386 ASSERT_EQ(16u, MB.getBufferSize());
387 char *Start = MB.getBufferStart();
388 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
389 ::memset(Start, 'x', MB.getBufferSize());
390 }
391
392 auto MBOrError = MemoryBuffer::getFile(TestPath);
393 ASSERT_FALSE(MBOrError.getError());
394 auto &MB = **MBOrError;
395 ASSERT_EQ(16u, MB.getBufferSize());
396 EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer());
397 }
398
399 TEST_F(MemoryBufferTest, mmapVolatileNoNull) {
400 // Verify that `MemoryBuffer::getOpenFile` will use mmap when
401 // `RequiresNullTerminator = false`, `IsVolatile = true`, and the file is
402 // large enough to use mmap.
403 //
404 // This is done because Clang should use this mode to open module files, and
405 // falling back to malloc for them causes a huge memory usage increase.
406
407 int FD;
408 SmallString<64> TestPath;
409 ASSERT_NO_ERROR(sys::fs::createTemporaryFile(
410 "MemoryBufferTest_mmapVolatileNoNull", "temp", FD, TestPath));
411 FileRemover Cleanup(TestPath);
412 raw_fd_ostream OF(FD, true);
413 // Create a file large enough to mmap. 4 pages should be enough.
414 unsigned PageSize = sys::Process::getPageSizeEstimate();
415 unsigned FileWrites = (PageSize * 4) / 8;
416 for (unsigned i = 0; i < FileWrites; ++i)
417 OF << "01234567";
418 OF.close();
419
420 Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath);
421 ASSERT_THAT_EXPECTED(File, Succeeded());
422 auto OnExit =
423 make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
424
425 auto MBOrError = MemoryBuffer::getOpenFile(*File, TestPath,
426 /*FileSize=*/-1, /*RequiresNullTerminator=*/false, /*IsVolatile=*/true);
427 ASSERT_NO_ERROR(MBOrError.getError())
428 OwningBuffer MB = std::move(*MBOrError);
429 EXPECT_EQ(MB->getBufferKind(), MemoryBuffer::MemoryBuffer_MMap);
430 EXPECT_EQ(MB->getBufferSize(), std::size_t(FileWrites * 8));
431 EXPECT_TRUE(MB->getBuffer().startswith("01234567"));
432 }
433
434 // Test that SmallVector without a null terminator gets one.
435 TEST(SmallVectorMemoryBufferTest, WithoutNullTerminatorRequiresNullTerminator) {
436 SmallString<0> Data("some data");
437
438 SmallVectorMemoryBuffer MB(std::move(Data),
439 /*RequiresNullTerminator=*/true);
440 EXPECT_EQ(MB.getBufferSize(), 9u);
441 EXPECT_EQ(MB.getBufferEnd()[0], '\0');
442 }
443
444 // Test that SmallVector with a null terminator keeps it.
445 TEST(SmallVectorMemoryBufferTest, WithNullTerminatorRequiresNullTerminator) {
446 SmallString<0> Data("some data");
447 Data.push_back('\0');
448 Data.pop_back();
449
450 SmallVectorMemoryBuffer MB(std::move(Data),
451 /*RequiresNullTerminator=*/true);
452 EXPECT_EQ(MB.getBufferSize(), 9u);
453 EXPECT_EQ(MB.getBufferEnd()[0], '\0');
454 }
455
456 } // namespace