Line data Source code
1 : //===- BitstreamReader.cpp - BitstreamReader implementation ---------------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 :
10 : #include "llvm/Bitcode/BitstreamReader.h"
11 : #include "llvm/ADT/StringRef.h"
12 : #include <cassert>
13 : #include <string>
14 :
15 : using namespace llvm;
16 :
17 : //===----------------------------------------------------------------------===//
18 : // BitstreamCursor implementation
19 : //===----------------------------------------------------------------------===//
20 :
21 : /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
22 : /// the block, and return true if the block has an error.
23 142725 : bool BitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) {
24 : // Save the current block's state on BlockScope.
25 428174 : BlockScope.push_back(Block(CurCodeSize));
26 142724 : BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
27 :
28 : // Add the abbrevs specific to this block to the CurAbbrevs list.
29 142724 : if (BlockInfo) {
30 66589 : if (const BitstreamBlockInfo::BlockInfo *Info =
31 : BlockInfo->getBlockInfo(BlockID)) {
32 : CurAbbrevs.insert(CurAbbrevs.end(), Info->Abbrevs.begin(),
33 73510 : Info->Abbrevs.end());
34 : }
35 : }
36 :
37 : // Get the codesize of this block.
38 142724 : CurCodeSize = ReadVBR(bitc::CodeLenWidth);
39 : // We can't read more than MaxChunkSize at a time
40 142726 : if (CurCodeSize > MaxChunkSize)
41 : return true;
42 :
43 : SkipToFourByteBoundary();
44 142726 : unsigned NumWords = Read(bitc::BlockSizeWidth);
45 142726 : if (NumWordsP) *NumWordsP = NumWords;
46 :
47 : // Validate that this block is sane.
48 142726 : return CurCodeSize == 0 || AtEndOfStream();
49 : }
50 :
51 4632436 : static uint64_t readAbbreviatedField(BitstreamCursor &Cursor,
52 : const BitCodeAbbrevOp &Op) {
53 : assert(!Op.isLiteral() && "Not to be used with literals!");
54 :
55 : // Decode the value as we are commanded.
56 4632436 : switch (Op.getEncoding()) {
57 : case BitCodeAbbrevOp::Array:
58 : case BitCodeAbbrevOp::Blob:
59 : llvm_unreachable("Should not reach here");
60 3292278 : case BitCodeAbbrevOp::Fixed:
61 : assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
62 3292278 : return Cursor.Read((unsigned)Op.getEncodingData());
63 1340158 : case BitCodeAbbrevOp::VBR:
64 : assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
65 1340158 : return Cursor.ReadVBR64((unsigned)Op.getEncodingData());
66 0 : case BitCodeAbbrevOp::Char6:
67 0 : return BitCodeAbbrevOp::DecodeChar6(Cursor.Read(6));
68 : }
69 0 : llvm_unreachable("invalid abbreviation encoding");
70 : }
71 :
72 12457 : static void skipAbbreviatedField(BitstreamCursor &Cursor,
73 : const BitCodeAbbrevOp &Op) {
74 : assert(!Op.isLiteral() && "Not to be used with literals!");
75 :
76 : // Decode the value as we are commanded.
77 12457 : switch (Op.getEncoding()) {
78 : case BitCodeAbbrevOp::Array:
79 : case BitCodeAbbrevOp::Blob:
80 : llvm_unreachable("Should not reach here");
81 5984 : case BitCodeAbbrevOp::Fixed:
82 : assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
83 5984 : Cursor.Read((unsigned)Op.getEncodingData());
84 5984 : break;
85 6473 : case BitCodeAbbrevOp::VBR:
86 : assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
87 6473 : Cursor.ReadVBR64((unsigned)Op.getEncodingData());
88 6473 : break;
89 0 : case BitCodeAbbrevOp::Char6:
90 0 : Cursor.Read(6);
91 0 : break;
92 : }
93 12457 : }
94 :
95 : /// skipRecord - Read the current record and discard it.
96 25910 : unsigned BitstreamCursor::skipRecord(unsigned AbbrevID) {
97 : // Skip unabbreviated records by reading past their entries.
98 25910 : if (AbbrevID == bitc::UNABBREV_RECORD) {
99 19743 : unsigned Code = ReadVBR(6);
100 19743 : unsigned NumElts = ReadVBR(6);
101 283441 : for (unsigned i = 0; i != NumElts; ++i)
102 263698 : (void)ReadVBR64(6);
103 : return Code;
104 : }
105 :
106 6167 : const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
107 : const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0);
108 : unsigned Code;
109 6167 : if (CodeOp.isLiteral())
110 6167 : Code = CodeOp.getLiteralValue();
111 : else {
112 0 : if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array ||
113 : CodeOp.getEncoding() == BitCodeAbbrevOp::Blob)
114 0 : report_fatal_error("Abbreviation starts with an Array or a Blob");
115 0 : Code = readAbbreviatedField(*this, CodeOp);
116 : }
117 :
118 23076 : for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) {
119 : const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
120 16909 : if (Op.isLiteral())
121 : continue;
122 :
123 14957 : if (Op.getEncoding() != BitCodeAbbrevOp::Array &&
124 : Op.getEncoding() != BitCodeAbbrevOp::Blob) {
125 12457 : skipAbbreviatedField(*this, Op);
126 12457 : continue;
127 : }
128 :
129 2500 : if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
130 : // Array case. Read the number of elements as a vbr6.
131 2197 : unsigned NumElts = ReadVBR(6);
132 :
133 : // Get the element encoding.
134 : assert(i+2 == e && "array op not second to last?");
135 2197 : const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
136 :
137 : // Read all the elements.
138 : // Decode the value as we are commanded.
139 2197 : switch (EltEnc.getEncoding()) {
140 0 : default:
141 0 : report_fatal_error("Array element type can't be an Array or a Blob");
142 1792 : case BitCodeAbbrevOp::Fixed:
143 : assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
144 3584 : JumpToBit(GetCurrentBitNo() + NumElts * EltEnc.getEncodingData());
145 : break;
146 318 : case BitCodeAbbrevOp::VBR:
147 : assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
148 318 : for (; NumElts; --NumElts)
149 155 : ReadVBR64((unsigned)EltEnc.getEncodingData());
150 : break;
151 242 : case BitCodeAbbrevOp::Char6:
152 484 : JumpToBit(GetCurrentBitNo() + NumElts * 6);
153 : break;
154 : }
155 2197 : continue;
156 : }
157 :
158 : assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
159 : // Blob case. Read the number of bytes as a vbr6.
160 303 : unsigned NumElts = ReadVBR(6);
161 : SkipToFourByteBoundary(); // 32-bit alignment
162 :
163 : // Figure out where the end of this blob will be including tail padding.
164 303 : size_t NewEnd = GetCurrentBitNo()+((NumElts+3)&~3)*8;
165 :
166 : // If this would read off the end of the bitcode file, just set the
167 : // record to empty and return.
168 606 : if (!canSkipToPos(NewEnd/8)) {
169 : skipToEnd();
170 : break;
171 : }
172 :
173 : // Skip over the blob.
174 : JumpToBit(NewEnd);
175 : }
176 : return Code;
177 : }
178 :
179 2527020 : unsigned BitstreamCursor::readRecord(unsigned AbbrevID,
180 : SmallVectorImpl<uint64_t> &Vals,
181 : StringRef *Blob) {
182 2527020 : if (AbbrevID == bitc::UNABBREV_RECORD) {
183 1617939 : unsigned Code = ReadVBR(6);
184 1617939 : unsigned NumElts = ReadVBR(6);
185 24279265 : for (unsigned i = 0; i != NumElts; ++i)
186 22661325 : Vals.push_back(ReadVBR64(6));
187 : return Code;
188 : }
189 :
190 909081 : const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
191 :
192 : // Read the record code first.
193 : assert(Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?");
194 : const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0);
195 : unsigned Code;
196 909081 : if (CodeOp.isLiteral())
197 909079 : Code = CodeOp.getLiteralValue();
198 : else {
199 2 : if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array ||
200 : CodeOp.getEncoding() == BitCodeAbbrevOp::Blob)
201 0 : report_fatal_error("Abbreviation starts with an Array or a Blob");
202 2 : Code = readAbbreviatedField(*this, CodeOp);
203 : }
204 :
205 6475526 : for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
206 : const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
207 5566446 : if (Op.isLiteral()) {
208 516876 : Vals.push_back(Op.getLiteralValue());
209 516876 : continue;
210 : }
211 :
212 5049570 : if (Op.getEncoding() != BitCodeAbbrevOp::Array &&
213 : Op.getEncoding() != BitCodeAbbrevOp::Blob) {
214 4632434 : Vals.push_back(readAbbreviatedField(*this, Op));
215 4632434 : continue;
216 : }
217 :
218 417136 : if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
219 : // Array case. Read the number of elements as a vbr6.
220 187323 : unsigned NumElts = ReadVBR(6);
221 :
222 : // Get the element encoding.
223 187323 : if (i + 2 != e)
224 1 : report_fatal_error("Array op not second to last");
225 187322 : const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
226 187322 : if (!EltEnc.isEncoding())
227 0 : report_fatal_error(
228 : "Array element type has to be an encoding of a type");
229 :
230 : // Read all the elements.
231 187322 : switch (EltEnc.getEncoding()) {
232 1 : default:
233 1 : report_fatal_error("Array element type can't be an Array or a Blob");
234 412249 : case BitCodeAbbrevOp::Fixed:
235 412249 : for (; NumElts; --NumElts)
236 386824 : Vals.push_back(Read((unsigned)EltEnc.getEncodingData()));
237 : break;
238 184696 : case BitCodeAbbrevOp::VBR:
239 184696 : for (; NumElts; --NumElts)
240 148293 : Vals.push_back(ReadVBR64((unsigned)EltEnc.getEncodingData()));
241 : break;
242 1330283 : case BitCodeAbbrevOp::Char6:
243 1330283 : for (; NumElts; --NumElts)
244 1204789 : Vals.push_back(BitCodeAbbrevOp::DecodeChar6(Read(6)));
245 : }
246 187322 : continue;
247 : }
248 :
249 : assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
250 : // Blob case. Read the number of bytes as a vbr6.
251 229813 : unsigned NumElts = ReadVBR(6);
252 : SkipToFourByteBoundary(); // 32-bit alignment
253 :
254 : // Figure out where the end of this blob will be including tail padding.
255 229813 : size_t CurBitPos = GetCurrentBitNo();
256 229813 : size_t NewEnd = CurBitPos+((NumElts+3)&~3)*8;
257 :
258 : // If this would read off the end of the bitcode file, just set the
259 : // record to empty and return.
260 459626 : if (!canSkipToPos(NewEnd/8)) {
261 0 : Vals.append(NumElts, 0);
262 : skipToEnd();
263 : break;
264 : }
265 :
266 : // Otherwise, inform the streamer that we need these bytes in memory. Skip
267 : // over tail padding first, in case jumping to NewEnd invalidates the Blob
268 : // pointer.
269 : JumpToBit(NewEnd);
270 229813 : const char *Ptr = (const char *)getPointerToBit(CurBitPos, NumElts);
271 :
272 : // If we can return a reference to the data, do so to avoid copying it.
273 229813 : if (Blob) {
274 229813 : *Blob = StringRef(Ptr, NumElts);
275 : } else {
276 : // Otherwise, unpack into Vals with zero extension.
277 0 : for (; NumElts; --NumElts)
278 0 : Vals.push_back((unsigned char)*Ptr++);
279 : }
280 : }
281 :
282 : return Code;
283 : }
284 :
285 441047 : void BitstreamCursor::ReadAbbrevRecord() {
286 : auto Abbv = std::make_shared<BitCodeAbbrev>();
287 441046 : unsigned NumOpInfo = ReadVBR(5);
288 3769364 : for (unsigned i = 0; i != NumOpInfo; ++i) {
289 3328320 : bool IsLiteral = Read(1);
290 3328321 : if (IsLiteral) {
291 1196669 : Abbv->Add(BitCodeAbbrevOp(ReadVBR64(8)));
292 1196670 : continue;
293 : }
294 :
295 2131652 : BitCodeAbbrevOp::Encoding E = (BitCodeAbbrevOp::Encoding)Read(3);
296 : if (BitCodeAbbrevOp::hasEncodingData(E)) {
297 1797992 : uint64_t Data = ReadVBR64(5);
298 :
299 : // As a special case, handle fixed(0) (i.e., a fixed field with zero bits)
300 : // and vbr(0) as a literal zero. This is decoded the same way, and avoids
301 : // a slow path in Read() to have to handle reading zero bits.
302 1797992 : if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) &&
303 : Data == 0) {
304 717 : Abbv->Add(BitCodeAbbrevOp(0));
305 717 : continue;
306 : }
307 :
308 1797275 : if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) &&
309 : Data > MaxChunkSize)
310 2 : report_fatal_error(
311 : "Fixed or VBR abbrev record with size > MaxChunkData");
312 :
313 1797273 : Abbv->Add(BitCodeAbbrevOp(E, Data));
314 : } else
315 333658 : Abbv->Add(BitCodeAbbrevOp(E));
316 : }
317 :
318 441044 : if (Abbv->getNumOperandInfos() == 0)
319 1 : report_fatal_error("Abbrev record with no operands");
320 441043 : CurAbbrevs.push_back(std::move(Abbv));
321 441041 : }
322 :
323 : Optional<BitstreamBlockInfo>
324 4115 : BitstreamCursor::ReadBlockInfoBlock(bool ReadBlockInfoNames) {
325 4115 : if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return None;
326 :
327 : BitstreamBlockInfo NewBlockInfo;
328 :
329 : SmallVector<uint64_t, 64> Record;
330 : BitstreamBlockInfo::BlockInfo *CurBlockInfo = nullptr;
331 :
332 : // Read all the records for this module.
333 : while (true) {
334 84823 : BitstreamEntry Entry = advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs);
335 :
336 84823 : switch (Entry.Kind) {
337 : case llvm::BitstreamEntry::SubBlock: // Handled for us already.
338 : case llvm::BitstreamEntry::Error:
339 4112 : return None;
340 : case llvm::BitstreamEntry::EndBlock:
341 : return std::move(NewBlockInfo);
342 : case llvm::BitstreamEntry::Record:
343 : // The interesting case.
344 : break;
345 : }
346 :
347 : // Read abbrev records, associate them with CurBID.
348 80711 : if (Entry.ID == bitc::DEFINE_ABBREV) {
349 65702 : if (!CurBlockInfo) return None;
350 65702 : ReadAbbrevRecord();
351 :
352 : // ReadAbbrevRecord installs the abbrev in CurAbbrevs. Move it to the
353 : // appropriate BlockInfo.
354 65698 : CurBlockInfo->Abbrevs.push_back(std::move(CurAbbrevs.back()));
355 : CurAbbrevs.pop_back();
356 65699 : continue;
357 : }
358 :
359 : // Read a record.
360 : Record.clear();
361 15009 : switch (readRecord(Entry.ID, Record)) {
362 : default: break; // Default behavior, ignore unknown content.
363 12576 : case bitc::BLOCKINFO_CODE_SETBID:
364 12576 : if (Record.size() < 1) return None;
365 12576 : CurBlockInfo = &NewBlockInfo.getOrCreateBlockInfo((unsigned)Record[0]);
366 12575 : break;
367 206 : case bitc::BLOCKINFO_CODE_BLOCKNAME: {
368 206 : if (!CurBlockInfo) return None;
369 206 : if (!ReadBlockInfoNames)
370 : break; // Ignore name.
371 : std::string Name;
372 1070 : for (unsigned i = 0, e = Record.size(); i != e; ++i)
373 2008 : Name += (char)Record[i];
374 66 : CurBlockInfo->Name = Name;
375 : break;
376 : }
377 2228 : case bitc::BLOCKINFO_CODE_SETRECORDNAME: {
378 2228 : if (!CurBlockInfo) return None;
379 2228 : if (!ReadBlockInfoNames)
380 : break; // Ignore name.
381 : std::string Name;
382 34068 : for (unsigned i = 1, e = Record.size(); i != e; ++i)
383 64726 : Name += (char)Record[i];
384 5115 : CurBlockInfo->RecordNames.push_back(std::make_pair((unsigned)Record[0],
385 : Name));
386 : break;
387 : }
388 : }
389 : }
390 : }
|
