1//===- llvm/unittest/DebugInfo/PDB/MappedBlockStreamTest.cpp --------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include <unordered_map>
11
12#include "llvm/DebugInfo/CodeView/ByteStream.h"
13#include "llvm/DebugInfo/CodeView/StreamReader.h"
14#include "llvm/DebugInfo/CodeView/StreamRef.h"
15#include "llvm/DebugInfo/CodeView/StreamWriter.h"
16#include "llvm/DebugInfo/PDB/Raw/IPDBFile.h"
17#include "llvm/DebugInfo/PDB/Raw/IPDBStreamData.h"
18#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
19#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
20#include "gtest/gtest.h"
21
22using namespace llvm;
23using namespace llvm::codeview;
24using namespace llvm::pdb;
25
26namespace {
27
28#define EXPECT_NO_ERROR(Err)                                                   \
29  {                                                                            \
30    auto E = Err;                                                              \
31    EXPECT_FALSE(static_cast<bool>(E));                                        \
32    if (E)                                                                     \
33      consumeError(std::move(E));                                              \
34  }
35
36#define EXPECT_ERROR(Err)                                                      \
37  {                                                                            \
38    auto E = Err;                                                              \
39    EXPECT_TRUE(static_cast<bool>(E));                                         \
40    if (E)                                                                     \
41      consumeError(std::move(E));                                              \
42  }
43
44static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
45static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'};
46
47class DiscontiguousFile : public IPDBFile {
48public:
49  DiscontiguousFile(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data)
50      : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {}
51
52  uint32_t getBlockSize() const override { return 1; }
53  uint32_t getBlockCount() const override { return Blocks.size(); }
54  uint32_t getNumStreams() const override { return 1; }
55  uint32_t getStreamByteSize(uint32_t StreamIndex) const override {
56    return getBlockCount() * getBlockSize();
57  }
58  ArrayRef<support::ulittle32_t>
59  getStreamBlockList(uint32_t StreamIndex) const override {
60    if (StreamIndex != 0)
61      return ArrayRef<support::ulittle32_t>();
62    return Blocks;
63  }
64  Expected<ArrayRef<uint8_t>> getBlockData(uint32_t BlockIndex,
65                                           uint32_t NumBytes) const override {
66    return ArrayRef<uint8_t>(&Data[BlockIndex], NumBytes);
67  }
68
69  Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
70                     ArrayRef<uint8_t> SrcData) const override {
71    if (BlockIndex >= Blocks.size())
72      return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
73    if (Offset > getBlockSize() - SrcData.size())
74      return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
75    ::memcpy(&Data[BlockIndex] + Offset, SrcData.data(), SrcData.size());
76    return Error::success();
77  }
78
79private:
80  std::vector<support::ulittle32_t> Blocks;
81  MutableArrayRef<uint8_t> Data;
82};
83
84class MappedBlockStreamImpl : public MappedBlockStream {
85public:
86  MappedBlockStreamImpl(std::unique_ptr<IPDBStreamData> Data,
87                        const IPDBFile &File)
88      : MappedBlockStream(std::move(Data), File) {}
89};
90
91// Tests that a read which is entirely contained within a single block works
92// and does not allocate.
93TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) {
94  DiscontiguousFile F(BlocksAry, DataAry);
95  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
96  StreamReader R(S);
97  StreamRef SR;
98  EXPECT_NO_ERROR(R.readStreamRef(SR, 0U));
99  ArrayRef<uint8_t> Buffer;
100  EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer));
101  EXPECT_NO_ERROR(R.readStreamRef(SR, 1U));
102  EXPECT_ERROR(SR.readBytes(1U, 1U, Buffer));
103}
104
105// Tests that a read which outputs into a full destination buffer works and
106// does not fail due to the length of the output buffer.
107TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
108  DiscontiguousFile F(BlocksAry, DataAry);
109  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
110  StreamReader R(S);
111  StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
112  EXPECT_NO_ERROR(R.readFixedString(Str, 1));
113  EXPECT_EQ(Str, StringRef("A"));
114  EXPECT_EQ(0U, S.getNumBytesCopied());
115}
116
117// Tests that a read which crosses a block boundary, but where the subsequent
118// blocks are still contiguous in memory to the previous block works and does
119// not allocate memory.
120TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
121  DiscontiguousFile F(BlocksAry, DataAry);
122  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
123  StreamReader R(S);
124  StringRef Str;
125  EXPECT_NO_ERROR(R.readFixedString(Str, 2));
126  EXPECT_EQ(Str, StringRef("AB"));
127  EXPECT_EQ(0U, S.getNumBytesCopied());
128
129  R.setOffset(6);
130  EXPECT_NO_ERROR(R.readFixedString(Str, 4));
131  EXPECT_EQ(Str, StringRef("GHIJ"));
132  EXPECT_EQ(0U, S.getNumBytesCopied());
133}
134
135// Tests that a read which crosses a block boundary and cannot be referenced
136// contiguously works and allocates only the precise amount of bytes
137// requested.
138TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
139  DiscontiguousFile F(BlocksAry, DataAry);
140  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
141  StreamReader R(S);
142  StringRef Str;
143  EXPECT_NO_ERROR(R.readFixedString(Str, 10));
144  EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
145  EXPECT_EQ(10U, S.getNumBytesCopied());
146}
147
148// Test that an out of bounds read which doesn't cross a block boundary
149// fails and allocates no memory.
150TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
151  DiscontiguousFile F(BlocksAry, DataAry);
152  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
153  StreamReader R(S);
154  StringRef Str;
155
156  R.setOffset(10);
157  EXPECT_ERROR(R.readFixedString(Str, 1));
158  EXPECT_EQ(0U, S.getNumBytesCopied());
159}
160
161// Test that an out of bounds read which crosses a contiguous block boundary
162// fails and allocates no memory.
163TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
164  DiscontiguousFile F(BlocksAry, DataAry);
165  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
166  StreamReader R(S);
167  StringRef Str;
168
169  R.setOffset(6);
170  EXPECT_ERROR(R.readFixedString(Str, 5));
171  EXPECT_EQ(0U, S.getNumBytesCopied());
172}
173
174// Test that an out of bounds read which crosses a discontiguous block
175// boundary fails and allocates no memory.
176TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
177  DiscontiguousFile F(BlocksAry, DataAry);
178  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
179  StreamReader R(S);
180  StringRef Str;
181
182  EXPECT_ERROR(R.readFixedString(Str, 11));
183  EXPECT_EQ(0U, S.getNumBytesCopied());
184}
185
186// Tests that a read which is entirely contained within a single block but
187// beyond the end of a StreamRef fails.
188TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
189  DiscontiguousFile F(BlocksAry, DataAry);
190  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
191  StreamReader R(S);
192  StringRef Str;
193  EXPECT_NO_ERROR(R.readFixedString(Str, 1));
194  EXPECT_EQ(Str, StringRef("A"));
195  EXPECT_EQ(0U, S.getNumBytesCopied());
196}
197
198// Tests that a read which is not aligned on the same boundary as a previous
199// cached request, but which is known to overlap that request, shares the
200// previous allocation.
201TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
202  DiscontiguousFile F(BlocksAry, DataAry);
203  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
204  StreamReader R(S);
205  StringRef Str1;
206  StringRef Str2;
207  EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
208  EXPECT_EQ(Str1, StringRef("ABCDEFG"));
209  EXPECT_EQ(7U, S.getNumBytesCopied());
210
211  R.setOffset(2);
212  EXPECT_NO_ERROR(R.readFixedString(Str2, 3));
213  EXPECT_EQ(Str2, StringRef("CDE"));
214  EXPECT_EQ(Str1.data() + 2, Str2.data());
215  EXPECT_EQ(7U, S.getNumBytesCopied());
216}
217
218// Tests that a read which is not aligned on the same boundary as a previous
219// cached request, but which only partially overlaps a previous cached request,
220// still works correctly and allocates again from the shared pool.
221TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
222  DiscontiguousFile F(BlocksAry, DataAry);
223  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
224  StreamReader R(S);
225  StringRef Str1;
226  StringRef Str2;
227  EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
228  EXPECT_EQ(Str1, StringRef("ABCDEF"));
229  EXPECT_EQ(6U, S.getNumBytesCopied());
230
231  R.setOffset(4);
232  EXPECT_NO_ERROR(R.readFixedString(Str2, 4));
233  EXPECT_EQ(Str2, StringRef("EFGH"));
234  EXPECT_EQ(10U, S.getNumBytesCopied());
235}
236
237TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
238  static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
239  static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5',
240                                  '6', '7', '8', '9', 'A'};
241  static uint8_t SmallBuffer[] = {'0', '1', '2'};
242  static_assert(sizeof(LargeBuffer) > sizeof(Data),
243                "LargeBuffer is not big enough");
244
245  DiscontiguousFile F(BlocksAry, Data);
246  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
247  ArrayRef<uint8_t> Buffer;
248
249  EXPECT_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)));
250  EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)));
251  EXPECT_NO_ERROR(S.writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)));
252  EXPECT_ERROR(S.writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)));
253}
254
255TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) {
256  static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
257  DiscontiguousFile F(BlocksAry, Data);
258  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
259  ArrayRef<uint8_t> Buffer;
260
261  EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
262  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
263  EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
264  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
265
266  EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('J')));
267  EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('A')));
268
269  EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
270  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
271  EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
272  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
273
274  EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('A')));
275  EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('J')));
276
277  EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
278  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
279  EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
280  EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
281}
282
283TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) {
284  static uint8_t Data[] = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0'};
285  static uint8_t TestData[] = {'T', 'E', 'S', 'T', 'I', 'N', 'G', '.'};
286  static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I',
287                               'T', 'G', '.', '0', '0'};
288
289  DiscontiguousFile F(BlocksAry, Data);
290  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
291  ArrayRef<uint8_t> Buffer;
292
293  EXPECT_NO_ERROR(S.writeBytes(0, TestData));
294  // First just compare the memory, then compare the result of reading the
295  // string out.
296  EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected));
297
298  EXPECT_NO_ERROR(S.readBytes(0, 8, Buffer));
299  EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData));
300}
301
302TEST(MappedBlockStreamTest, TestWriteThenRead) {
303  std::vector<uint8_t> DataBytes(10);
304  MutableArrayRef<uint8_t> Data(DataBytes);
305  const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
306
307  DiscontiguousFile F(Blocks, Data);
308  MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F), F);
309
310  enum class MyEnum : uint32_t { Val1 = 2908234, Val2 = 120891234 };
311  using support::ulittle32_t;
312
313  uint16_t u16[] = {31468, 0};
314  uint32_t u32[] = {890723408, 0};
315  MyEnum Enum[] = {MyEnum::Val1, MyEnum::Val2};
316  StringRef ZStr[] = {"Zero Str", ""};
317  StringRef FStr[] = {"Fixed Str", ""};
318  uint8_t byteArray0[] = {'1', '2'};
319  uint8_t byteArray1[] = {'0', '0'};
320  ArrayRef<uint8_t> byteArrayRef0(byteArray0);
321  ArrayRef<uint8_t> byteArrayRef1(byteArray1);
322  ArrayRef<uint8_t> byteArray[] = { byteArrayRef0, byteArrayRef1 };
323  ArrayRef<uint32_t> intArray[] = {{890723408, 29082234}, {0, 0}};
324
325  StreamReader Reader(S);
326  StreamWriter Writer(S);
327  EXPECT_NO_ERROR(Writer.writeInteger(u16[0]));
328  EXPECT_NO_ERROR(Reader.readInteger(u16[1]));
329  EXPECT_EQ(u16[0], u16[1]);
330  EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}),
331            DataBytes);
332
333  Reader.setOffset(0);
334  Writer.setOffset(0);
335  ::memset(DataBytes.data(), 0, 10);
336  EXPECT_NO_ERROR(Writer.writeInteger(u32[0]));
337  EXPECT_NO_ERROR(Reader.readInteger(u32[1]));
338  EXPECT_EQ(u32[0], u32[1]);
339  EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}),
340            DataBytes);
341
342  Reader.setOffset(0);
343  Writer.setOffset(0);
344  ::memset(DataBytes.data(), 0, 10);
345  EXPECT_NO_ERROR(Writer.writeEnum(Enum[0]));
346  EXPECT_NO_ERROR(Reader.readEnum(Enum[1]));
347  EXPECT_EQ(Enum[0], Enum[1]);
348  EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}),
349            DataBytes);
350
351  Reader.setOffset(0);
352  Writer.setOffset(0);
353  ::memset(DataBytes.data(), 0, 10);
354  EXPECT_NO_ERROR(Writer.writeZeroString(ZStr[0]));
355  EXPECT_NO_ERROR(Reader.readZeroString(ZStr[1]));
356  EXPECT_EQ(ZStr[0], ZStr[1]);
357  EXPECT_EQ(
358      std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}),
359      DataBytes);
360
361  Reader.setOffset(0);
362  Writer.setOffset(0);
363  ::memset(DataBytes.data(), 0, 10);
364  EXPECT_NO_ERROR(Writer.writeFixedString(FStr[0]));
365  EXPECT_NO_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()));
366  EXPECT_EQ(FStr[0], FStr[1]);
367  EXPECT_EQ(
368      std::vector<uint8_t>({'x', 'i', 'F', 'd', ' ', 'S', 'e', 't', 0, 'r'}),
369      DataBytes);
370
371  Reader.setOffset(0);
372  Writer.setOffset(0);
373  ::memset(DataBytes.data(), 0, 10);
374  EXPECT_NO_ERROR(Writer.writeArray(byteArray[0]));
375  EXPECT_NO_ERROR(Reader.readArray(byteArray[1], byteArray[0].size()));
376  EXPECT_EQ(byteArray[0], byteArray[1]);
377  EXPECT_EQ(std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}),
378            DataBytes);
379
380  Reader.setOffset(0);
381  Writer.setOffset(0);
382  ::memset(DataBytes.data(), 0, 10);
383  EXPECT_NO_ERROR(Writer.writeArray(intArray[0]));
384  EXPECT_NO_ERROR(Reader.readArray(intArray[1], intArray[0].size()));
385  EXPECT_EQ(intArray[0], intArray[1]);
386}
387
388TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
389  std::vector<uint8_t> DestDataBytes(10);
390  MutableArrayRef<uint8_t> DestData(DestDataBytes);
391  const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
392
393  std::vector<uint8_t> SrcDataBytes(10);
394  MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
395
396  DiscontiguousFile F(DestBlocks, DestData);
397  MappedBlockStreamImpl DestStream(llvm::make_unique<IndexedStreamData>(0, F),
398                                   F);
399
400  // First write "Test Str" into the source stream.
401  ByteStream<true> SourceStream(SrcData);
402  StreamWriter SourceWriter(SourceStream);
403  EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
404  EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
405                              {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0}));
406
407  // Then write the source stream into the dest stream.
408  StreamWriter DestWriter(DestStream);
409  EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream));
410  EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
411                               {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
412
413  // Then read the string back out of the dest stream.
414  StringRef Result;
415  StreamReader DestReader(DestStream);
416  EXPECT_NO_ERROR(DestReader.readZeroString(Result));
417  EXPECT_EQ(Result, "Test Str");
418}
419
420TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) {
421  std::vector<uint8_t> DestDataBytes(10);
422  MutableArrayRef<uint8_t> DestData(DestDataBytes);
423  const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
424
425  std::vector<uint8_t> SrcDataBytes(10);
426  MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
427  const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9};
428
429  DiscontiguousFile DestFile(DestBlocks, DestData);
430  DiscontiguousFile SrcFile(SrcBlocks, SrcData);
431
432  MappedBlockStreamImpl DestStream(
433      llvm::make_unique<IndexedStreamData>(0, DestFile), DestFile);
434  MappedBlockStreamImpl SrcStream(
435      llvm::make_unique<IndexedStreamData>(0, SrcFile), SrcFile);
436
437  // First write "Test Str" into the source stream.
438  StreamWriter SourceWriter(SrcStream);
439  EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
440  EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
441                              {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0}));
442
443  // Then write the source stream into the dest stream.
444  StreamWriter DestWriter(DestStream);
445  EXPECT_NO_ERROR(DestWriter.writeStreamRef(SrcStream));
446  EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
447                               {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
448
449  // Then read the string back out of the dest stream.
450  StringRef Result;
451  StreamReader DestReader(DestStream);
452  EXPECT_NO_ERROR(DestReader.readZeroString(Result));
453  EXPECT_EQ(Result, "Test Str");
454}
455
456} // end anonymous namespace
457