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