llvm/unittests/Support/MemoryBufferTest.cpp

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