Home | History | Annotate | Download | only in IPO 
      1 //===- LowerBitSets.cpp - Unit tests for bitset lowering ------------------===//
      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 "llvm/Transforms/IPO/LowerBitSets.h"
     11 #include "gtest/gtest.h"
     12 
     13 using namespace llvm;
     14 
     15 TEST(LowerBitSets, BitSetBuilder) {
     16   struct {
     17     std::vector<uint64_t> Offsets;
     18     std::set<uint64_t> Bits;
     19     uint64_t ByteOffset;
     20     uint64_t BitSize;
     21     unsigned AlignLog2;
     22     bool IsSingleOffset;
     23     bool IsAllOnes;
     24   } BSBTests[] = {
     25       {{}, std::set<uint64_t>{}, 0, 1, 0, false, false},
     26       {{0}, {0}, 0, 1, 0, true, true},
     27       {{4}, {0}, 4, 1, 0, true, true},
     28       {{37}, {0}, 37, 1, 0, true, true},
     29       {{0, 1}, {0, 1}, 0, 2, 0, false, true},
     30       {{0, 4}, {0, 1}, 0, 2, 2, false, true},
     31       {{0, uint64_t(1) << 33}, {0, 1}, 0, 2, 33, false, true},
     32       {{3, 7}, {0, 1}, 3, 2, 2, false, true},
     33       {{0, 1, 7}, {0, 1, 7}, 0, 8, 0, false, false},
     34       {{0, 2, 14}, {0, 1, 7}, 0, 8, 1, false, false},
     35       {{0, 1, 8}, {0, 1, 8}, 0, 9, 0, false, false},
     36       {{0, 2, 16}, {0, 1, 8}, 0, 9, 1, false, false},
     37       {{0, 1, 2, 3, 4, 5, 6, 7},
     38        {0, 1, 2, 3, 4, 5, 6, 7},
     39        0,
     40        8,
     41        0,
     42        false,
     43        true},
     44       {{0, 1, 2, 3, 4, 5, 6, 7, 8},
     45        {0, 1, 2, 3, 4, 5, 6, 7, 8},
     46        0,
     47        9,
     48        0,
     49        false,
     50        true},
     51   };
     52 
     53   for (auto &&T : BSBTests) {
     54     BitSetBuilder BSB;
     55     for (auto Offset : T.Offsets)
     56       BSB.addOffset(Offset);
     57 
     58     BitSetInfo BSI = BSB.build();
     59 
     60     EXPECT_EQ(T.Bits, BSI.Bits);
     61     EXPECT_EQ(T.ByteOffset, BSI.ByteOffset);
     62     EXPECT_EQ(T.BitSize, BSI.BitSize);
     63     EXPECT_EQ(T.AlignLog2, BSI.AlignLog2);
     64     EXPECT_EQ(T.IsSingleOffset, BSI.isSingleOffset());
     65     EXPECT_EQ(T.IsAllOnes, BSI.isAllOnes());
     66 
     67     for (auto Offset : T.Offsets)
     68       EXPECT_TRUE(BSI.containsGlobalOffset(Offset));
     69 
     70     auto I = T.Offsets.begin();
     71     for (uint64_t NonOffset = 0; NonOffset != 256; ++NonOffset) {
     72       if (I != T.Offsets.end() && *I == NonOffset) {
     73         ++I;
     74         continue;
     75       }
     76 
     77       EXPECT_FALSE(BSI.containsGlobalOffset(NonOffset));
     78     }
     79   }
     80 }
     81 
     82 TEST(LowerBitSets, GlobalLayoutBuilder) {
     83   struct {
     84     uint64_t NumObjects;
     85     std::vector<std::set<uint64_t>> Fragments;
     86     std::vector<uint64_t> WantLayout;
     87   } GLBTests[] = {
     88     {0, {}, {}},
     89     {4, {{0, 1}, {2, 3}}, {0, 1, 2, 3}},
     90     {3, {{0, 1}, {1, 2}}, {0, 1, 2}},
     91     {4, {{0, 1}, {1, 2}, {2, 3}}, {0, 1, 2, 3}},
     92     {4, {{0, 1}, {2, 3}, {1, 2}}, {0, 1, 2, 3}},
     93     {6, {{2, 5}, {0, 1, 2, 3, 4, 5}}, {0, 1, 2, 5, 3, 4}},
     94   };
     95 
     96   for (auto &&T : GLBTests) {
     97     GlobalLayoutBuilder GLB(T.NumObjects);
     98     for (auto &&F : T.Fragments)
     99       GLB.addFragment(F);
    100 
    101     std::vector<uint64_t> ComputedLayout;
    102     for (auto &&F : GLB.Fragments)
    103       ComputedLayout.insert(ComputedLayout.end(), F.begin(), F.end());
    104 
    105     EXPECT_EQ(T.WantLayout, ComputedLayout);
    106   }
    107 }
    108 
    109 TEST(LowerBitSets, ByteArrayBuilder) {
    110   struct BABAlloc {
    111     std::set<uint64_t> Bits;
    112     uint64_t BitSize;
    113     uint64_t WantByteOffset;
    114     uint8_t WantMask;
    115   };
    116 
    117   struct {
    118     std::vector<BABAlloc> Allocs;
    119     std::vector<uint8_t> WantBytes;
    120   } BABTests[] = {
    121       {{{{0}, 1, 0, 1}, {{0}, 1, 0, 2}}, {3}},
    122       {{{{0}, 16, 0, 1},
    123         {{1}, 15, 0, 2},
    124         {{2}, 14, 0, 4},
    125         {{3}, 13, 0, 8},
    126         {{4}, 12, 0, 0x10},
    127         {{5}, 11, 0, 0x20},
    128         {{6}, 10, 0, 0x40},
    129         {{7}, 9, 0, 0x80},
    130         {{0}, 7, 9, 0x80},
    131         {{0}, 6, 10, 0x40},
    132         {{0}, 5, 11, 0x20},
    133         {{0}, 4, 12, 0x10},
    134         {{0}, 3, 13, 8},
    135         {{0}, 2, 14, 4},
    136         {{0}, 1, 15, 2}},
    137        {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0, 0x80, 0x40, 0x20, 0x10, 8, 4,
    138         2}},
    139   };
    140 
    141   for (auto &&T : BABTests) {
    142     ByteArrayBuilder BABuilder;
    143 
    144     for (auto &&A : T.Allocs) {
    145       uint64_t GotByteOffset;
    146       uint8_t GotMask;
    147 
    148       BABuilder.allocate(A.Bits, A.BitSize, GotByteOffset, GotMask);
    149       EXPECT_EQ(A.WantByteOffset, GotByteOffset);
    150       EXPECT_EQ(A.WantMask, GotMask);
    151     }
    152 
    153     EXPECT_EQ(T.WantBytes, BABuilder.Bytes);
    154   }
    155 }
    156