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