include/llvm/Bitcode/BitstreamReader.h

   1 //===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
   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 // This header defines the BitstreamReader class.  This class can be used to
  11 // read an arbitrary bitstream, regardless of its contents.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_BITCODE_BITSTREAMREADER_H
  16 #define LLVM_BITCODE_BITSTREAMREADER_H
  17
  18 #include "llvm/ADT/OwningPtr.h"
  19 #include "llvm/Bitcode/BitCodes.h"
  20 #include "llvm/Support/Endian.h"
  21 #include "llvm/Support/StreamableMemoryObject.h"
  22 #include <climits>
  23 #include <string>
  24 #include <vector>
  25
  26 namespace llvm {
  27
  28   class Deserializer;
  29
  30 /// BitstreamReader - This class is used to read from an LLVM bitcode stream,
  31 /// maintaining information that is global to decoding the entire file.  While
  32 /// a file is being read, multiple cursors can be independently advanced or
  33 /// skipped around within the file.  These are represented by the
  34 /// BitstreamCursor class.
  35 class BitstreamReader {
  36 public:
  37   /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
  38   /// These describe abbreviations that all blocks of the specified ID inherit.
  39   struct BlockInfo {
  40     unsigned BlockID;
  41     std::vector<BitCodeAbbrev*> Abbrevs;
  42     std::string Name;
  43
  44     std::vector<std::pair<unsigned, std::string> > RecordNames;
  45   };
  46 private:
  47   OwningPtr<StreamableMemoryObject> BitcodeBytes;
  48
  49   std::vector<BlockInfo> BlockInfoRecords;
  50
  51   /// IgnoreBlockInfoNames - This is set to true if we don't care about the
  52   /// block/record name information in the BlockInfo block. Only llvm-bcanalyzer
  53   /// uses this.
  54   bool IgnoreBlockInfoNames;
  55
  56   BitstreamReader(const BitstreamReader&) LLVM_DELETED_FUNCTION;
  57   void operator=(const BitstreamReader&) LLVM_DELETED_FUNCTION;
  58 public:
  59   BitstreamReader() : IgnoreBlockInfoNames(true) {
  60   }
  61
  62   BitstreamReader(const unsigned char *Start, const unsigned char *End) {
  63     IgnoreBlockInfoNames = true;
  64     init(Start, End);
  65   }
  66
  67   BitstreamReader(StreamableMemoryObject *bytes) {
  68     BitcodeBytes.reset(bytes);
  69   }
  70
  71   void init(const unsigned char *Start, const unsigned char *End) {
  72     assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
  73     BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));
  74   }
  75
  76   StreamableMemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
  77
  78   ~BitstreamReader() {
  79     // Free the BlockInfoRecords.
  80     while (!BlockInfoRecords.empty()) {
  81       BlockInfo &Info = BlockInfoRecords.back();
  82       // Free blockinfo abbrev info.
  83       for (unsigned i = 0, e = static_cast<unsigned>(Info.Abbrevs.size());
  84            i != e; ++i)
  85         Info.Abbrevs[i]->dropRef();
  86       BlockInfoRecords.pop_back();
  87     }
  88   }
  89
  90   /// CollectBlockInfoNames - This is called by clients that want block/record
  91   /// name information.
  92   void CollectBlockInfoNames() { IgnoreBlockInfoNames = false; }
  93   bool isIgnoringBlockInfoNames() { return IgnoreBlockInfoNames; }
  94
  95   //===--------------------------------------------------------------------===//
  96   // Block Manipulation
  97   //===--------------------------------------------------------------------===//
  98
  99   /// hasBlockInfoRecords - Return true if we've already read and processed the
 100   /// block info block for this Bitstream.  We only process it for the first
 101   /// cursor that walks over it.
 102   bool hasBlockInfoRecords() const { return !BlockInfoRecords.empty(); }
 103
 104   /// getBlockInfo - If there is block info for the specified ID, return it,
 105   /// otherwise return null.
 106   const BlockInfo *getBlockInfo(unsigned BlockID) const {
 107     // Common case, the most recent entry matches BlockID.
 108     if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
 109       return &BlockInfoRecords.back();
 110
 111     for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
 112          i != e; ++i)
 113       if (BlockInfoRecords[i].BlockID == BlockID)
 114         return &BlockInfoRecords[i];
 115     return 0;
 116   }
 117
 118   BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
 119     if (const BlockInfo *BI = getBlockInfo(BlockID))
 120       return *const_cast<BlockInfo*>(BI);
 121
 122     // Otherwise, add a new record.
 123     BlockInfoRecords.push_back(BlockInfo());
 124     BlockInfoRecords.back().BlockID = BlockID;
 125     return BlockInfoRecords.back();
 126   }
 127 };
 128
 129
 130 /// BitstreamEntry - When advancing through a bitstream cursor, each advance can
 131 /// discover a few different kinds of entries:
 132 ///   Error    - Malformed bitcode was found.
 133 ///   EndBlock - We've reached the end of the current block, (or the end of the
 134 ///              file, which is treated like a series of EndBlock records.
 135 ///   SubBlock - This is the start of a new subblock of a specific ID.
 136 ///   Record   - This is a record with a specific AbbrevID.
 137 ///
 138 struct BitstreamEntry {
 139   enum {
 140     Error,
 141     EndBlock,
 142     SubBlock,
 143     Record
 144   } Kind;
 145
 146   unsigned ID;
 147
 148   static BitstreamEntry getError() {
 149     BitstreamEntry E; E.Kind = Error; return E;
 150   }
 151   static BitstreamEntry getEndBlock() {
 152     BitstreamEntry E; E.Kind = EndBlock; return E;
 153   }
 154   static BitstreamEntry getSubBlock(unsigned ID) {
 155     BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
 156   }
 157   static BitstreamEntry getRecord(unsigned AbbrevID) {
 158     BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
 159   }
 160 };
 161
 162 /// BitstreamCursor - This represents a position within a bitcode file.  There
 163 /// may be multiple independent cursors reading within one bitstream, each
 164 /// maintaining their own local state.
 165 ///
 166 /// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
 167 /// be passed by value.
 168 class BitstreamCursor {
 169   friend class Deserializer;
 170   BitstreamReader *BitStream;
 171   size_t NextChar;
 172
 173   /// CurWord - This is the current data we have pulled from the stream but have
 174   /// not returned to the client.
 175   uint32_t CurWord;
 176
 177   /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
 178   /// is always from [0...31] inclusive.
 179   unsigned BitsInCurWord;
 180
 181   // CurCodeSize - This is the declared size of code values used for the current
 182   // block, in bits.
 183   unsigned CurCodeSize;
 184
 185   /// CurAbbrevs - Abbrevs installed at in this block.
 186   std::vector<BitCodeAbbrev*> CurAbbrevs;
 187
 188   struct Block {
 189     unsigned PrevCodeSize;
 190     std::vector<BitCodeAbbrev*> PrevAbbrevs;
 191     explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
 192   };
 193
 194   /// BlockScope - This tracks the codesize of parent blocks.
 195   SmallVector<Block, 8> BlockScope;
 196
 197
 198 public:
 199   BitstreamCursor() : BitStream(0), NextChar(0) {
 200   }
 201   BitstreamCursor(const BitstreamCursor &RHS) : BitStream(0), NextChar(0) {
 202     operator=(RHS);
 203   }
 204
 205   explicit BitstreamCursor(BitstreamReader &R) : BitStream(&R) {
 206     NextChar = 0;
 207     CurWord = 0;
 208     BitsInCurWord = 0;
 209     CurCodeSize = 2;
 210   }
 211
 212   void init(BitstreamReader &R) {
 213     freeState();
 214
 215     BitStream = &R;
 216     NextChar = 0;
 217     CurWord = 0;
 218     BitsInCurWord = 0;
 219     CurCodeSize = 2;
 220   }
 221
 222   ~BitstreamCursor() {
 223     freeState();
 224   }
 225
 226   void operator=(const BitstreamCursor &RHS);
 227
 228   void freeState();
 229
 230   bool isEndPos(size_t pos) {
 231     return BitStream->getBitcodeBytes().isObjectEnd(static_cast<uint64_t>(pos));
 232   }
 233
 234   bool canSkipToPos(size_t pos) const {
 235     // pos can be skipped to if it is a valid address or one byte past the end.
 236     return pos == 0 || BitStream->getBitcodeBytes().isValidAddress(
 237         static_cast<uint64_t>(pos - 1));
 238   }
 239
 240   uint32_t getWord(size_t pos) {
 241     uint8_t buf[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
 242     BitStream->getBitcodeBytes().readBytes(pos, sizeof(buf), buf, NULL);
 243     return *reinterpret_cast<support::ulittle32_t *>(buf);
 244   }
 245
 246   bool AtEndOfStream() {
 247     return BitsInCurWord == 0 && isEndPos(NextChar);
 248   }
 249
 250   /// getAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
 251   unsigned getAbbrevIDWidth() const { return CurCodeSize; }
 252
 253   /// GetCurrentBitNo - Return the bit # of the bit we are reading.
 254   uint64_t GetCurrentBitNo() const {
 255     return NextChar*CHAR_BIT - BitsInCurWord;
 256   }
 257
 258   BitstreamReader *getBitStreamReader() {
 259     return BitStream;
 260   }
 261   const BitstreamReader *getBitStreamReader() const {
 262     return BitStream;
 263   }
 264
 265   /// Flags that modify the behavior of advance().
 266   enum {
 267     /// AF_DontPopBlockAtEnd - If this flag is used, the advance() method does
 268     /// not automatically pop the block scope when the end of a block is
 269     /// reached.
 270     AF_DontPopBlockAtEnd = 1,
 271
 272     /// AF_DontAutoprocessAbbrevs - If this flag is used, abbrev entries are
 273     /// returned just like normal records.
 274     AF_DontAutoprocessAbbrevs = 2
 275   };
 276
 277   /// advance - Advance the current bitstream, returning the next entry in the
 278   /// stream.
 279   BitstreamEntry advance(unsigned Flags = 0) {
 280     while (1) {
 281       unsigned Code = ReadCode();
 282       if (Code == bitc::END_BLOCK) {
 283         // Pop the end of the block unless Flags tells us not to.
 284         if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
 285           return BitstreamEntry::getError();
 286         return BitstreamEntry::getEndBlock();
 287       }
 288
 289       if (Code == bitc::ENTER_SUBBLOCK)
 290         return BitstreamEntry::getSubBlock(ReadSubBlockID());
 291
 292       if (Code == bitc::DEFINE_ABBREV &&
 293           !(Flags & AF_DontAutoprocessAbbrevs)) {
 294         // We read and accumulate abbrev's, the client can't do anything with
 295         // them anyway.
 296         ReadAbbrevRecord();
 297         continue;
 298       }
 299
 300       return BitstreamEntry::getRecord(Code);
 301     }
 302   }
 303
 304   /// advanceSkippingSubblocks - This is a convenience function for clients that
 305   /// don't expect any subblocks.  This just skips over them automatically.
 306   BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
 307     while (1) {
 308       // If we found a normal entry, return it.
 309       BitstreamEntry Entry = advance(Flags);
 310       if (Entry.Kind != BitstreamEntry::SubBlock)
 311         return Entry;
 312
 313       // If we found a sub-block, just skip over it and check the next entry.
 314       if (SkipBlock())
 315         return BitstreamEntry::getError();
 316     }
 317   }
 318
 319   /// JumpToBit - Reset the stream to the specified bit number.
 320   void JumpToBit(uint64_t BitNo) {
 321     uintptr_t ByteNo = uintptr_t(BitNo/8) & ~3;
 322     uintptr_t WordBitNo = uintptr_t(BitNo) & 31;
 323     assert(canSkipToPos(ByteNo) && "Invalid location");
 324
 325     // Move the cursor to the right word.
 326     NextChar = ByteNo;
 327     BitsInCurWord = 0;
 328     CurWord = 0;
 329
 330     // Skip over any bits that are already consumed.
 331     if (WordBitNo)
 332       Read(static_cast<unsigned>(WordBitNo));
 333   }
 334
 335
 336   uint32_t Read(unsigned NumBits) {
 337     assert(NumBits <= 32 && "Cannot return more than 32 bits!");
 338     // If the field is fully contained by CurWord, return it quickly.
 339     if (BitsInCurWord >= NumBits) {
 340       uint32_t R = CurWord & ((1U << NumBits)-1);
 341       CurWord >>= NumBits;
 342       BitsInCurWord -= NumBits;
 343       return R;
 344     }
 345
 346     // If we run out of data, stop at the end of the stream.
 347     if (isEndPos(NextChar)) {
 348       CurWord = 0;
 349       BitsInCurWord = 0;
 350       return 0;
 351     }
 352
 353     unsigned R = CurWord;
 354
 355     // Read the next word from the stream.
 356     CurWord = getWord(NextChar);
 357     NextChar += 4;
 358
 359     // Extract NumBits-BitsInCurWord from what we just read.
 360     unsigned BitsLeft = NumBits-BitsInCurWord;
 361
 362     // Be careful here, BitsLeft is in the range [1..32] inclusive.
 363     R |= (CurWord & (~0U >> (32-BitsLeft))) << BitsInCurWord;
 364
 365     // BitsLeft bits have just been used up from CurWord.
 366     if (BitsLeft != 32)
 367       CurWord >>= BitsLeft;
 368     else
 369       CurWord = 0;
 370     BitsInCurWord = 32-BitsLeft;
 371     return R;
 372   }
 373
 374   uint64_t Read64(unsigned NumBits) {
 375     if (NumBits <= 32) return Read(NumBits);
 376
 377     uint64_t V = Read(32);
 378     return V | (uint64_t)Read(NumBits-32) << 32;
 379   }
 380
 381   uint32_t ReadVBR(unsigned NumBits) {
 382     uint32_t Piece = Read(NumBits);
 383     if ((Piece & (1U << (NumBits-1))) == 0)
 384       return Piece;
 385
 386     uint32_t Result = 0;
 387     unsigned NextBit = 0;
 388     while (1) {
 389       Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
 390
 391       if ((Piece & (1U << (NumBits-1))) == 0)
 392         return Result;
 393
 394       NextBit += NumBits-1;
 395       Piece = Read(NumBits);
 396     }
 397   }
 398
 399   // ReadVBR64 - Read a VBR that may have a value up to 64-bits in size.  The
 400   // chunk size of the VBR must still be <= 32 bits though.
 401   uint64_t ReadVBR64(unsigned NumBits) {
 402     uint32_t Piece = Read(NumBits);
 403     if ((Piece & (1U << (NumBits-1))) == 0)
 404       return uint64_t(Piece);
 405
 406     uint64_t Result = 0;
 407     unsigned NextBit = 0;
 408     while (1) {
 409       Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
 410
 411       if ((Piece & (1U << (NumBits-1))) == 0)
 412         return Result;
 413
 414       NextBit += NumBits-1;
 415       Piece = Read(NumBits);
 416     }
 417   }
 418
 419   void SkipToFourByteBoundary() {
 420     BitsInCurWord = 0;
 421     CurWord = 0;
 422   }
 423
 424   unsigned ReadCode() {
 425     return Read(CurCodeSize);
 426   }
 427
 428
 429   // Block header:
 430   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
 431
 432   /// ReadSubBlockID - Having read the ENTER_SUBBLOCK code, read the BlockID for
 433   /// the block.
 434   unsigned ReadSubBlockID() {
 435     return ReadVBR(bitc::BlockIDWidth);
 436   }
 437
 438   /// SkipBlock - Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip
 439   /// over the body of this block.  If the block record is malformed, return
 440   /// true.
 441   bool SkipBlock() {
 442     // Read and ignore the codelen value.  Since we are skipping this block, we
 443     // don't care what code widths are used inside of it.
 444     ReadVBR(bitc::CodeLenWidth);
 445     SkipToFourByteBoundary();
 446     unsigned NumWords = Read(bitc::BlockSizeWidth);
 447
 448     // Check that the block wasn't partially defined, and that the offset isn't
 449     // bogus.
 450     size_t SkipTo = NextChar + NumWords*4;
 451     if (AtEndOfStream() || !canSkipToPos(SkipTo))
 452       return true;
 453
 454     NextChar = SkipTo;
 455     return false;
 456   }
 457
 458   /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
 459   /// the block, and return true if the block has an error.
 460   bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = 0);
 461
 462   bool ReadBlockEnd() {
 463     if (BlockScope.empty()) return true;
 464
 465     // Block tail:
 466     //    [END_BLOCK, <align4bytes>]
 467     SkipToFourByteBoundary();
 468
 469     popBlockScope();
 470     return false;
 471   }
 472
 473 private:
 474
 475   void popBlockScope() {
 476     CurCodeSize = BlockScope.back().PrevCodeSize;
 477
 478     // Delete abbrevs from popped scope.
 479     for (unsigned i = 0, e = static_cast<unsigned>(CurAbbrevs.size());
 480          i != e; ++i)
 481       CurAbbrevs[i]->dropRef();
 482
 483     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
 484     BlockScope.pop_back();
 485   }
 486
 487   //===--------------------------------------------------------------------===//
 488   // Record Processing
 489   //===--------------------------------------------------------------------===//
 490
 491 private:
 492   void readAbbreviatedLiteral(const BitCodeAbbrevOp &Op,
 493                               SmallVectorImpl<uint64_t> &Vals);
 494   void readAbbreviatedField(const BitCodeAbbrevOp &Op,
 495                             SmallVectorImpl<uint64_t> &Vals);
 496   void skipAbbreviatedField(const BitCodeAbbrevOp &Op);
 497
 498 public:
 499
 500   /// getAbbrev - Return the abbreviation for the specified AbbrevId.
 501   const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
 502     unsigned AbbrevNo = AbbrevID-bitc::FIRST_APPLICATION_ABBREV;
 503     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
 504     return CurAbbrevs[AbbrevNo];
 505   }
 506
 507   /// skipRecord - Read the current record and discard it.
 508   void skipRecord(unsigned AbbrevID);
 509
 510   unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
 511                       StringRef *Blob = 0);
 512
 513   //===--------------------------------------------------------------------===//
 514   // Abbrev Processing
 515   //===--------------------------------------------------------------------===//
 516   void ReadAbbrevRecord();
 517
 518   bool ReadBlockInfoBlock();
 519 };
 520
 521 } // End llvm namespace
 522
 523 #endif