1 //===- BitstreamReaderTest.cpp - Tests for BitstreamReader ----------------===//
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/Bitstream/BitstreamReader.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/Bitstream/BitstreamWriter.h"
12 #include "gtest/gtest.h"
13 
14 using namespace llvm;
15 
16 namespace {
17 
TEST(BitstreamReaderTest,AtEndOfStream)18 TEST(BitstreamReaderTest, AtEndOfStream) {
19   uint8_t Bytes[4] = {
20     0x00, 0x01, 0x02, 0x03
21   };
22   BitstreamCursor Cursor(Bytes);
23 
24   EXPECT_FALSE(Cursor.AtEndOfStream());
25   Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(8);
26   EXPECT_TRUE((bool)MaybeRead);
27   EXPECT_FALSE(Cursor.AtEndOfStream());
28   MaybeRead = Cursor.Read(24);
29   EXPECT_TRUE((bool)MaybeRead);
30   EXPECT_TRUE(Cursor.AtEndOfStream());
31 
32   EXPECT_FALSE(Cursor.JumpToBit(0));
33   EXPECT_FALSE(Cursor.AtEndOfStream());
34 
35   EXPECT_FALSE(Cursor.JumpToBit(32));
36   EXPECT_TRUE(Cursor.AtEndOfStream());
37 }
38 
TEST(BitstreamReaderTest,AtEndOfStreamJump)39 TEST(BitstreamReaderTest, AtEndOfStreamJump) {
40   uint8_t Bytes[4] = {
41     0x00, 0x01, 0x02, 0x03
42   };
43   BitstreamCursor Cursor(Bytes);
44 
45   EXPECT_FALSE(Cursor.JumpToBit(32));
46   EXPECT_TRUE(Cursor.AtEndOfStream());
47 }
48 
TEST(BitstreamReaderTest,AtEndOfStreamEmpty)49 TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
50   BitstreamCursor Cursor(ArrayRef<uint8_t>{});
51 
52   EXPECT_TRUE(Cursor.AtEndOfStream());
53 }
54 
TEST(BitstreamReaderTest,getCurrentByteNo)55 TEST(BitstreamReaderTest, getCurrentByteNo) {
56   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03};
57   SimpleBitstreamCursor Cursor(Bytes);
58 
59   for (unsigned I = 0, E = 32; I != E; ++I) {
60     EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
61     Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(1);
62     EXPECT_TRUE((bool)MaybeRead);
63   }
64   EXPECT_EQ(4u, Cursor.getCurrentByteNo());
65 }
66 
TEST(BitstreamReaderTest,getPointerToByte)67 TEST(BitstreamReaderTest, getPointerToByte) {
68   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
69   SimpleBitstreamCursor Cursor(Bytes);
70 
71   for (unsigned I = 0, E = 8; I != E; ++I) {
72     EXPECT_EQ(Bytes + I, Cursor.getPointerToByte(I, 1));
73   }
74 }
75 
TEST(BitstreamReaderTest,getPointerToBit)76 TEST(BitstreamReaderTest, getPointerToBit) {
77   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
78   SimpleBitstreamCursor Cursor(Bytes);
79 
80   for (unsigned I = 0, E = 8; I != E; ++I) {
81     EXPECT_EQ(Bytes + I, Cursor.getPointerToBit(I * 8, 1));
82   }
83 }
84 
TEST(BitstreamReaderTest,readRecordWithBlobWhileStreaming)85 TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) {
86   SmallVector<uint8_t, 1> BlobData;
87   for (unsigned I = 0, E = 1024; I != E; ++I)
88     BlobData.push_back(I);
89 
90   // Try a bunch of different sizes.
91   const unsigned Magic = 0x12345678;
92   const unsigned BlockID = bitc::FIRST_APPLICATION_BLOCKID;
93   const unsigned RecordID = 1;
94   for (unsigned I = 0, BlobSize = 0, E = BlobData.size(); BlobSize < E;
95        BlobSize += ++I) {
96     StringRef BlobIn((const char *)BlobData.begin(), BlobSize);
97 
98     // Write the bitcode.
99     SmallVector<char, 1> Buffer;
100     unsigned AbbrevID;
101     {
102       BitstreamWriter Stream(Buffer);
103       Stream.Emit(Magic, 32);
104       Stream.EnterSubblock(BlockID, 3);
105 
106       auto Abbrev = std::make_shared<BitCodeAbbrev>();
107       Abbrev->Add(BitCodeAbbrevOp(RecordID));
108       Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
109       AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
110       unsigned Record[] = {RecordID};
111       Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn);
112 
113       Stream.ExitBlock();
114     }
115 
116     // Stream the buffer into the reader.
117     BitstreamCursor Stream(
118         ArrayRef<uint8_t>((const uint8_t *)Buffer.begin(), Buffer.size()));
119 
120     // Header.  Included in test so that we can run llvm-bcanalyzer to debug
121     // when there are problems.
122     Expected<SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(32);
123     ASSERT_TRUE((bool)MaybeRead);
124     ASSERT_EQ(Magic, MaybeRead.get());
125 
126     // Block.
127     Expected<BitstreamEntry> MaybeEntry =
128         Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
129     ASSERT_TRUE((bool)MaybeEntry);
130     BitstreamEntry Entry = MaybeEntry.get();
131     ASSERT_EQ(BitstreamEntry::SubBlock, Entry.Kind);
132     ASSERT_EQ(BlockID, Entry.ID);
133     ASSERT_FALSE(Stream.EnterSubBlock(BlockID));
134 
135     // Abbreviation.
136     MaybeEntry = Stream.advance();
137     ASSERT_TRUE((bool)MaybeEntry);
138     Entry = MaybeEntry.get();
139     ASSERT_EQ(BitstreamEntry::Record, Entry.Kind);
140     ASSERT_EQ(AbbrevID, Entry.ID);
141 
142     // Record.
143     StringRef BlobOut;
144     SmallVector<uint64_t, 1> Record;
145     Expected<unsigned> MaybeRecord =
146         Stream.readRecord(Entry.ID, Record, &BlobOut);
147     ASSERT_TRUE((bool)MaybeRecord);
148     ASSERT_EQ(RecordID, MaybeRecord.get());
149     EXPECT_TRUE(Record.empty());
150     EXPECT_EQ(BlobIn, BlobOut);
151   }
152 }
153 
TEST(BitstreamReaderTest,shortRead)154 TEST(BitstreamReaderTest, shortRead) {
155   uint8_t Bytes[] = {8, 7, 6, 5, 4, 3, 2, 1};
156   for (unsigned I = 1; I != 8; ++I) {
157     SimpleBitstreamCursor Cursor(ArrayRef<uint8_t>(Bytes, I));
158     Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(8);
159     ASSERT_TRUE((bool)MaybeRead);
160     EXPECT_EQ(8ull, MaybeRead.get());
161   }
162 }
163 
164 static_assert(is_trivially_copyable<BitCodeAbbrevOp>::value,
165               "trivially copyable");
166 
167 } // end anonymous namespace
168