unittests/DebugInfo/MSF/MSFCommonTest.cpp

   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 }