summaryrefslogtreecommitdiff
path: root/unittests/DebugInfo/PDB
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/DebugInfo/PDB')
-rw-r--r--unittests/DebugInfo/PDB/CMakeLists.txt3
-rw-r--r--unittests/DebugInfo/PDB/ErrorChecking.h41
-rw-r--r--unittests/DebugInfo/PDB/Makefile16
-rw-r--r--unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp442
-rw-r--r--unittests/DebugInfo/PDB/MsfBuilderTest.cpp360
-rw-r--r--unittests/DebugInfo/PDB/PDBApiTest.cpp27
6 files changed, 873 insertions, 16 deletions
diff --git a/unittests/DebugInfo/PDB/CMakeLists.txt b/unittests/DebugInfo/PDB/CMakeLists.txt
index 91924a5a87544..405b7bb9b1a6c 100644
--- a/unittests/DebugInfo/PDB/CMakeLists.txt
+++ b/unittests/DebugInfo/PDB/CMakeLists.txt
@@ -1,8 +1,11 @@
set(LLVM_LINK_COMPONENTS
+ DebugInfoCodeView
DebugInfoPDB
)
set(DebugInfoPDBSources
+ MappedBlockStreamTest.cpp
+ MsfBuilderTest.cpp
PDBApiTest.cpp
)
diff --git a/unittests/DebugInfo/PDB/ErrorChecking.h b/unittests/DebugInfo/PDB/ErrorChecking.h
new file mode 100644
index 0000000000000..da734a9b1b5ba
--- /dev/null
+++ b/unittests/DebugInfo/PDB/ErrorChecking.h
@@ -0,0 +1,41 @@
+//===- ErrorChecking.h - Helpers for verifying llvm::Errors -----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UNITTESTS_DEBUGINFO_PDB_ERRORCHECKING_H
+#define LLVM_UNITTESTS_DEBUGINFO_PDB_ERRORCHECKING_H
+
+#define EXPECT_NO_ERROR(Err) \
+ { \
+ auto E = Err; \
+ EXPECT_FALSE(static_cast<bool>(E)); \
+ if (E) \
+ consumeError(std::move(E)); \
+ }
+
+#define EXPECT_ERROR(Err) \
+ { \
+ auto E = Err; \
+ EXPECT_TRUE(static_cast<bool>(E)); \
+ if (E) \
+ consumeError(std::move(E)); \
+ }
+
+#define EXPECT_EXPECTED(Exp) \
+ { \
+ auto E = Exp.takeError(); \
+ EXPECT_FALSE(static_cast<bool>(E)); \
+ if (E) { \
+ consumeError(std::move(E)); \
+ return; \
+ } \
+ }
+
+#define EXPECT_UNEXPECTED(Exp) EXPECT_ERROR(Err)
+
+#endif
diff --git a/unittests/DebugInfo/PDB/Makefile b/unittests/DebugInfo/PDB/Makefile
deleted file mode 100644
index eb118a3fd2bd1..0000000000000
--- a/unittests/DebugInfo/PDB/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-##===- unittests/DebugInfo/PDB/Makefile -------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-LEVEL = ../../..
-TESTNAME = DebugInfoPDB
-LINK_COMPONENTS := DebugInfoPDB support
-
-include $(LEVEL)/Makefile.config
-
-include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest
diff --git a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
new file mode 100644
index 0000000000000..6f9e86c4f2620
--- /dev/null
+++ b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
@@ -0,0 +1,442 @@
+//===- llvm/unittest/DebugInfo/PDB/MappedBlockStreamTest.cpp --------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ErrorChecking.h"
+
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
+#include "llvm/DebugInfo/CodeView/StreamRef.h"
+#include "llvm/DebugInfo/CodeView/StreamWriter.h"
+#include "llvm/DebugInfo/PDB/Raw/IPDBFile.h"
+#include "llvm/DebugInfo/PDB/Raw/IPDBStreamData.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
+#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
+#include "gtest/gtest.h"
+
+#include <unordered_map>
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+namespace {
+
+static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
+static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'};
+
+class DiscontiguousFile : public IPDBFile {
+public:
+ DiscontiguousFile(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data)
+ : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {}
+
+ uint32_t getBlockSize() const override { return 1; }
+ uint32_t getBlockCount() const override { return Blocks.size(); }
+ uint32_t getNumStreams() const override { return 1; }
+ uint32_t getStreamByteSize(uint32_t StreamIndex) const override {
+ return getBlockCount() * getBlockSize();
+ }
+ ArrayRef<support::ulittle32_t>
+ getStreamBlockList(uint32_t StreamIndex) const override {
+ if (StreamIndex != 0)
+ return ArrayRef<support::ulittle32_t>();
+ return Blocks;
+ }
+ Expected<ArrayRef<uint8_t>> getBlockData(uint32_t BlockIndex,
+ uint32_t NumBytes) const override {
+ return ArrayRef<uint8_t>(&Data[BlockIndex], NumBytes);
+ }
+
+ Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
+ ArrayRef<uint8_t> SrcData) const override {
+ if (BlockIndex >= Blocks.size())
+ return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
+ if (Offset > getBlockSize() - SrcData.size())
+ return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
+ ::memcpy(&Data[BlockIndex] + Offset, SrcData.data(), SrcData.size());
+ return Error::success();
+ }
+
+private:
+ std::vector<support::ulittle32_t> Blocks;
+ MutableArrayRef<uint8_t> Data;
+};
+
+class MappedBlockStreamImpl : public MappedBlockStream {
+public:
+ MappedBlockStreamImpl(std::unique_ptr<IPDBStreamData> Data,
+ const IPDBFile &File)
+ : MappedBlockStream(std::move(Data), File) {}
+};
+
+// Tests that a read which is entirely contained within a single block works
+// and does not allocate.
+TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StreamRef SR;
+ EXPECT_NO_ERROR(R.readStreamRef(SR, 0U));
+ ArrayRef<uint8_t> Buffer;
+ EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer));
+ EXPECT_NO_ERROR(R.readStreamRef(SR, 1U));
+ EXPECT_ERROR(SR.readBytes(1U, 1U, Buffer));
+}
+
+// Tests that a read which outputs into a full destination buffer works and
+// does not fail due to the length of the output buffer.
+TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
+ EXPECT_NO_ERROR(R.readFixedString(Str, 1));
+ EXPECT_EQ(Str, StringRef("A"));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Tests that a read which crosses a block boundary, but where the subsequent
+// blocks are still contiguous in memory to the previous block works and does
+// not allocate memory.
+TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+ EXPECT_NO_ERROR(R.readFixedString(Str, 2));
+ EXPECT_EQ(Str, StringRef("AB"));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+
+ R.setOffset(6);
+ EXPECT_NO_ERROR(R.readFixedString(Str, 4));
+ EXPECT_EQ(Str, StringRef("GHIJ"));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Tests that a read which crosses a block boundary and cannot be referenced
+// contiguously works and allocates only the precise amount of bytes
+// requested.
+TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+ EXPECT_NO_ERROR(R.readFixedString(Str, 10));
+ EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
+ EXPECT_EQ(10U, S.getNumBytesCopied());
+}
+
+// Test that an out of bounds read which doesn't cross a block boundary
+// fails and allocates no memory.
+TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+
+ R.setOffset(10);
+ EXPECT_ERROR(R.readFixedString(Str, 1));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Test that an out of bounds read which crosses a contiguous block boundary
+// fails and allocates no memory.
+TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+
+ R.setOffset(6);
+ EXPECT_ERROR(R.readFixedString(Str, 5));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Test that an out of bounds read which crosses a discontiguous block
+// boundary fails and allocates no memory.
+TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+
+ EXPECT_ERROR(R.readFixedString(Str, 11));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Tests that a read which is entirely contained within a single block but
+// beyond the end of a StreamRef fails.
+TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str;
+ EXPECT_NO_ERROR(R.readFixedString(Str, 1));
+ EXPECT_EQ(Str, StringRef("A"));
+ EXPECT_EQ(0U, S.getNumBytesCopied());
+}
+
+// Tests that a read which is not aligned on the same boundary as a previous
+// cached request, but which is known to overlap that request, shares the
+// previous allocation.
+TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str1;
+ StringRef Str2;
+ EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
+ EXPECT_EQ(Str1, StringRef("ABCDEFG"));
+ EXPECT_EQ(7U, S.getNumBytesCopied());
+
+ R.setOffset(2);
+ EXPECT_NO_ERROR(R.readFixedString(Str2, 3));
+ EXPECT_EQ(Str2, StringRef("CDE"));
+ EXPECT_EQ(Str1.data() + 2, Str2.data());
+ EXPECT_EQ(7U, S.getNumBytesCopied());
+}
+
+// Tests that a read which is not aligned on the same boundary as a previous
+// cached request, but which only partially overlaps a previous cached request,
+// still works correctly and allocates again from the shared pool.
+TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
+ DiscontiguousFile F(BlocksAry, DataAry);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ StreamReader R(S);
+ StringRef Str1;
+ StringRef Str2;
+ EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
+ EXPECT_EQ(Str1, StringRef("ABCDEF"));
+ EXPECT_EQ(6U, S.getNumBytesCopied());
+
+ R.setOffset(4);
+ EXPECT_NO_ERROR(R.readFixedString(Str2, 4));
+ EXPECT_EQ(Str2, StringRef("EFGH"));
+ EXPECT_EQ(10U, S.getNumBytesCopied());
+}
+
+TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
+ static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
+ static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5',
+ '6', '7', '8', '9', 'A'};
+ static uint8_t SmallBuffer[] = {'0', '1', '2'};
+ static_assert(sizeof(LargeBuffer) > sizeof(Data),
+ "LargeBuffer is not big enough");
+
+ DiscontiguousFile F(BlocksAry, Data);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ ArrayRef<uint8_t> Buffer;
+
+ EXPECT_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)));
+ EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)));
+ EXPECT_NO_ERROR(S.writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)));
+ EXPECT_ERROR(S.writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)));
+}
+
+TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) {
+ static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
+ DiscontiguousFile F(BlocksAry, Data);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ ArrayRef<uint8_t> Buffer;
+
+ EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
+ EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
+
+ EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('J')));
+ EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('A')));
+
+ EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
+ EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
+
+ EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('A')));
+ EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('J')));
+
+ EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
+ EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
+}
+
+TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) {
+ static uint8_t Data[] = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0'};
+ static uint8_t TestData[] = {'T', 'E', 'S', 'T', 'I', 'N', 'G', '.'};
+ static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I',
+ 'T', 'G', '.', '0', '0'};
+
+ DiscontiguousFile F(BlocksAry, Data);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+ ArrayRef<uint8_t> Buffer;
+
+ EXPECT_NO_ERROR(S.writeBytes(0, TestData));
+ // First just compare the memory, then compare the result of reading the
+ // string out.
+ EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected));
+
+ EXPECT_NO_ERROR(S.readBytes(0, 8, Buffer));
+ EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData));
+}
+
+TEST(MappedBlockStreamTest, TestWriteThenRead) {
+ std::vector<uint8_t> DataBytes(10);
+ MutableArrayRef<uint8_t> Data(DataBytes);
+ const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
+
+ DiscontiguousFile F(Blocks, Data);
+ MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
+
+ enum class MyEnum : uint32_t { Val1 = 2908234, Val2 = 120891234 };
+ using support::ulittle32_t;
+
+ uint16_t u16[] = {31468, 0};
+ uint32_t u32[] = {890723408, 0};
+ MyEnum Enum[] = {MyEnum::Val1, MyEnum::Val2};
+ StringRef ZStr[] = {"Zero Str", ""};
+ StringRef FStr[] = {"Fixed Str", ""};
+ uint8_t byteArray0[] = {'1', '2'};
+ uint8_t byteArray1[] = {'0', '0'};
+ ArrayRef<uint8_t> byteArrayRef0(byteArray0);
+ ArrayRef<uint8_t> byteArrayRef1(byteArray1);
+ ArrayRef<uint8_t> byteArray[] = { byteArrayRef0, byteArrayRef1 };
+ ArrayRef<uint32_t> intArray[] = {{890723408, 29082234}, {0, 0}};
+
+ StreamReader Reader(S);
+ StreamWriter Writer(S);
+ EXPECT_NO_ERROR(Writer.writeInteger(u16[0]));
+ EXPECT_NO_ERROR(Reader.readInteger(u16[1]));
+ EXPECT_EQ(u16[0], u16[1]);
+ EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeInteger(u32[0]));
+ EXPECT_NO_ERROR(Reader.readInteger(u32[1]));
+ EXPECT_EQ(u32[0], u32[1]);
+ EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeEnum(Enum[0]));
+ EXPECT_NO_ERROR(Reader.readEnum(Enum[1]));
+ EXPECT_EQ(Enum[0], Enum[1]);
+ EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeZeroString(ZStr[0]));
+ EXPECT_NO_ERROR(Reader.readZeroString(ZStr[1]));
+ EXPECT_EQ(ZStr[0], ZStr[1]);
+ EXPECT_EQ(
+ std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeFixedString(FStr[0]));
+ EXPECT_NO_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()));
+ EXPECT_EQ(FStr[0], FStr[1]);
+ EXPECT_EQ(
+ std::vector<uint8_t>({'x', 'i', 'F', 'd', ' ', 'S', 'e', 't', 0, 'r'}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeArray(byteArray[0]));
+ EXPECT_NO_ERROR(Reader.readArray(byteArray[1], byteArray[0].size()));
+ EXPECT_EQ(byteArray[0], byteArray[1]);
+ EXPECT_EQ(std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}),
+ DataBytes);
+
+ Reader.setOffset(0);
+ Writer.setOffset(0);
+ ::memset(DataBytes.data(), 0, 10);
+ EXPECT_NO_ERROR(Writer.writeArray(intArray[0]));
+ EXPECT_NO_ERROR(Reader.readArray(intArray[1], intArray[0].size()));
+ EXPECT_EQ(intArray[0], intArray[1]);
+}
+
+TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
+ std::vector<uint8_t> DestDataBytes(10);
+ MutableArrayRef<uint8_t> DestData(DestDataBytes);
+ const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
+
+ std::vector<uint8_t> SrcDataBytes(10);
+ MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
+
+ DiscontiguousFile F(DestBlocks, DestData);
+ MappedBlockStreamImpl DestStream(llvm::make_unique<IndexedStreamData>(0, F),
+ F);
+
+ // First write "Test Str" into the source stream.
+ ByteStream<true> SourceStream(SrcData);
+ StreamWriter SourceWriter(SourceStream);
+ EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
+ EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
+ {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0}));
+
+ // Then write the source stream into the dest stream.
+ StreamWriter DestWriter(DestStream);
+ EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream));
+ EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
+ {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
+
+ // Then read the string back out of the dest stream.
+ StringRef Result;
+ StreamReader DestReader(DestStream);
+ EXPECT_NO_ERROR(DestReader.readZeroString(Result));
+ EXPECT_EQ(Result, "Test Str");
+}
+
+TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) {
+ std::vector<uint8_t> DestDataBytes(10);
+ MutableArrayRef<uint8_t> DestData(DestDataBytes);
+ const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
+
+ std::vector<uint8_t> SrcDataBytes(10);
+ MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
+ const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9};
+
+ DiscontiguousFile DestFile(DestBlocks, DestData);
+ DiscontiguousFile SrcFile(SrcBlocks, SrcData);
+
+ MappedBlockStreamImpl DestStream(
+ llvm::make_unique<IndexedStreamData>(0, DestFile), DestFile);
+ MappedBlockStreamImpl SrcStream(
+ llvm::make_unique<IndexedStreamData>(0, SrcFile), SrcFile);
+
+ // First write "Test Str" into the source stream.
+ StreamWriter SourceWriter(SrcStream);
+ EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
+ EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
+ {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0}));
+
+ // Then write the source stream into the dest stream.
+ StreamWriter DestWriter(DestStream);
+ EXPECT_NO_ERROR(DestWriter.writeStreamRef(SrcStream));
+ EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
+ {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
+
+ // Then read the string back out of the dest stream.
+ StringRef Result;
+ StreamReader DestReader(DestStream);
+ EXPECT_NO_ERROR(DestReader.readZeroString(Result));
+ EXPECT_EQ(Result, "Test Str");
+}
+
+} // end anonymous namespace
diff --git a/unittests/DebugInfo/PDB/MsfBuilderTest.cpp b/unittests/DebugInfo/PDB/MsfBuilderTest.cpp
new file mode 100644
index 0000000000000..ac292a73a8fb7
--- /dev/null
+++ b/unittests/DebugInfo/PDB/MsfBuilderTest.cpp
@@ -0,0 +1,360 @@
+//===- MsfBuilderTest.cpp Tests manipulation of MSF stream metadata ------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ErrorChecking.h"
+
+#include "llvm/DebugInfo/PDB/Raw/MsfBuilder.h"
+#include "llvm/DebugInfo/PDB/Raw/MsfCommon.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+using namespace llvm::pdb::msf;
+
+namespace {
+class MsfBuilderTest : public testing::Test {
+protected:
+ void initializeSimpleSuperBlock(msf::SuperBlock &SB) {
+ initializeSuperBlock(SB);
+ SB.NumBlocks = 1000;
+ SB.NumDirectoryBytes = 8192;
+ }
+
+ void initializeSuperBlock(msf::SuperBlock &SB) {
+ ::memset(&SB, 0, sizeof(SB));
+
+ ::memcpy(SB.MagicBytes, msf::Magic, sizeof(msf::Magic));
+ SB.BlockMapAddr = 1;
+ SB.BlockSize = 4096;
+ SB.NumDirectoryBytes = 0;
+ SB.NumBlocks = 2; // one for the Super Block, one for the directory
+ }
+
+ BumpPtrAllocator Allocator;
+};
+}
+
+TEST_F(MsfBuilderTest, ValidateSuperBlockAccept) {
+ // Test that a known good super block passes validation.
+ SuperBlock SB;
+ initializeSuperBlock(SB);
+
+ EXPECT_NO_ERROR(msf::validateSuperBlock(SB));
+}
+
+TEST_F(MsfBuilderTest, ValidateSuperBlockReject) {
+ // Test that various known problems cause a super block to be rejected.
+ SuperBlock SB;
+ initializeSimpleSuperBlock(SB);
+
+ // Mismatched magic
+ SB.MagicBytes[0] = 8;
+ EXPECT_ERROR(msf::validateSuperBlock(SB));
+ initializeSimpleSuperBlock(SB);
+
+ // Block 0 is reserved for super block, can't be occupied by the block map
+ SB.BlockMapAddr = 0;
+ EXPECT_ERROR(msf::validateSuperBlock(SB));
+ initializeSimpleSuperBlock(SB);
+
+ // Block sizes have to be powers of 2.
+ SB.BlockSize = 3120;
+ EXPECT_ERROR(msf::validateSuperBlock(SB));
+ initializeSimpleSuperBlock(SB);
+
+ // The directory itself has a maximum size.
+ SB.NumDirectoryBytes = SB.BlockSize * SB.BlockSize / 4;
+ EXPECT_NO_ERROR(msf::validateSuperBlock(SB));
+ SB.NumDirectoryBytes = SB.NumDirectoryBytes + 4;
+ EXPECT_ERROR(msf::validateSuperBlock(SB));
+}
+
+TEST_F(MsfBuilderTest, TestUsedBlocksMarkedAsUsed) {
+ // Test that when assigning a stream to a known list of blocks, the blocks
+ // are correctly marked as used after adding, but no other incorrect blocks
+ // are accidentally marked as used.
+
+ std::vector<uint32_t> Blocks = {4, 5, 6, 7, 8, 9, 10, 11, 12};
+ // Allocate some extra blocks at the end so we can verify that they're free
+ // after the initialization.
+ uint32_t NumBlocks = msf::getMinimumBlockCount() + Blocks.size() + 10;
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096, NumBlocks);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(Blocks.size() * 4096, Blocks));
+
+ for (auto B : Blocks) {
+ EXPECT_FALSE(Msf.isBlockFree(B));
+ }
+
+ uint32_t FreeBlockStart = Blocks.back() + 1;
+ for (uint32_t I = FreeBlockStart; I < NumBlocks; ++I) {
+ EXPECT_TRUE(Msf.isBlockFree(I));
+ }
+}
+
+TEST_F(MsfBuilderTest, TestAddStreamNoDirectoryBlockIncrease) {
+ // Test that adding a new stream correctly updates the directory. This only
+ // tests the case where the directory *DOES NOT* grow large enough that it
+ // crosses a Block boundary.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ auto ExpectedL1 = Msf.build();
+ EXPECT_EXPECTED(ExpectedL1);
+ Layout &L1 = *ExpectedL1;
+
+ auto OldDirBlocks = L1.DirectoryBlocks;
+ EXPECT_EQ(1U, OldDirBlocks.size());
+
+ auto ExpectedMsf2 = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf2);
+ auto &Msf2 = *ExpectedMsf2;
+
+ EXPECT_NO_ERROR(Msf2.addStream(4000));
+ EXPECT_EQ(1U, Msf2.getNumStreams());
+ EXPECT_EQ(4000U, Msf2.getStreamSize(0));
+ auto Blocks = Msf2.getStreamBlocks(0);
+ EXPECT_EQ(1U, Blocks.size());
+
+ auto ExpectedL2 = Msf2.build();
+ EXPECT_EXPECTED(ExpectedL2);
+ Layout &L2 = *ExpectedL2;
+ auto NewDirBlocks = L2.DirectoryBlocks;
+ EXPECT_EQ(1U, NewDirBlocks.size());
+}
+
+TEST_F(MsfBuilderTest, TestAddStreamWithDirectoryBlockIncrease) {
+ // Test that adding a new stream correctly updates the directory. This only
+ // tests the case where the directory *DOES* grow large enough that it
+ // crosses a Block boundary. This is because the newly added stream occupies
+ // so many Blocks that need to be indexed in the directory that the directory
+ // crosses a Block boundary.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(4096 * 4096 / sizeof(uint32_t)));
+
+ auto ExpectedL1 = Msf.build();
+ EXPECT_EXPECTED(ExpectedL1);
+ Layout &L1 = *ExpectedL1;
+ auto DirBlocks = L1.DirectoryBlocks;
+ EXPECT_EQ(2U, DirBlocks.size());
+}
+
+TEST_F(MsfBuilderTest, TestGrowStreamNoBlockIncrease) {
+ // Test growing an existing stream by a value that does not affect the number
+ // of blocks it occupies.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(1024));
+ EXPECT_EQ(1024U, Msf.getStreamSize(0));
+ auto OldStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, OldStreamBlocks.size());
+
+ EXPECT_NO_ERROR(Msf.setStreamSize(0, 2048));
+ EXPECT_EQ(2048U, Msf.getStreamSize(0));
+ auto NewStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, NewStreamBlocks.size());
+
+ EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
+}
+
+TEST_F(MsfBuilderTest, TestGrowStreamWithBlockIncrease) {
+ // Test that growing an existing stream to a value large enough that it causes
+ // the need to allocate new Blocks to the stream correctly updates the
+ // stream's
+ // block list.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(2048));
+ EXPECT_EQ(2048U, Msf.getStreamSize(0));
+ std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, OldStreamBlocks.size());
+
+ EXPECT_NO_ERROR(Msf.setStreamSize(0, 6144));
+ EXPECT_EQ(6144U, Msf.getStreamSize(0));
+ std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(2U, NewStreamBlocks.size());
+
+ EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
+ EXPECT_NE(NewStreamBlocks[0], NewStreamBlocks[1]);
+}
+
+TEST_F(MsfBuilderTest, TestShrinkStreamNoBlockDecrease) {
+ // Test that shrinking an existing stream by a value that does not affect the
+ // number of Blocks it occupies makes no changes to stream's block list.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(2048));
+ EXPECT_EQ(2048U, Msf.getStreamSize(0));
+ std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, OldStreamBlocks.size());
+
+ EXPECT_NO_ERROR(Msf.setStreamSize(0, 1024));
+ EXPECT_EQ(1024U, Msf.getStreamSize(0));
+ std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, NewStreamBlocks.size());
+
+ EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
+}
+
+TEST_F(MsfBuilderTest, TestShrinkStreamWithBlockDecrease) {
+ // Test that shrinking an existing stream to a value large enough that it
+ // causes the need to deallocate new Blocks to the stream correctly updates
+ // the stream's block list.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(6144));
+ EXPECT_EQ(6144U, Msf.getStreamSize(0));
+ std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(2U, OldStreamBlocks.size());
+
+ EXPECT_NO_ERROR(Msf.setStreamSize(0, 2048));
+ EXPECT_EQ(2048U, Msf.getStreamSize(0));
+ std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
+ EXPECT_EQ(1U, NewStreamBlocks.size());
+
+ EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
+}
+
+TEST_F(MsfBuilderTest, TestRejectReusedStreamBlock) {
+ // Test that attempting to add a stream and assigning a block that is already
+ // in use by another stream fails.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ EXPECT_NO_ERROR(Msf.addStream(6144));
+
+ std::vector<uint32_t> Blocks = {2, 3};
+ EXPECT_ERROR(Msf.addStream(6144, Blocks));
+}
+
+TEST_F(MsfBuilderTest, TestBlockCountsWhenAddingStreams) {
+ // Test that when adding multiple streams, the number of used and free Blocks
+ // allocated to the MSF file are as expected.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ // one for the super block, one for the directory block map
+ uint32_t NumUsedBlocks = Msf.getNumUsedBlocks();
+ EXPECT_EQ(msf::getMinimumBlockCount(), NumUsedBlocks);
+ EXPECT_EQ(0U, Msf.getNumFreeBlocks());
+
+ const uint32_t StreamSizes[] = {4000, 6193, 189723};
+ for (int I = 0; I < 3; ++I) {
+ EXPECT_NO_ERROR(Msf.addStream(StreamSizes[I]));
+ NumUsedBlocks += bytesToBlocks(StreamSizes[I], 4096);
+ EXPECT_EQ(NumUsedBlocks, Msf.getNumUsedBlocks());
+ EXPECT_EQ(0U, Msf.getNumFreeBlocks());
+ }
+}
+
+TEST_F(MsfBuilderTest, BuildMsfLayout) {
+ // Test that we can generate an Msf Layout structure from a valid layout
+ // specification.
+ auto ExpectedMsf = MsfBuilder::create(Allocator, 4096);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ const uint32_t StreamSizes[] = {4000, 6193, 189723};
+ uint32_t ExpectedNumBlocks = msf::getMinimumBlockCount();
+ for (int I = 0; I < 3; ++I) {
+ EXPECT_NO_ERROR(Msf.addStream(StreamSizes[I]));
+ ExpectedNumBlocks += bytesToBlocks(StreamSizes[I], 4096);
+ }
+ ++ExpectedNumBlocks; // The directory itself should use 1 block
+
+ auto ExpectedLayout = Msf.build();
+ EXPECT_EXPECTED(ExpectedLayout);
+ Layout &L = *ExpectedLayout;
+ EXPECT_EQ(4096U, L.SB->BlockSize);
+ EXPECT_EQ(ExpectedNumBlocks, L.SB->NumBlocks);
+
+ EXPECT_EQ(1U, L.DirectoryBlocks.size());
+
+ EXPECT_EQ(3U, L.StreamMap.size());
+ EXPECT_EQ(3U, L.StreamSizes.size());
+ for (int I = 0; I < 3; ++I) {
+ EXPECT_EQ(StreamSizes[I], L.StreamSizes[I]);
+ uint32_t ExpectedNumBlocks = bytesToBlocks(StreamSizes[I], 4096);
+ EXPECT_EQ(ExpectedNumBlocks, L.StreamMap[I].size());
+ }
+}
+
+TEST_F(MsfBuilderTest, UseDirectoryBlockHint) {
+ Expected<MsfBuilder> ExpectedMsf = MsfBuilder::create(
+ Allocator, 4096, msf::getMinimumBlockCount() + 1, false);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ uint32_t B = msf::getFirstUnreservedBlock();
+ EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1}));
+ EXPECT_NO_ERROR(Msf.addStream(2048, {B + 2}));
+
+ auto ExpectedLayout = Msf.build();
+ EXPECT_EXPECTED(ExpectedLayout);
+ Layout &L = *ExpectedLayout;
+ EXPECT_EQ(msf::getMinimumBlockCount() + 2, L.SB->NumBlocks);
+ EXPECT_EQ(1U, L.DirectoryBlocks.size());
+ EXPECT_EQ(1U, L.StreamMap[0].size());
+
+ EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
+ EXPECT_EQ(B + 2, L.StreamMap[0].front());
+}
+
+TEST_F(MsfBuilderTest, DirectoryBlockHintInsufficient) {
+ Expected<MsfBuilder> ExpectedMsf =
+ MsfBuilder::create(Allocator, 4096, msf::getMinimumBlockCount() + 2);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+ uint32_t B = msf::getFirstUnreservedBlock();
+ EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1}));
+
+ uint32_t Size = 4096 * 4096 / 4;
+ EXPECT_NO_ERROR(Msf.addStream(Size));
+
+ auto ExpectedLayout = Msf.build();
+ EXPECT_EXPECTED(ExpectedLayout);
+ Layout &L = *ExpectedLayout;
+ EXPECT_EQ(2U, L.DirectoryBlocks.size());
+ EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
+}
+
+TEST_F(MsfBuilderTest, DirectoryBlockHintOverestimated) {
+ Expected<MsfBuilder> ExpectedMsf =
+ MsfBuilder::create(Allocator, 4096, msf::getMinimumBlockCount() + 2);
+ EXPECT_EXPECTED(ExpectedMsf);
+ auto &Msf = *ExpectedMsf;
+
+ uint32_t B = msf::getFirstUnreservedBlock();
+ EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1, B + 2}));
+
+ EXPECT_NO_ERROR(Msf.addStream(2048));
+
+ auto ExpectedLayout = Msf.build();
+ EXPECT_EXPECTED(ExpectedLayout);
+ Layout &L = *ExpectedLayout;
+ EXPECT_EQ(1U, L.DirectoryBlocks.size());
+ EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
+}
diff --git a/unittests/DebugInfo/PDB/PDBApiTest.cpp b/unittests/DebugInfo/PDB/PDBApiTest.cpp
index ebd3d7bb6b3ca..cd0f928a08ab5 100644
--- a/unittests/DebugInfo/PDB/PDBApiTest.cpp
+++ b/unittests/DebugInfo/PDB/PDBApiTest.cpp
@@ -50,6 +50,7 @@
#include "llvm/DebugInfo/PDB/PDBTypes.h"
#include "gtest/gtest.h"
using namespace llvm;
+using namespace llvm::pdb;
namespace {
@@ -78,9 +79,35 @@ class MockSession : public IPDBSession {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
+ findLineNumbers(const PDBSymbolCompiland &Compiland,
+ const IPDBSourceFile &File) const override {
+ return nullptr;
+ }
+ std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override {
return nullptr;
}
+ std::unique_ptr<IPDBEnumSourceFiles>
+ findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern,
+ PDB_NameSearchFlags Flags) const override {
+ return nullptr;
+ }
+ std::unique_ptr<IPDBSourceFile>
+ findOneSourceFile(const PDBSymbolCompiland *Compiland,
+ llvm::StringRef Pattern,
+ PDB_NameSearchFlags Flags) const override {
+ return nullptr;
+ }
+ std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
+ findCompilandsForSourceFile(llvm::StringRef Pattern,
+ PDB_NameSearchFlags Flags) const override {
+ return nullptr;
+ }
+ std::unique_ptr<PDBSymbolCompiland>
+ findOneCompilandForSourceFile(llvm::StringRef Pattern,
+ PDB_NameSearchFlags Flags) const override {
+ return nullptr;
+ }
std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override {
return nullptr;
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 05:11:57 +0000