File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include/llvm/Bitstream/BitstreamReader.h |
Warning: | line 217, column 39 The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- BitstreamReader.cpp - BitstreamReader implementation ---------------===// | |||
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/StringRef.h" | |||
11 | #include <cassert> | |||
12 | #include <string> | |||
13 | ||||
14 | using namespace llvm; | |||
15 | ||||
16 | //===----------------------------------------------------------------------===// | |||
17 | // BitstreamCursor implementation | |||
18 | //===----------------------------------------------------------------------===// | |||
19 | // | |||
20 | static Error error(const char *Message) { | |||
21 | return createStringError(std::errc::illegal_byte_sequence, Message); | |||
22 | } | |||
23 | ||||
24 | /// Having read the ENTER_SUBBLOCK abbrevid, enter the block. | |||
25 | Error BitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) { | |||
26 | // Save the current block's state on BlockScope. | |||
27 | BlockScope.push_back(Block(CurCodeSize)); | |||
28 | BlockScope.back().PrevAbbrevs.swap(CurAbbrevs); | |||
29 | ||||
30 | // Add the abbrevs specific to this block to the CurAbbrevs list. | |||
31 | if (BlockInfo) { | |||
32 | if (const BitstreamBlockInfo::BlockInfo *Info = | |||
33 | BlockInfo->getBlockInfo(BlockID)) { | |||
34 | llvm::append_range(CurAbbrevs, Info->Abbrevs); | |||
35 | } | |||
36 | } | |||
37 | ||||
38 | // Get the codesize of this block. | |||
39 | Expected<uint32_t> MaybeVBR = ReadVBR(bitc::CodeLenWidth); | |||
40 | if (!MaybeVBR) | |||
41 | return MaybeVBR.takeError(); | |||
42 | CurCodeSize = MaybeVBR.get(); | |||
43 | ||||
44 | if (CurCodeSize > MaxChunkSize) | |||
45 | return llvm::createStringError( | |||
46 | std::errc::illegal_byte_sequence, | |||
47 | "can't read more than %zu at a time, trying to read %u", +MaxChunkSize, | |||
48 | CurCodeSize); | |||
49 | ||||
50 | SkipToFourByteBoundary(); | |||
51 | Expected<word_t> MaybeNum = Read(bitc::BlockSizeWidth); | |||
52 | if (!MaybeNum) | |||
53 | return MaybeNum.takeError(); | |||
54 | word_t NumWords = MaybeNum.get(); | |||
55 | if (NumWordsP) | |||
56 | *NumWordsP = NumWords; | |||
57 | ||||
58 | if (CurCodeSize == 0) | |||
59 | return llvm::createStringError( | |||
60 | std::errc::illegal_byte_sequence, | |||
61 | "can't enter sub-block: current code size is 0"); | |||
62 | if (AtEndOfStream()) | |||
63 | return llvm::createStringError( | |||
64 | std::errc::illegal_byte_sequence, | |||
65 | "can't enter sub block: already at end of stream"); | |||
66 | ||||
67 | return Error::success(); | |||
68 | } | |||
69 | ||||
70 | static Expected<uint64_t> readAbbreviatedField(BitstreamCursor &Cursor, | |||
71 | const BitCodeAbbrevOp &Op) { | |||
72 | assert(!Op.isLiteral() && "Not to be used with literals!")(static_cast <bool> (!Op.isLiteral() && "Not to be used with literals!" ) ? void (0) : __assert_fail ("!Op.isLiteral() && \"Not to be used with literals!\"" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 72, __extension__ __PRETTY_FUNCTION__)); | |||
73 | ||||
74 | // Decode the value as we are commanded. | |||
75 | switch (Op.getEncoding()) { | |||
76 | case BitCodeAbbrevOp::Array: | |||
77 | case BitCodeAbbrevOp::Blob: | |||
78 | llvm_unreachable("Should not reach here")::llvm::llvm_unreachable_internal("Should not reach here", "llvm/lib/Bitstream/Reader/BitstreamReader.cpp" , 78); | |||
79 | case BitCodeAbbrevOp::Fixed: | |||
80 | assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize)(static_cast <bool> ((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize) ? void (0) : __assert_fail ("(unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 80, __extension__ __PRETTY_FUNCTION__)); | |||
81 | return Cursor.Read((unsigned)Op.getEncodingData()); | |||
82 | case BitCodeAbbrevOp::VBR: | |||
83 | assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize)(static_cast <bool> ((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize) ? void (0) : __assert_fail ("(unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 83, __extension__ __PRETTY_FUNCTION__)); | |||
84 | return Cursor.ReadVBR64((unsigned)Op.getEncodingData()); | |||
85 | case BitCodeAbbrevOp::Char6: | |||
86 | if (Expected<unsigned> Res = Cursor.Read(6)) | |||
87 | return BitCodeAbbrevOp::DecodeChar6(Res.get()); | |||
88 | else | |||
89 | return Res.takeError(); | |||
90 | } | |||
91 | llvm_unreachable("invalid abbreviation encoding")::llvm::llvm_unreachable_internal("invalid abbreviation encoding" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 91); | |||
92 | } | |||
93 | ||||
94 | /// skipRecord - Read the current record and discard it. | |||
95 | Expected<unsigned> BitstreamCursor::skipRecord(unsigned AbbrevID) { | |||
96 | // Skip unabbreviated records by reading past their entries. | |||
97 | if (AbbrevID == bitc::UNABBREV_RECORD) { | |||
98 | Expected<uint32_t> MaybeCode = ReadVBR(6); | |||
99 | if (!MaybeCode) | |||
100 | return MaybeCode.takeError(); | |||
101 | unsigned Code = MaybeCode.get(); | |||
102 | Expected<uint32_t> MaybeVBR = ReadVBR(6); | |||
103 | if (!MaybeVBR) | |||
104 | return MaybeVBR.takeError(); | |||
105 | unsigned NumElts = MaybeVBR.get(); | |||
106 | for (unsigned i = 0; i != NumElts; ++i) | |||
107 | if (Expected<uint64_t> Res = ReadVBR64(6)) | |||
108 | ; // Skip! | |||
109 | else | |||
110 | return Res.takeError(); | |||
111 | return Code; | |||
112 | } | |||
113 | ||||
114 | Expected<const BitCodeAbbrev *> MaybeAbbv = getAbbrev(AbbrevID); | |||
115 | if (!MaybeAbbv) | |||
116 | return MaybeAbbv.takeError(); | |||
117 | ||||
118 | const BitCodeAbbrev *Abbv = MaybeAbbv.get(); | |||
119 | const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0); | |||
120 | unsigned Code; | |||
121 | if (CodeOp.isLiteral()) | |||
122 | Code = CodeOp.getLiteralValue(); | |||
123 | else { | |||
124 | if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array || | |||
125 | CodeOp.getEncoding() == BitCodeAbbrevOp::Blob) | |||
126 | return llvm::createStringError( | |||
127 | std::errc::illegal_byte_sequence, | |||
128 | "Abbreviation starts with an Array or a Blob"); | |||
129 | Expected<uint64_t> MaybeCode = readAbbreviatedField(*this, CodeOp); | |||
130 | if (!MaybeCode) | |||
131 | return MaybeCode.takeError(); | |||
132 | Code = MaybeCode.get(); | |||
133 | } | |||
134 | ||||
135 | for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) { | |||
136 | const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); | |||
137 | if (Op.isLiteral()) | |||
138 | continue; | |||
139 | ||||
140 | if (Op.getEncoding() != BitCodeAbbrevOp::Array && | |||
141 | Op.getEncoding() != BitCodeAbbrevOp::Blob) { | |||
142 | if (Expected<uint64_t> MaybeField = readAbbreviatedField(*this, Op)) | |||
143 | continue; | |||
144 | else | |||
145 | return MaybeField.takeError(); | |||
146 | } | |||
147 | ||||
148 | if (Op.getEncoding() == BitCodeAbbrevOp::Array) { | |||
149 | // Array case. Read the number of elements as a vbr6. | |||
150 | Expected<uint32_t> MaybeNum = ReadVBR(6); | |||
151 | if (!MaybeNum) | |||
152 | return MaybeNum.takeError(); | |||
153 | unsigned NumElts = MaybeNum.get(); | |||
154 | ||||
155 | // Get the element encoding. | |||
156 | assert(i+2 == e && "array op not second to last?")(static_cast <bool> (i+2 == e && "array op not second to last?" ) ? void (0) : __assert_fail ("i+2 == e && \"array op not second to last?\"" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 156, __extension__ __PRETTY_FUNCTION__)); | |||
157 | const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); | |||
158 | ||||
159 | // Read all the elements. | |||
160 | // Decode the value as we are commanded. | |||
161 | switch (EltEnc.getEncoding()) { | |||
162 | default: | |||
163 | return error("Array element type can't be an Array or a Blob"); | |||
164 | case BitCodeAbbrevOp::Fixed: | |||
165 | assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize)(static_cast <bool> ((unsigned)EltEnc.getEncodingData() <= MaxChunkSize) ? void (0) : __assert_fail ("(unsigned)EltEnc.getEncodingData() <= MaxChunkSize" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 165, __extension__ __PRETTY_FUNCTION__)); | |||
166 | if (Error Err = | |||
167 | JumpToBit(GetCurrentBitNo() + static_cast<uint64_t>(NumElts) * | |||
168 | EltEnc.getEncodingData())) | |||
169 | return std::move(Err); | |||
170 | break; | |||
171 | case BitCodeAbbrevOp::VBR: | |||
172 | assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize)(static_cast <bool> ((unsigned)EltEnc.getEncodingData() <= MaxChunkSize) ? void (0) : __assert_fail ("(unsigned)EltEnc.getEncodingData() <= MaxChunkSize" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 172, __extension__ __PRETTY_FUNCTION__)); | |||
173 | for (; NumElts; --NumElts) | |||
174 | if (Expected<uint64_t> Res = | |||
175 | ReadVBR64((unsigned)EltEnc.getEncodingData())) | |||
176 | ; // Skip! | |||
177 | else | |||
178 | return Res.takeError(); | |||
179 | break; | |||
180 | case BitCodeAbbrevOp::Char6: | |||
181 | if (Error Err = JumpToBit(GetCurrentBitNo() + NumElts * 6)) | |||
182 | return std::move(Err); | |||
183 | break; | |||
184 | } | |||
185 | continue; | |||
186 | } | |||
187 | ||||
188 | assert(Op.getEncoding() == BitCodeAbbrevOp::Blob)(static_cast <bool> (Op.getEncoding() == BitCodeAbbrevOp ::Blob) ? void (0) : __assert_fail ("Op.getEncoding() == BitCodeAbbrevOp::Blob" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 188, __extension__ __PRETTY_FUNCTION__)); | |||
189 | // Blob case. Read the number of bytes as a vbr6. | |||
190 | Expected<uint32_t> MaybeNum = ReadVBR(6); | |||
191 | if (!MaybeNum) | |||
192 | return MaybeNum.takeError(); | |||
193 | unsigned NumElts = MaybeNum.get(); | |||
194 | SkipToFourByteBoundary(); // 32-bit alignment | |||
195 | ||||
196 | // Figure out where the end of this blob will be including tail padding. | |||
197 | const size_t NewEnd = GetCurrentBitNo() + alignTo(NumElts, 4) * 8; | |||
198 | ||||
199 | // If this would read off the end of the bitcode file, just set the | |||
200 | // record to empty and return. | |||
201 | if (!canSkipToPos(NewEnd/8)) { | |||
202 | skipToEnd(); | |||
203 | break; | |||
204 | } | |||
205 | ||||
206 | // Skip over the blob. | |||
207 | if (Error Err = JumpToBit(NewEnd)) | |||
208 | return std::move(Err); | |||
209 | } | |||
210 | return Code; | |||
211 | } | |||
212 | ||||
213 | Expected<unsigned> BitstreamCursor::readRecord(unsigned AbbrevID, | |||
214 | SmallVectorImpl<uint64_t> &Vals, | |||
215 | StringRef *Blob) { | |||
216 | if (AbbrevID == bitc::UNABBREV_RECORD) { | |||
217 | Expected<uint32_t> MaybeCode = ReadVBR(6); | |||
218 | if (!MaybeCode) | |||
219 | return MaybeCode.takeError(); | |||
220 | uint32_t Code = MaybeCode.get(); | |||
221 | Expected<uint32_t> MaybeNumElts = ReadVBR(6); | |||
222 | if (!MaybeNumElts) | |||
223 | return error( | |||
224 | ("Failed to read size: " + toString(MaybeNumElts.takeError())) | |||
225 | .c_str()); | |||
226 | uint32_t NumElts = MaybeNumElts.get(); | |||
227 | if (!isSizePlausible(NumElts)) | |||
228 | return error("Size is not plausible"); | |||
229 | Vals.reserve(Vals.size() + NumElts); | |||
230 | ||||
231 | for (unsigned i = 0; i != NumElts; ++i) | |||
232 | if (Expected<uint64_t> MaybeVal = ReadVBR64(6)) | |||
233 | Vals.push_back(MaybeVal.get()); | |||
234 | else | |||
235 | return MaybeVal.takeError(); | |||
236 | return Code; | |||
237 | } | |||
238 | ||||
239 | Expected<const BitCodeAbbrev *> MaybeAbbv = getAbbrev(AbbrevID); | |||
240 | if (!MaybeAbbv) | |||
241 | return MaybeAbbv.takeError(); | |||
242 | const BitCodeAbbrev *Abbv = MaybeAbbv.get(); | |||
243 | ||||
244 | // Read the record code first. | |||
245 | assert(Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?")(static_cast <bool> (Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?") ? void (0) : __assert_fail ("Abbv->getNumOperandInfos() != 0 && \"no record code in abbreviation?\"" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 245, __extension__ __PRETTY_FUNCTION__)); | |||
246 | const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0); | |||
247 | unsigned Code; | |||
248 | if (CodeOp.isLiteral()) | |||
249 | Code = CodeOp.getLiteralValue(); | |||
250 | else { | |||
251 | if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array || | |||
252 | CodeOp.getEncoding() == BitCodeAbbrevOp::Blob) | |||
253 | return error("Abbreviation starts with an Array or a Blob"); | |||
254 | if (Expected<uint64_t> MaybeCode = readAbbreviatedField(*this, CodeOp)) | |||
255 | Code = MaybeCode.get(); | |||
256 | else | |||
257 | return MaybeCode.takeError(); | |||
258 | } | |||
259 | ||||
260 | for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) { | |||
261 | const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); | |||
262 | if (Op.isLiteral()) { | |||
263 | Vals.push_back(Op.getLiteralValue()); | |||
264 | continue; | |||
265 | } | |||
266 | ||||
267 | if (Op.getEncoding() != BitCodeAbbrevOp::Array && | |||
268 | Op.getEncoding() != BitCodeAbbrevOp::Blob) { | |||
269 | if (Expected<uint64_t> MaybeVal = readAbbreviatedField(*this, Op)) | |||
270 | Vals.push_back(MaybeVal.get()); | |||
271 | else | |||
272 | return MaybeVal.takeError(); | |||
273 | continue; | |||
274 | } | |||
275 | ||||
276 | if (Op.getEncoding() == BitCodeAbbrevOp::Array) { | |||
277 | // Array case. Read the number of elements as a vbr6. | |||
278 | Expected<uint32_t> MaybeNumElts = ReadVBR(6); | |||
279 | if (!MaybeNumElts) | |||
280 | return error( | |||
281 | ("Failed to read size: " + toString(MaybeNumElts.takeError())) | |||
282 | .c_str()); | |||
283 | uint32_t NumElts = MaybeNumElts.get(); | |||
284 | if (!isSizePlausible(NumElts)) | |||
285 | return error("Size is not plausible"); | |||
286 | Vals.reserve(Vals.size() + NumElts); | |||
287 | ||||
288 | // Get the element encoding. | |||
289 | if (i + 2 != e) | |||
290 | return error("Array op not second to last"); | |||
291 | const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); | |||
292 | if (!EltEnc.isEncoding()) | |||
293 | return error( | |||
294 | "Array element type has to be an encoding of a type"); | |||
295 | ||||
296 | // Read all the elements. | |||
297 | switch (EltEnc.getEncoding()) { | |||
298 | default: | |||
299 | return error("Array element type can't be an Array or a Blob"); | |||
300 | case BitCodeAbbrevOp::Fixed: | |||
301 | for (; NumElts; --NumElts) | |||
302 | if (Expected<SimpleBitstreamCursor::word_t> MaybeVal = | |||
303 | Read((unsigned)EltEnc.getEncodingData())) | |||
304 | Vals.push_back(MaybeVal.get()); | |||
305 | else | |||
306 | return MaybeVal.takeError(); | |||
307 | break; | |||
308 | case BitCodeAbbrevOp::VBR: | |||
309 | for (; NumElts; --NumElts) | |||
310 | if (Expected<uint64_t> MaybeVal = | |||
311 | ReadVBR64((unsigned)EltEnc.getEncodingData())) | |||
312 | Vals.push_back(MaybeVal.get()); | |||
313 | else | |||
314 | return MaybeVal.takeError(); | |||
315 | break; | |||
316 | case BitCodeAbbrevOp::Char6: | |||
317 | for (; NumElts; --NumElts) | |||
318 | if (Expected<SimpleBitstreamCursor::word_t> MaybeVal = Read(6)) | |||
319 | Vals.push_back(BitCodeAbbrevOp::DecodeChar6(MaybeVal.get())); | |||
320 | else | |||
321 | return MaybeVal.takeError(); | |||
322 | } | |||
323 | continue; | |||
324 | } | |||
325 | ||||
326 | assert(Op.getEncoding() == BitCodeAbbrevOp::Blob)(static_cast <bool> (Op.getEncoding() == BitCodeAbbrevOp ::Blob) ? void (0) : __assert_fail ("Op.getEncoding() == BitCodeAbbrevOp::Blob" , "llvm/lib/Bitstream/Reader/BitstreamReader.cpp", 326, __extension__ __PRETTY_FUNCTION__)); | |||
327 | // Blob case. Read the number of bytes as a vbr6. | |||
328 | Expected<uint32_t> MaybeNumElts = ReadVBR(6); | |||
329 | if (!MaybeNumElts) | |||
330 | return MaybeNumElts.takeError(); | |||
331 | uint32_t NumElts = MaybeNumElts.get(); | |||
332 | SkipToFourByteBoundary(); // 32-bit alignment | |||
333 | ||||
334 | // Figure out where the end of this blob will be including tail padding. | |||
335 | size_t CurBitPos = GetCurrentBitNo(); | |||
336 | const size_t NewEnd = CurBitPos + alignTo(NumElts, 4) * 8; | |||
337 | ||||
338 | // Make sure the bitstream is large enough to contain the blob. | |||
339 | if (!canSkipToPos(NewEnd/8)) | |||
340 | return error("Blob ends too soon"); | |||
341 | ||||
342 | // Otherwise, inform the streamer that we need these bytes in memory. Skip | |||
343 | // over tail padding first, in case jumping to NewEnd invalidates the Blob | |||
344 | // pointer. | |||
345 | if (Error Err = JumpToBit(NewEnd)) | |||
346 | return std::move(Err); | |||
347 | const char *Ptr = (const char *)getPointerToBit(CurBitPos, NumElts); | |||
348 | ||||
349 | // If we can return a reference to the data, do so to avoid copying it. | |||
350 | if (Blob) { | |||
351 | *Blob = StringRef(Ptr, NumElts); | |||
352 | } else { | |||
353 | // Otherwise, unpack into Vals with zero extension. | |||
354 | auto *UPtr = reinterpret_cast<const unsigned char *>(Ptr); | |||
355 | Vals.append(UPtr, UPtr + NumElts); | |||
356 | } | |||
357 | } | |||
358 | ||||
359 | return Code; | |||
360 | } | |||
361 | ||||
362 | Error BitstreamCursor::ReadAbbrevRecord() { | |||
363 | auto Abbv = std::make_shared<BitCodeAbbrev>(); | |||
364 | Expected<uint32_t> MaybeNumOpInfo = ReadVBR(5); | |||
365 | if (!MaybeNumOpInfo) | |||
366 | return MaybeNumOpInfo.takeError(); | |||
367 | unsigned NumOpInfo = MaybeNumOpInfo.get(); | |||
368 | for (unsigned i = 0; i != NumOpInfo; ++i) { | |||
369 | Expected<word_t> MaybeIsLiteral = Read(1); | |||
370 | if (!MaybeIsLiteral) | |||
371 | return MaybeIsLiteral.takeError(); | |||
372 | bool IsLiteral = MaybeIsLiteral.get(); | |||
373 | if (IsLiteral) { | |||
374 | Expected<uint64_t> MaybeOp = ReadVBR64(8); | |||
375 | if (!MaybeOp) | |||
376 | return MaybeOp.takeError(); | |||
377 | Abbv->Add(BitCodeAbbrevOp(MaybeOp.get())); | |||
378 | continue; | |||
379 | } | |||
380 | ||||
381 | Expected<word_t> MaybeEncoding = Read(3); | |||
382 | if (!MaybeEncoding) | |||
383 | return MaybeEncoding.takeError(); | |||
384 | if (!BitCodeAbbrevOp::isValidEncoding(MaybeEncoding.get())) | |||
385 | return error("Invalid encoding"); | |||
386 | ||||
387 | BitCodeAbbrevOp::Encoding E = | |||
388 | (BitCodeAbbrevOp::Encoding)MaybeEncoding.get(); | |||
389 | if (BitCodeAbbrevOp::hasEncodingData(E)) { | |||
390 | Expected<uint64_t> MaybeData = ReadVBR64(5); | |||
391 | if (!MaybeData) | |||
392 | return MaybeData.takeError(); | |||
393 | uint64_t Data = MaybeData.get(); | |||
394 | ||||
395 | // As a special case, handle fixed(0) (i.e., a fixed field with zero bits) | |||
396 | // and vbr(0) as a literal zero. This is decoded the same way, and avoids | |||
397 | // a slow path in Read() to have to handle reading zero bits. | |||
398 | if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) && | |||
399 | Data == 0) { | |||
400 | Abbv->Add(BitCodeAbbrevOp(0)); | |||
401 | continue; | |||
402 | } | |||
403 | ||||
404 | if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) && | |||
405 | Data > MaxChunkSize) | |||
406 | return error("Fixed or VBR abbrev record with size > MaxChunkData"); | |||
407 | ||||
408 | Abbv->Add(BitCodeAbbrevOp(E, Data)); | |||
409 | } else | |||
410 | Abbv->Add(BitCodeAbbrevOp(E)); | |||
411 | } | |||
412 | ||||
413 | if (Abbv->getNumOperandInfos() == 0) | |||
414 | return error("Abbrev record with no operands"); | |||
415 | CurAbbrevs.push_back(std::move(Abbv)); | |||
416 | ||||
417 | return Error::success(); | |||
418 | } | |||
419 | ||||
420 | Expected<Optional<BitstreamBlockInfo>> | |||
421 | BitstreamCursor::ReadBlockInfoBlock(bool ReadBlockInfoNames) { | |||
422 | if (llvm::Error Err = EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) | |||
| ||||
423 | return std::move(Err); | |||
424 | ||||
425 | BitstreamBlockInfo NewBlockInfo; | |||
426 | ||||
427 | SmallVector<uint64_t, 64> Record; | |||
428 | BitstreamBlockInfo::BlockInfo *CurBlockInfo = nullptr; | |||
429 | ||||
430 | // Read all the records for this module. | |||
431 | while (true) { | |||
432 | Expected<BitstreamEntry> MaybeEntry = | |||
433 | advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs); | |||
434 | if (!MaybeEntry) | |||
435 | return MaybeEntry.takeError(); | |||
436 | BitstreamEntry Entry = MaybeEntry.get(); | |||
437 | ||||
438 | switch (Entry.Kind) { | |||
439 | case llvm::BitstreamEntry::SubBlock: // Handled for us already. | |||
440 | case llvm::BitstreamEntry::Error: | |||
441 | return None; | |||
442 | case llvm::BitstreamEntry::EndBlock: | |||
443 | return std::move(NewBlockInfo); | |||
444 | case llvm::BitstreamEntry::Record: | |||
445 | // The interesting case. | |||
446 | break; | |||
447 | } | |||
448 | ||||
449 | // Read abbrev records, associate them with CurBID. | |||
450 | if (Entry.ID == bitc::DEFINE_ABBREV) { | |||
451 | if (!CurBlockInfo) return None; | |||
452 | if (Error Err = ReadAbbrevRecord()) | |||
453 | return std::move(Err); | |||
454 | ||||
455 | // ReadAbbrevRecord installs the abbrev in CurAbbrevs. Move it to the | |||
456 | // appropriate BlockInfo. | |||
457 | CurBlockInfo->Abbrevs.push_back(std::move(CurAbbrevs.back())); | |||
458 | CurAbbrevs.pop_back(); | |||
459 | continue; | |||
460 | } | |||
461 | ||||
462 | // Read a record. | |||
463 | Record.clear(); | |||
464 | Expected<unsigned> MaybeBlockInfo = readRecord(Entry.ID, Record); | |||
465 | if (!MaybeBlockInfo) | |||
466 | return MaybeBlockInfo.takeError(); | |||
467 | switch (MaybeBlockInfo.get()) { | |||
468 | default: | |||
469 | break; // Default behavior, ignore unknown content. | |||
470 | case bitc::BLOCKINFO_CODE_SETBID: | |||
471 | if (Record.size() < 1) | |||
472 | return None; | |||
473 | CurBlockInfo = &NewBlockInfo.getOrCreateBlockInfo((unsigned)Record[0]); | |||
474 | break; | |||
475 | case bitc::BLOCKINFO_CODE_BLOCKNAME: { | |||
476 | if (!CurBlockInfo) | |||
477 | return None; | |||
478 | if (!ReadBlockInfoNames) | |||
479 | break; // Ignore name. | |||
480 | CurBlockInfo->Name = std::string(Record.begin(), Record.end()); | |||
481 | break; | |||
482 | } | |||
483 | case bitc::BLOCKINFO_CODE_SETRECORDNAME: { | |||
484 | if (!CurBlockInfo) return None; | |||
485 | if (!ReadBlockInfoNames) | |||
486 | break; // Ignore name. | |||
487 | CurBlockInfo->RecordNames.emplace_back( | |||
488 | (unsigned)Record[0], std::string(Record.begin() + 1, Record.end())); | |||
489 | break; | |||
490 | } | |||
491 | } | |||
492 | } | |||
493 | } |
1 | //===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===// | ||||
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 | // This header defines the BitstreamReader class. This class can be used to | ||||
10 | // read an arbitrary bitstream, regardless of its contents. | ||||
11 | // | ||||
12 | //===----------------------------------------------------------------------===// | ||||
13 | |||||
14 | #ifndef LLVM_BITSTREAM_BITSTREAMREADER_H | ||||
15 | #define LLVM_BITSTREAM_BITSTREAMREADER_H | ||||
16 | |||||
17 | #include "llvm/ADT/ArrayRef.h" | ||||
18 | #include "llvm/ADT/SmallVector.h" | ||||
19 | #include "llvm/Bitstream/BitCodes.h" | ||||
20 | #include "llvm/Support/Endian.h" | ||||
21 | #include "llvm/Support/Error.h" | ||||
22 | #include "llvm/Support/MemoryBufferRef.h" | ||||
23 | #include <algorithm> | ||||
24 | #include <cassert> | ||||
25 | #include <climits> | ||||
26 | #include <cstddef> | ||||
27 | #include <cstdint> | ||||
28 | #include <memory> | ||||
29 | #include <string> | ||||
30 | #include <utility> | ||||
31 | #include <vector> | ||||
32 | |||||
33 | namespace llvm { | ||||
34 | |||||
35 | /// This class maintains the abbreviations read from a block info block. | ||||
36 | class BitstreamBlockInfo { | ||||
37 | public: | ||||
38 | /// This contains information emitted to BLOCKINFO_BLOCK blocks. These | ||||
39 | /// describe abbreviations that all blocks of the specified ID inherit. | ||||
40 | struct BlockInfo { | ||||
41 | unsigned BlockID = 0; | ||||
42 | std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs; | ||||
43 | std::string Name; | ||||
44 | std::vector<std::pair<unsigned, std::string>> RecordNames; | ||||
45 | }; | ||||
46 | |||||
47 | private: | ||||
48 | std::vector<BlockInfo> BlockInfoRecords; | ||||
49 | |||||
50 | public: | ||||
51 | /// If there is block info for the specified ID, return it, otherwise return | ||||
52 | /// null. | ||||
53 | const BlockInfo *getBlockInfo(unsigned BlockID) const { | ||||
54 | // Common case, the most recent entry matches BlockID. | ||||
55 | if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID) | ||||
56 | return &BlockInfoRecords.back(); | ||||
57 | |||||
58 | for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size()); | ||||
59 | i != e; ++i) | ||||
60 | if (BlockInfoRecords[i].BlockID == BlockID) | ||||
61 | return &BlockInfoRecords[i]; | ||||
62 | return nullptr; | ||||
63 | } | ||||
64 | |||||
65 | BlockInfo &getOrCreateBlockInfo(unsigned BlockID) { | ||||
66 | if (const BlockInfo *BI = getBlockInfo(BlockID)) | ||||
67 | return *const_cast<BlockInfo*>(BI); | ||||
68 | |||||
69 | // Otherwise, add a new record. | ||||
70 | BlockInfoRecords.emplace_back(); | ||||
71 | BlockInfoRecords.back().BlockID = BlockID; | ||||
72 | return BlockInfoRecords.back(); | ||||
73 | } | ||||
74 | }; | ||||
75 | |||||
76 | /// This represents a position within a bitstream. There may be multiple | ||||
77 | /// independent cursors reading within one bitstream, each maintaining their | ||||
78 | /// own local state. | ||||
79 | class SimpleBitstreamCursor { | ||||
80 | ArrayRef<uint8_t> BitcodeBytes; | ||||
81 | size_t NextChar = 0; | ||||
82 | |||||
83 | public: | ||||
84 | /// This is the current data we have pulled from the stream but have not | ||||
85 | /// returned to the client. This is specifically and intentionally defined to | ||||
86 | /// follow the word size of the host machine for efficiency. We use word_t in | ||||
87 | /// places that are aware of this to make it perfectly explicit what is going | ||||
88 | /// on. | ||||
89 | using word_t = size_t; | ||||
90 | |||||
91 | private: | ||||
92 | word_t CurWord = 0; | ||||
93 | |||||
94 | /// This is the number of bits in CurWord that are valid. This is always from | ||||
95 | /// [0...bits_of(size_t)-1] inclusive. | ||||
96 | unsigned BitsInCurWord = 0; | ||||
97 | |||||
98 | public: | ||||
99 | SimpleBitstreamCursor() = default; | ||||
100 | explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes) | ||||
101 | : BitcodeBytes(BitcodeBytes) {} | ||||
102 | explicit SimpleBitstreamCursor(StringRef BitcodeBytes) | ||||
103 | : BitcodeBytes(arrayRefFromStringRef(BitcodeBytes)) {} | ||||
104 | explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes) | ||||
105 | : SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {} | ||||
106 | |||||
107 | bool canSkipToPos(size_t pos) const { | ||||
108 | // pos can be skipped to if it is a valid address or one byte past the end. | ||||
109 | return pos <= BitcodeBytes.size(); | ||||
110 | } | ||||
111 | |||||
112 | bool AtEndOfStream() { | ||||
113 | return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar; | ||||
114 | } | ||||
115 | |||||
116 | /// Return the bit # of the bit we are reading. | ||||
117 | uint64_t GetCurrentBitNo() const { | ||||
118 | return NextChar*CHAR_BIT8 - BitsInCurWord; | ||||
119 | } | ||||
120 | |||||
121 | // Return the byte # of the current bit. | ||||
122 | uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; } | ||||
123 | |||||
124 | ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; } | ||||
125 | |||||
126 | /// Reset the stream to the specified bit number. | ||||
127 | Error JumpToBit(uint64_t BitNo) { | ||||
128 | size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1); | ||||
129 | unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1)); | ||||
130 | assert(canSkipToPos(ByteNo) && "Invalid location")(static_cast <bool> (canSkipToPos(ByteNo) && "Invalid location" ) ? void (0) : __assert_fail ("canSkipToPos(ByteNo) && \"Invalid location\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 130, __extension__ __PRETTY_FUNCTION__)); | ||||
131 | |||||
132 | // Move the cursor to the right word. | ||||
133 | NextChar = ByteNo; | ||||
134 | BitsInCurWord = 0; | ||||
135 | |||||
136 | // Skip over any bits that are already consumed. | ||||
137 | if (WordBitNo) { | ||||
138 | if (Expected<word_t> Res = Read(WordBitNo)) | ||||
139 | return Error::success(); | ||||
140 | else | ||||
141 | return Res.takeError(); | ||||
142 | } | ||||
143 | |||||
144 | return Error::success(); | ||||
145 | } | ||||
146 | |||||
147 | /// Get a pointer into the bitstream at the specified byte offset. | ||||
148 | const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) { | ||||
149 | return BitcodeBytes.data() + ByteNo; | ||||
150 | } | ||||
151 | |||||
152 | /// Get a pointer into the bitstream at the specified bit offset. | ||||
153 | /// | ||||
154 | /// The bit offset must be on a byte boundary. | ||||
155 | const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) { | ||||
156 | assert(!(BitNo % 8) && "Expected bit on byte boundary")(static_cast <bool> (!(BitNo % 8) && "Expected bit on byte boundary" ) ? void (0) : __assert_fail ("!(BitNo % 8) && \"Expected bit on byte boundary\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 156, __extension__ __PRETTY_FUNCTION__)); | ||||
157 | return getPointerToByte(BitNo / 8, NumBytes); | ||||
158 | } | ||||
159 | |||||
160 | Error fillCurWord() { | ||||
161 | if (NextChar >= BitcodeBytes.size()) | ||||
162 | return createStringError(std::errc::io_error, | ||||
163 | "Unexpected end of file reading %u of %u bytes", | ||||
164 | NextChar, BitcodeBytes.size()); | ||||
165 | |||||
166 | // Read the next word from the stream. | ||||
167 | const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar; | ||||
168 | unsigned BytesRead; | ||||
169 | if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) { | ||||
170 | BytesRead = sizeof(word_t); | ||||
171 | CurWord = | ||||
172 | support::endian::read<word_t, support::little, support::unaligned>( | ||||
173 | NextCharPtr); | ||||
174 | } else { | ||||
175 | // Short read. | ||||
176 | BytesRead = BitcodeBytes.size() - NextChar; | ||||
177 | CurWord = 0; | ||||
178 | for (unsigned B = 0; B != BytesRead; ++B) | ||||
179 | CurWord |= uint64_t(NextCharPtr[B]) << (B * 8); | ||||
180 | } | ||||
181 | NextChar += BytesRead; | ||||
182 | BitsInCurWord = BytesRead * 8; | ||||
183 | return Error::success(); | ||||
184 | } | ||||
185 | |||||
186 | Expected<word_t> Read(unsigned NumBits) { | ||||
187 | static const unsigned BitsInWord = sizeof(word_t) * 8; | ||||
188 | |||||
189 | assert(NumBits && NumBits <= BitsInWord &&(static_cast <bool> (NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!" ) ? void (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 190, __extension__ __PRETTY_FUNCTION__)) | ||||
190 | "Cannot return zero or more than BitsInWord bits!")(static_cast <bool> (NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!" ) ? void (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 190, __extension__ __PRETTY_FUNCTION__)); | ||||
191 | |||||
192 | static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f; | ||||
193 | |||||
194 | // If the field is fully contained by CurWord, return it quickly. | ||||
195 | if (BitsInCurWord >= NumBits) { | ||||
196 | word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits)); | ||||
197 | |||||
198 | // Use a mask to avoid undefined behavior. | ||||
199 | CurWord >>= (NumBits & Mask); | ||||
200 | |||||
201 | BitsInCurWord -= NumBits; | ||||
202 | return R; | ||||
203 | } | ||||
204 | |||||
205 | word_t R = BitsInCurWord
| ||||
206 | unsigned BitsLeft = NumBits - BitsInCurWord; | ||||
207 | |||||
208 | if (Error fillResult = fillCurWord()) | ||||
209 | return std::move(fillResult); | ||||
210 | |||||
211 | // If we run out of data, abort. | ||||
212 | if (BitsLeft > BitsInCurWord) | ||||
213 | return createStringError(std::errc::io_error, | ||||
214 | "Unexpected end of file reading %u of %u bits", | ||||
215 | BitsInCurWord, BitsLeft); | ||||
216 | |||||
217 | word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft)); | ||||
| |||||
218 | |||||
219 | // Use a mask to avoid undefined behavior. | ||||
220 | CurWord >>= (BitsLeft & Mask); | ||||
221 | |||||
222 | BitsInCurWord -= BitsLeft; | ||||
223 | |||||
224 | R |= R2 << (NumBits - BitsLeft); | ||||
225 | |||||
226 | return R; | ||||
227 | } | ||||
228 | |||||
229 | Expected<uint32_t> ReadVBR(const unsigned NumBits) { | ||||
230 | Expected<unsigned> MaybeRead = Read(NumBits); | ||||
231 | if (!MaybeRead) | ||||
232 | return MaybeRead; | ||||
233 | uint32_t Piece = MaybeRead.get(); | ||||
234 | |||||
235 | assert(NumBits <= 32 && NumBits >= 1 && "Invalid NumBits value")(static_cast <bool> (NumBits <= 32 && NumBits >= 1 && "Invalid NumBits value") ? void (0) : __assert_fail ("NumBits <= 32 && NumBits >= 1 && \"Invalid NumBits value\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 235, __extension__ __PRETTY_FUNCTION__)); | ||||
236 | const uint32_t MaskBitOrder = (NumBits - 1); | ||||
237 | const uint32_t Mask = 1UL << MaskBitOrder; | ||||
238 | |||||
239 | if ((Piece & Mask) == 0) | ||||
240 | return Piece; | ||||
241 | |||||
242 | uint32_t Result = 0; | ||||
243 | unsigned NextBit = 0; | ||||
244 | while (true) { | ||||
245 | Result |= (Piece & (Mask - 1)) << NextBit; | ||||
246 | |||||
247 | if ((Piece & Mask) == 0) | ||||
248 | return Result; | ||||
249 | |||||
250 | NextBit += NumBits-1; | ||||
251 | if (NextBit >= 32) | ||||
252 | return createStringError(std::errc::illegal_byte_sequence, | ||||
253 | "Unterminated VBR"); | ||||
254 | |||||
255 | MaybeRead = Read(NumBits); | ||||
256 | if (!MaybeRead) | ||||
257 | return MaybeRead; | ||||
258 | Piece = MaybeRead.get(); | ||||
259 | } | ||||
260 | } | ||||
261 | |||||
262 | // Read a VBR that may have a value up to 64-bits in size. The chunk size of | ||||
263 | // the VBR must still be <= 32 bits though. | ||||
264 | Expected<uint64_t> ReadVBR64(const unsigned NumBits) { | ||||
265 | Expected<uint64_t> MaybeRead = Read(NumBits); | ||||
266 | if (!MaybeRead) | ||||
267 | return MaybeRead; | ||||
268 | uint32_t Piece = MaybeRead.get(); | ||||
269 | assert(NumBits <= 32 && NumBits >= 1 && "Invalid NumBits value")(static_cast <bool> (NumBits <= 32 && NumBits >= 1 && "Invalid NumBits value") ? void (0) : __assert_fail ("NumBits <= 32 && NumBits >= 1 && \"Invalid NumBits value\"" , "llvm/include/llvm/Bitstream/BitstreamReader.h", 269, __extension__ __PRETTY_FUNCTION__)); | ||||
270 | const uint32_t MaskBitOrder = (NumBits - 1); | ||||
271 | const uint32_t Mask = 1UL << MaskBitOrder; | ||||
272 | |||||
273 | if ((Piece & Mask) == 0) | ||||
274 | return uint64_t(Piece); | ||||
275 | |||||
276 | uint64_t Result = 0; | ||||
277 | unsigned NextBit = 0; | ||||
278 | while (true) { | ||||
279 | Result |= uint64_t(Piece & (Mask - 1)) << NextBit; | ||||
280 | |||||
281 | if ((Piece & Mask) == 0) | ||||
282 | return Result; | ||||
283 | |||||
284 | NextBit += NumBits-1; | ||||
285 | if (NextBit >= 64) | ||||
286 | return createStringError(std::errc::illegal_byte_sequence, | ||||
287 | "Unterminated VBR"); | ||||
288 | |||||
289 | MaybeRead = Read(NumBits); | ||||
290 | if (!MaybeRead) | ||||
291 | return MaybeRead; | ||||
292 | Piece = MaybeRead.get(); | ||||
293 | } | ||||
294 | } | ||||
295 | |||||
296 | void SkipToFourByteBoundary() { | ||||
297 | // If word_t is 64-bits and if we've read less than 32 bits, just dump | ||||
298 | // the bits we have up to the next 32-bit boundary. | ||||
299 | if (sizeof(word_t) > 4 && | ||||
300 | BitsInCurWord >= 32) { | ||||
301 | CurWord >>= BitsInCurWord-32; | ||||
302 | BitsInCurWord = 32; | ||||
303 | return; | ||||
304 | } | ||||
305 | |||||
306 | BitsInCurWord = 0; | ||||
307 | } | ||||
308 | |||||
309 | /// Return the size of the stream in bytes. | ||||
310 | size_t SizeInBytes() const { return BitcodeBytes.size(); } | ||||
311 | |||||
312 | /// Skip to the end of the file. | ||||
313 | void skipToEnd() { NextChar = BitcodeBytes.size(); } | ||||
314 | |||||
315 | /// Check whether a reservation of Size elements is plausible. | ||||
316 | bool isSizePlausible(size_t Size) const { | ||||
317 | // Don't allow reserving more elements than the number of bits, assuming | ||||
318 | // at least one bit is needed to encode an element. | ||||
319 | return Size < BitcodeBytes.size() * 8; | ||||
320 | } | ||||
321 | }; | ||||
322 | |||||
323 | /// When advancing through a bitstream cursor, each advance can discover a few | ||||
324 | /// different kinds of entries: | ||||
325 | struct BitstreamEntry { | ||||
326 | enum { | ||||
327 | Error, // Malformed bitcode was found. | ||||
328 | EndBlock, // We've reached the end of the current block, (or the end of the | ||||
329 | // file, which is treated like a series of EndBlock records. | ||||
330 | SubBlock, // This is the start of a new subblock of a specific ID. | ||||
331 | Record // This is a record with a specific AbbrevID. | ||||
332 | } Kind; | ||||
333 | |||||
334 | unsigned ID; | ||||
335 | |||||
336 | static BitstreamEntry getError() { | ||||
337 | BitstreamEntry E; E.Kind = Error; return E; | ||||
338 | } | ||||
339 | |||||
340 | static BitstreamEntry getEndBlock() { | ||||
341 | BitstreamEntry E; E.Kind = EndBlock; return E; | ||||
342 | } | ||||
343 | |||||
344 | static BitstreamEntry getSubBlock(unsigned ID) { | ||||
345 | BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E; | ||||
346 | } | ||||
347 | |||||
348 | static BitstreamEntry getRecord(unsigned AbbrevID) { | ||||
349 | BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E; | ||||
350 | } | ||||
351 | }; | ||||
352 | |||||
353 | /// This represents a position within a bitcode file, implemented on top of a | ||||
354 | /// SimpleBitstreamCursor. | ||||
355 | /// | ||||
356 | /// Unlike iterators, BitstreamCursors are heavy-weight objects that should not | ||||
357 | /// be passed by value. | ||||
358 | class BitstreamCursor : SimpleBitstreamCursor { | ||||
359 | // This is the declared size of code values used for the current block, in | ||||
360 | // bits. | ||||
361 | unsigned CurCodeSize = 2; | ||||
362 | |||||
363 | /// Abbrevs installed at in this block. | ||||
364 | std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs; | ||||
365 | |||||
366 | struct Block { | ||||
367 | unsigned PrevCodeSize; | ||||
368 | std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs; | ||||
369 | |||||
370 | explicit Block(unsigned PCS) : PrevCodeSize(PCS) {} | ||||
371 | }; | ||||
372 | |||||
373 | /// This tracks the codesize of parent blocks. | ||||
374 | SmallVector<Block, 8> BlockScope; | ||||
375 | |||||
376 | BitstreamBlockInfo *BlockInfo = nullptr; | ||||
377 | |||||
378 | public: | ||||
379 | static const size_t MaxChunkSize = 32; | ||||
380 | |||||
381 | BitstreamCursor() = default; | ||||
382 | explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes) | ||||
383 | : SimpleBitstreamCursor(BitcodeBytes) {} | ||||
384 | explicit BitstreamCursor(StringRef BitcodeBytes) | ||||
385 | : SimpleBitstreamCursor(BitcodeBytes) {} | ||||
386 | explicit BitstreamCursor(MemoryBufferRef BitcodeBytes) | ||||
387 | : SimpleBitstreamCursor(BitcodeBytes) {} | ||||
388 | |||||
389 | using SimpleBitstreamCursor::AtEndOfStream; | ||||
390 | using SimpleBitstreamCursor::canSkipToPos; | ||||
391 | using SimpleBitstreamCursor::fillCurWord; | ||||
392 | using SimpleBitstreamCursor::getBitcodeBytes; | ||||
393 | using SimpleBitstreamCursor::GetCurrentBitNo; | ||||
394 | using SimpleBitstreamCursor::getCurrentByteNo; | ||||
395 | using SimpleBitstreamCursor::getPointerToByte; | ||||
396 | using SimpleBitstreamCursor::JumpToBit; | ||||
397 | using SimpleBitstreamCursor::Read; | ||||
398 | using SimpleBitstreamCursor::ReadVBR; | ||||
399 | using SimpleBitstreamCursor::ReadVBR64; | ||||
400 | using SimpleBitstreamCursor::SizeInBytes; | ||||
401 | using SimpleBitstreamCursor::skipToEnd; | ||||
402 | |||||
403 | /// Return the number of bits used to encode an abbrev #. | ||||
404 | unsigned getAbbrevIDWidth() const { return CurCodeSize; } | ||||
405 | |||||
406 | /// Flags that modify the behavior of advance(). | ||||
407 | enum { | ||||
408 | /// If this flag is used, the advance() method does not automatically pop | ||||
409 | /// the block scope when the end of a block is reached. | ||||
410 | AF_DontPopBlockAtEnd = 1, | ||||
411 | |||||
412 | /// If this flag is used, abbrev entries are returned just like normal | ||||
413 | /// records. | ||||
414 | AF_DontAutoprocessAbbrevs = 2 | ||||
415 | }; | ||||
416 | |||||
417 | /// Advance the current bitstream, returning the next entry in the stream. | ||||
418 | Expected<BitstreamEntry> advance(unsigned Flags = 0) { | ||||
419 | while (true) { | ||||
420 | if (AtEndOfStream()) | ||||
421 | return BitstreamEntry::getError(); | ||||
422 | |||||
423 | Expected<unsigned> MaybeCode = ReadCode(); | ||||
424 | if (!MaybeCode) | ||||
425 | return MaybeCode.takeError(); | ||||
426 | unsigned Code = MaybeCode.get(); | ||||
427 | |||||
428 | if (Code == bitc::END_BLOCK) { | ||||
429 | // Pop the end of the block unless Flags tells us not to. | ||||
430 | if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd()) | ||||
431 | return BitstreamEntry::getError(); | ||||
432 | return BitstreamEntry::getEndBlock(); | ||||
433 | } | ||||
434 | |||||
435 | if (Code == bitc::ENTER_SUBBLOCK) { | ||||
436 | if (Expected<unsigned> MaybeSubBlock = ReadSubBlockID()) | ||||
437 | return BitstreamEntry::getSubBlock(MaybeSubBlock.get()); | ||||
438 | else | ||||
439 | return MaybeSubBlock.takeError(); | ||||
440 | } | ||||
441 | |||||
442 | if (Code == bitc::DEFINE_ABBREV && | ||||
443 | !(Flags & AF_DontAutoprocessAbbrevs)) { | ||||
444 | // We read and accumulate abbrev's, the client can't do anything with | ||||
445 | // them anyway. | ||||
446 | if (Error Err = ReadAbbrevRecord()) | ||||
447 | return std::move(Err); | ||||
448 | continue; | ||||
449 | } | ||||
450 | |||||
451 | return BitstreamEntry::getRecord(Code); | ||||
452 | } | ||||
453 | } | ||||
454 | |||||
455 | /// This is a convenience function for clients that don't expect any | ||||
456 | /// subblocks. This just skips over them automatically. | ||||
457 | Expected<BitstreamEntry> advanceSkippingSubblocks(unsigned Flags = 0) { | ||||
458 | while (true) { | ||||
459 | // If we found a normal entry, return it. | ||||
460 | Expected<BitstreamEntry> MaybeEntry = advance(Flags); | ||||
461 | if (!MaybeEntry) | ||||
462 | return MaybeEntry; | ||||
463 | BitstreamEntry Entry = MaybeEntry.get(); | ||||
464 | |||||
465 | if (Entry.Kind != BitstreamEntry::SubBlock) | ||||
466 | return Entry; | ||||
467 | |||||
468 | // If we found a sub-block, just skip over it and check the next entry. | ||||
469 | if (Error Err = SkipBlock()) | ||||
470 | return std::move(Err); | ||||
471 | } | ||||
472 | } | ||||
473 | |||||
474 | Expected<unsigned> ReadCode() { return Read(CurCodeSize); } | ||||
475 | |||||
476 | // Block header: | ||||
477 | // [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen] | ||||
478 | |||||
479 | /// Having read the ENTER_SUBBLOCK code, read the BlockID for the block. | ||||
480 | Expected<unsigned> ReadSubBlockID() { return ReadVBR(bitc::BlockIDWidth); } | ||||
481 | |||||
482 | /// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body | ||||
483 | /// of this block. | ||||
484 | Error SkipBlock() { | ||||
485 | // Read and ignore the codelen value. | ||||
486 | if (Expected<uint32_t> Res = ReadVBR(bitc::CodeLenWidth)) | ||||
487 | ; // Since we are skipping this block, we don't care what code widths are | ||||
488 | // used inside of it. | ||||
489 | else | ||||
490 | return Res.takeError(); | ||||
491 | |||||
492 | SkipToFourByteBoundary(); | ||||
493 | Expected<unsigned> MaybeNum = Read(bitc::BlockSizeWidth); | ||||
494 | if (!MaybeNum) | ||||
495 | return MaybeNum.takeError(); | ||||
496 | size_t NumFourBytes = MaybeNum.get(); | ||||
497 | |||||
498 | // Check that the block wasn't partially defined, and that the offset isn't | ||||
499 | // bogus. | ||||
500 | size_t SkipTo = GetCurrentBitNo() + NumFourBytes * 4 * 8; | ||||
501 | if (AtEndOfStream()) | ||||
502 | return createStringError(std::errc::illegal_byte_sequence, | ||||
503 | "can't skip block: already at end of stream"); | ||||
504 | if (!canSkipToPos(SkipTo / 8)) | ||||
505 | return createStringError(std::errc::illegal_byte_sequence, | ||||
506 | "can't skip to bit %zu from %" PRIu64"l" "u", SkipTo, | ||||
507 | GetCurrentBitNo()); | ||||
508 | |||||
509 | if (Error Res = JumpToBit(SkipTo)) | ||||
510 | return Res; | ||||
511 | |||||
512 | return Error::success(); | ||||
513 | } | ||||
514 | |||||
515 | /// Having read the ENTER_SUBBLOCK abbrevid, and enter the block. | ||||
516 | Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr); | ||||
517 | |||||
518 | bool ReadBlockEnd() { | ||||
519 | if (BlockScope.empty()) return true; | ||||
520 | |||||
521 | // Block tail: | ||||
522 | // [END_BLOCK, <align4bytes>] | ||||
523 | SkipToFourByteBoundary(); | ||||
524 | |||||
525 | popBlockScope(); | ||||
526 | return false; | ||||
527 | } | ||||
528 | |||||
529 | private: | ||||
530 | void popBlockScope() { | ||||
531 | CurCodeSize = BlockScope.back().PrevCodeSize; | ||||
532 | |||||
533 | CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs); | ||||
534 | BlockScope.pop_back(); | ||||
535 | } | ||||
536 | |||||
537 | //===--------------------------------------------------------------------===// | ||||
538 | // Record Processing | ||||
539 | //===--------------------------------------------------------------------===// | ||||
540 | |||||
541 | public: | ||||
542 | /// Return the abbreviation for the specified AbbrevId. | ||||
543 | Expected<const BitCodeAbbrev *> getAbbrev(unsigned AbbrevID) { | ||||
544 | unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV; | ||||
545 | if (AbbrevNo >= CurAbbrevs.size()) | ||||
546 | return createStringError( | ||||
547 | std::errc::illegal_byte_sequence, "Invalid abbrev number"); | ||||
548 | return CurAbbrevs[AbbrevNo].get(); | ||||
549 | } | ||||
550 | |||||
551 | /// Read the current record and discard it, returning the code for the record. | ||||
552 | Expected<unsigned> skipRecord(unsigned AbbrevID); | ||||
553 | |||||
554 | Expected<unsigned> readRecord(unsigned AbbrevID, | ||||
555 | SmallVectorImpl<uint64_t> &Vals, | ||||
556 | StringRef *Blob = nullptr); | ||||
557 | |||||
558 | //===--------------------------------------------------------------------===// | ||||
559 | // Abbrev Processing | ||||
560 | //===--------------------------------------------------------------------===// | ||||
561 | Error ReadAbbrevRecord(); | ||||
562 | |||||
563 | /// Read and return a block info block from the bitstream. If an error was | ||||
564 | /// encountered, return None. | ||||
565 | /// | ||||
566 | /// \param ReadBlockInfoNames Whether to read block/record name information in | ||||
567 | /// the BlockInfo block. Only llvm-bcanalyzer uses this. | ||||
568 | Expected<Optional<BitstreamBlockInfo>> | ||||
569 | ReadBlockInfoBlock(bool ReadBlockInfoNames = false); | ||||
570 | |||||
571 | /// Set the block info to be used by this BitstreamCursor to interpret | ||||
572 | /// abbreviated records. | ||||
573 | void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; } | ||||
574 | }; | ||||
575 | |||||
576 | } // end llvm namespace | ||||
577 | |||||
578 | #endif // LLVM_BITSTREAM_BITSTREAMREADER_H |