| 1 |
//===- MSFBuilderTest.cpp Tests manipulation of MSF stream metadata ------===// |
| 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 |
#include "llvm/DebugInfo/MSF/MSFCommon.h" |
| 10 |
#include "llvm/Testing/Support/Error.h" |
| 11 |
|
| 12 |
#include "gtest/gtest.h" |
| 13 |
|
| 14 |
using namespace llvm; |
| 15 |
using namespace llvm::msf; |
| 16 |
|
| 17 |
TEST(MSFCommonTest, BytesToBlocks) { |
| 18 |
EXPECT_EQ(0ULL, bytesToBlocks(0, 4096)); |
| 19 |
EXPECT_EQ(1ULL, bytesToBlocks(12, 4096)); |
| 20 |
EXPECT_EQ(1ULL, bytesToBlocks(4096, 4096)); |
| 21 |
EXPECT_EQ(2ULL, bytesToBlocks(4097, 4096)); |
| 22 |
EXPECT_EQ(2ULL, bytesToBlocks(600, 512)); |
| 23 |
} |
| 24 |
|
| 25 |
TEST(MSFCommonTest, FpmIntervals) { |
| 26 |
SuperBlock SB; |
| 27 |
SB.FreeBlockMapBlock = 1; |
| 28 |
SB.BlockSize = 4096; |
| 29 |
|
| 30 |
MSFLayout L; |
| 31 |
L.SB = &SB; |
| 32 |
|
| 33 |
SB.NumBlocks = 12; |
| 34 |
EXPECT_EQ(1u, getNumFpmIntervals(L, false)); |
| 35 |
SB.NumBlocks = SB.BlockSize; |
| 36 |
EXPECT_EQ(1u, getNumFpmIntervals(L, false)); |
| 37 |
SB.NumBlocks = SB.BlockSize + 1; |
| 38 |
EXPECT_EQ(1u, getNumFpmIntervals(L, false)); |
| 39 |
SB.NumBlocks = SB.BlockSize * 8; |
| 40 |
EXPECT_EQ(1u, getNumFpmIntervals(L, false)); |
| 41 |
SB.NumBlocks = SB.BlockSize * 8 + 1; |
| 42 |
EXPECT_EQ(2u, getNumFpmIntervals(L, false)); |
| 43 |
|
| 44 |
SB.NumBlocks = 12; |
| 45 |
EXPECT_EQ(1u, getNumFpmIntervals(L, true)); |
| 46 |
SB.NumBlocks = SB.BlockSize; |
| 47 |
EXPECT_EQ(1u, getNumFpmIntervals(L, true)); |
| 48 |
SB.NumBlocks = SB.BlockSize * 8; |
| 49 |
EXPECT_EQ(8u, getNumFpmIntervals(L, true)); |
| 50 |
|
| 51 |
// The FPM is going to look like this: |
| 52 |
// | 0 | 1 | 2 | ... | 4096 | 4097 | 4098 | ... | |
| 53 |
// | SB | FPM0 | FPM1 | Data | Data | FPM0 | FPM1 | ... | |
| 54 |
// |
| 55 |
// So when there are up to 4097 blocks (last index 4096), the final blocks |
| 56 |
// are data blocks. When there are 4098 blocks (last index 4097), there is |
| 57 |
// one terminating FPM block, and when there are 4099 blocks, there are two |
| 58 |
// terminating FPM blocks. Make sure all these cases are handled. |
| 59 |
|
| 60 |
// With 4096 or 4097 blocks, the last block is a data block so we only have |
| 61 |
// 1 interval. |
| 62 |
for (uint32_t I : {4096, 4097}) { |
| 63 |
// 1 FPM0 interval |
| 64 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, I, true, 1)); |
| 65 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, I, false, 1)); |
| 66 |
|
| 67 |
// 1 FPM1 interval |
| 68 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, I, true, 2)); |
| 69 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, I, false, 2)); |
| 70 |
} |
| 71 |
|
| 72 |
// With 4098 blocks, the last block belongs to FPM0 so we should have 2 FPM0 |
| 73 |
// intervals. |
| 74 |
EXPECT_EQ(2U, getNumFpmIntervals(4096, 4098, true, 1)); |
| 75 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, false, 1)); |
| 76 |
|
| 77 |
// And 1 FPM1 interval. |
| 78 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, true, 2)); |
| 79 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, false, 2)); |
| 80 |
|
| 81 |
// With 4099 blocks, the last block belongs to FPM1 so we should have 2 |
| 82 |
// FPM0 intervals. |
| 83 |
EXPECT_EQ(2U, getNumFpmIntervals(4096, 4099, true, 1)); |
| 84 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, 4099, false, 1)); |
| 85 |
|
| 86 |
// And 2 FPM1 intervals. |
| 87 |
EXPECT_EQ(2U, getNumFpmIntervals(4096, 4099, true, 2)); |
| 88 |
EXPECT_EQ(1U, getNumFpmIntervals(4096, 4099, false, 2)); |
| 89 |
} |
| 90 |
|
| 91 |
TEST(MSFCommonTest, FpmStreamLayout) { |
| 92 |
SuperBlock SB; |
| 93 |
MSFLayout L; |
| 94 |
L.SB = &SB; |
| 95 |
SB.FreeBlockMapBlock = 1; |
| 96 |
|
| 97 |
// Each FPM block has 4096 bytes for a maximum of 4096*8 allocation states. |
| 98 |
SB.BlockSize = 4096; |
| 99 |
|
| 100 |
// 1. When we're not including unused FPM data, the length of the FPM stream |
| 101 |
// should be only long enough to contain 1 bit for each block. |
| 102 |
|
| 103 |
// 1a. When the PDB has <= 4096*8 blocks, there should only be one FPM block. |
| 104 |
SB.NumBlocks = 8000; |
| 105 |
MSFStreamLayout SL = getFpmStreamLayout(L, false, false); |
| 106 |
EXPECT_EQ(1000u, SL.Length); |
| 107 |
EXPECT_EQ(1u, SL.Blocks.size()); |
| 108 |
EXPECT_EQ(SB.FreeBlockMapBlock, SL.Blocks.front()); |
| 109 |
|
| 110 |
SL = getFpmStreamLayout(L, false, true); |
| 111 |
EXPECT_EQ(1000u, SL.Length); |
| 112 |
EXPECT_EQ(1u, SL.Blocks.size()); |
| 113 |
EXPECT_EQ(3u - SB.FreeBlockMapBlock, SL.Blocks.front()); |
| 114 |
|
| 115 |
// 1b. When the PDB has > 4096*8 blocks, there should be multiple FPM blocks. |
| 116 |
SB.NumBlocks = SB.BlockSize * 8 + 1; |
| 117 |
SL = getFpmStreamLayout(L, false, false); |
| 118 |
EXPECT_EQ(SB.BlockSize + 1, SL.Length); |
| 119 |
EXPECT_EQ(2u, SL.Blocks.size()); |
| 120 |
EXPECT_EQ(SB.FreeBlockMapBlock, SL.Blocks[0]); |
| 121 |
EXPECT_EQ(SB.FreeBlockMapBlock + SB.BlockSize, SL.Blocks[1]); |
| 122 |
|
| 123 |
SL = getFpmStreamLayout(L, false, true); |
| 124 |
EXPECT_EQ(SB.BlockSize + 1, SL.Length); |
| 125 |
EXPECT_EQ(2u, SL.Blocks.size()); |
| 126 |
EXPECT_EQ(3u - SB.FreeBlockMapBlock, SL.Blocks[0]); |
| 127 |
EXPECT_EQ(3u - SB.FreeBlockMapBlock + SB.BlockSize, SL.Blocks[1]); |
| 128 |
|
| 129 |
// 2. When we are including unused FPM data, there should be one FPM block |
| 130 |
// at every BlockSize interval in the file, even if entire FPM blocks are |
| 131 |
// unused. |
| 132 |
SB.NumBlocks = SB.BlockSize * 8 + 3; |
| 133 |
SL = getFpmStreamLayout(L, true, false); |
| 134 |
EXPECT_EQ(SB.BlockSize * 9, SL.Length); |
| 135 |
EXPECT_EQ(9u, SL.Blocks.size()); |
| 136 |
for (int I = 0; I < 9; ++I) |
| 137 |
EXPECT_EQ(I * SB.BlockSize + SB.FreeBlockMapBlock, SL.Blocks[I]); |
| 138 |
} |