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 CurAbbrevs.insert(CurAbbrevs.end(), Info->Abbrevs.begin(), 31 Info->Abbrevs.end()); 32 } 33 } 34 35 // Get the codesize of this block. 36 Expected<uint32_t> MaybeVBR = ReadVBR(bitc::CodeLenWidth); 37 if (!MaybeVBR) 38 return MaybeVBR.takeError(); 39 CurCodeSize = MaybeVBR.get(); 40 41 if (CurCodeSize > MaxChunkSize) 42 return llvm::createStringError( 43 std::errc::illegal_byte_sequence, 44 "can't read more than %zu at a time, trying to read %u", +MaxChunkSize, 45 CurCodeSize); 46 47 SkipToFourByteBoundary(); 48 Expected<word_t> MaybeNum = Read(bitc::BlockSizeWidth); 49 if (!MaybeNum) 50 return MaybeNum.takeError(); 51 word_t NumWords = MaybeNum.get(); 52 if (NumWordsP) 53 *NumWordsP = NumWords; 54 55 if (CurCodeSize == 0) 56 return llvm::createStringError( 57 std::errc::illegal_byte_sequence, 58 "can't enter sub-block: current code size is 0"); 59 if (AtEndOfStream()) 60 return llvm::createStringError( 61 std::errc::illegal_byte_sequence, 62 "can't enter sub block: already at end of stream"); 63 64 return Error::success(); 65 } 66 67 static Expected<uint64_t> readAbbreviatedField(BitstreamCursor &Cursor, 68 const BitCodeAbbrevOp &Op) { 69 assert(!Op.isLiteral() && "Not to be used with literals!"); 70 71 // Decode the value as we are commanded. 72 switch (Op.getEncoding()) { 73 case BitCodeAbbrevOp::Array: 74 case BitCodeAbbrevOp::Blob: 75 llvm_unreachable("Should not reach here"); 76 case BitCodeAbbrevOp::Fixed: 77 assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize); 78 return Cursor.Read((unsigned)Op.getEncodingData()); 79 case BitCodeAbbrevOp::VBR: 80 assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize); 81 return Cursor.ReadVBR64((unsigned)Op.getEncodingData()); 82 case BitCodeAbbrevOp::Char6: 83 if (Expected<unsigned> Res = Cursor.Read(6)) 84 return BitCodeAbbrevOp::DecodeChar6(Res.get()); 85 else 86 return Res.takeError(); 87 } 88 llvm_unreachable("invalid abbreviation encoding"); 89 } 90 91 /// skipRecord - Read the current record and discard it. 92 Expected<unsigned> BitstreamCursor::skipRecord(unsigned AbbrevID) { 93 // Skip unabbreviated records by reading past their entries. 94 if (AbbrevID == bitc::UNABBREV_RECORD) { 95 Expected<uint32_t> MaybeCode = ReadVBR(6); 96 if (!MaybeCode) 97 return MaybeCode.takeError(); 98 unsigned Code = MaybeCode.get(); 99 Expected<uint32_t> MaybeVBR = ReadVBR(6); 100 if (!MaybeVBR) 101 return MaybeVBR.get(); 102 unsigned NumElts = MaybeVBR.get(); 103 for (unsigned i = 0; i != NumElts; ++i) 104 if (Expected<uint64_t> Res = ReadVBR64(6)) 105 ; // Skip! 106 else 107 return Res.takeError(); 108 return Code; 109 } 110 111 const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID); 112 const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0); 113 unsigned Code; 114 if (CodeOp.isLiteral()) 115 Code = CodeOp.getLiteralValue(); 116 else { 117 if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array || 118 CodeOp.getEncoding() == BitCodeAbbrevOp::Blob) 119 return llvm::createStringError( 120 std::errc::illegal_byte_sequence, 121 "Abbreviation starts with an Array or a Blob"); 122 Expected<uint64_t> MaybeCode = readAbbreviatedField(*this, CodeOp); 123 if (!MaybeCode) 124 return MaybeCode.takeError(); 125 Code = MaybeCode.get(); 126 } 127 128 for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) { 129 const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); 130 if (Op.isLiteral()) 131 continue; 132 133 if (Op.getEncoding() != BitCodeAbbrevOp::Array && 134 Op.getEncoding() != BitCodeAbbrevOp::Blob) { 135 if (Expected<uint64_t> MaybeField = readAbbreviatedField(*this, Op)) 136 continue; 137 else 138 return MaybeField.takeError(); 139 } 140 141 if (Op.getEncoding() == BitCodeAbbrevOp::Array) { 142 // Array case. Read the number of elements as a vbr6. 143 Expected<uint32_t> MaybeNum = ReadVBR(6); 144 if (!MaybeNum) 145 return MaybeNum.takeError(); 146 unsigned NumElts = MaybeNum.get(); 147 148 // Get the element encoding. 149 assert(i+2 == e && "array op not second to last?"); 150 const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); 151 152 // Read all the elements. 153 // Decode the value as we are commanded. 154 switch (EltEnc.getEncoding()) { 155 default: 156 report_fatal_error("Array element type can't be an Array or a Blob"); 157 case BitCodeAbbrevOp::Fixed: 158 assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize); 159 if (Error Err = JumpToBit(GetCurrentBitNo() + 160 NumElts * EltEnc.getEncodingData())) 161 return std::move(Err); 162 break; 163 case BitCodeAbbrevOp::VBR: 164 assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize); 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); 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 size_t NewEnd = GetCurrentBitNo()+((NumElts+3)&~3)*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?"); 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); 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 size_t NewEnd = CurBitPos+((NumElts+3)&~3)*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 } 477