Make a major API change to BitstreamReader: split all the reading

state out of the BitstreamReader class into a BitstreamCursor class.
Doing this allows the client to have multiple cursors into the same
file, each with potentially different live block stacks and
abbreviation records.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@70157 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 141 insertions, 110 deletions

diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h
index 7ff4e26..ae18f2c 100644
--- a/include/llvm/Bitcode/BitstreamReader.h
+++ b/include/llvm/Bitcode/BitstreamReader.h
@@ -24,72 +24,144 @@ namespace llvm {
   class Deserializer;
 
 class BitstreamReader {
-  const unsigned char *NextChar;
-  const unsigned char *LastChar;
-  friend class Deserializer;
+public:
+  /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
+  /// These describe abbreviations that all blocks of the specified ID inherit.
+  struct BlockInfo {
+    unsigned BlockID;
+    std::vector<BitCodeAbbrev*> Abbrevs;
+  };
+private:
+  /// FirstChar/LastChar - This remembers the first and last bytes of the
+  /// stream.
+  const unsigned char *FirstChar, *LastChar;
+  
+  std::vector<BlockInfo> BlockInfoRecords;
+
+public:
+  BitstreamReader() : FirstChar(0), LastChar(0) {
+  }
+
+  BitstreamReader(const unsigned char *Start, const unsigned char *End) {
+    init(Start, End);
+  }
+
+  void init(const unsigned char *Start, const unsigned char *End) {
+    FirstChar = Start;
+    LastChar = End;
+    assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
+  }
+
+  ~BitstreamReader() {
+    // Free the BlockInfoRecords.
+    while (!BlockInfoRecords.empty()) {
+      BlockInfo &Info = BlockInfoRecords.back();
+      // Free blockinfo abbrev info.
+      for (unsigned i = 0, e = static_cast<unsigned>(Info.Abbrevs.size());
+           i != e; ++i)
+        Info.Abbrevs[i]->dropRef();
+      BlockInfoRecords.pop_back();
+    }
+  }
+  
+  const unsigned char *getFirstChar() const { return FirstChar; }
+  const unsigned char *getLastChar() const { return LastChar; }
+
+  //===--------------------------------------------------------------------===//
+  // Block Manipulation
+  //===--------------------------------------------------------------------===//
+
+  /// getBlockInfo - If there is block info for the specified ID, return it,
+  /// otherwise return null.
+  BlockInfo *getBlockInfo(unsigned BlockID) {
+    // Common case, the most recent entry matches BlockID.
+    if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
+      return &BlockInfoRecords.back();
+
+    for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
+         i != e; ++i)
+      if (BlockInfoRecords[i].BlockID == BlockID)
+        return &BlockInfoRecords[i];
+    return 0;
+  }
 
+  BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
+    if (BlockInfo *BI = getBlockInfo(BlockID))
+      return *BI;
+
+    // Otherwise, add a new record.
+    BlockInfoRecords.push_back(BlockInfo());
+    BlockInfoRecords.back().BlockID = BlockID;
+    return BlockInfoRecords.back();
+  }
+
+};
+
+class BitstreamCursor {
+  friend class Deserializer;
+  BitstreamReader *BitStream;
+  const unsigned char *NextChar;
+  
   /// CurWord - This is the current data we have pulled from the stream but have
   /// not returned to the client.
   uint32_t CurWord;
-
+  
   /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
   /// is always from [0...31] inclusive.
   unsigned BitsInCurWord;
-
+  
   // CurCodeSize - This is the declared size of code values used for the current
   // block, in bits.
   unsigned CurCodeSize;
-
+  
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<BitCodeAbbrev*> CurAbbrevs;
-
+  
   struct Block {
     unsigned PrevCodeSize;
     std::vector<BitCodeAbbrev*> PrevAbbrevs;
     explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
   };
-
+  
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
-
-  /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
-  /// These describe abbreviations that all blocks of the specified ID inherit.
-  struct BlockInfo {
-    unsigned BlockID;
-    std::vector<BitCodeAbbrev*> Abbrevs;
-  };
-  std::vector<BlockInfo> BlockInfoRecords;
-
-  /// FirstChar - This remembers the first byte of the stream.
-  const unsigned char *FirstChar;
+  
+  BitstreamCursor(const BitstreamCursor&); // NOT YET IMPLEMENTED.
+  void operator=(const BitstreamCursor&);  // NOT YET IMPLEMENTED.
 public:
-  BitstreamReader() {
-    NextChar = FirstChar = LastChar = 0;
+  BitstreamCursor() : BitStream(0), NextChar(0) {
+  }
+  explicit BitstreamCursor(BitstreamReader &R) : BitStream(&R) {
+    NextChar = R.getFirstChar();
+    assert(NextChar && "Bitstream not initialized yet");
     CurWord = 0;
     BitsInCurWord = 0;
-    CurCodeSize = 0;
-  }
-
-  BitstreamReader(const unsigned char *Start, const unsigned char *End) {
-    init(Start, End);
+    CurCodeSize = 2;
   }
-
-  void init(const unsigned char *Start, const unsigned char *End) {
-    NextChar = FirstChar = Start;
-    LastChar = End;
-    assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
+  
+  void init(BitstreamReader &R) {
+    freeState();
+    
+    BitStream = &R;
+    NextChar = R.getFirstChar();
+    assert(NextChar && "Bitstream not initialized yet");
     CurWord = 0;
     BitsInCurWord = 0;
     CurCodeSize = 2;
   }
-
-  ~BitstreamReader() {
-    // Abbrevs could still exist if the stream was broken.  If so, don't leak
-    // them.
+  
+  ~BitstreamCursor() {
+    freeState();
+  }
+  
+  void freeState() {
+    // Free all the Abbrevs.
     for (unsigned i = 0, e = static_cast<unsigned>(CurAbbrevs.size());
          i != e; ++i)
       CurAbbrevs[i]->dropRef();
-
+    CurAbbrevs.clear();
+    
+    // Free all the Abbrevs in the block scope.
     for (unsigned S = 0, e = static_cast<unsigned>(BlockScope.size());
          S != e; ++S) {
       std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
@@ -97,47 +169,41 @@ public:
            i != e; ++i)
         Abbrevs[i]->dropRef();
     }
-
-    // Free the BlockInfoRecords.
-    while (!BlockInfoRecords.empty()) {
-      BlockInfo &Info = BlockInfoRecords.back();
-      // Free blockinfo abbrev info.
-      for (unsigned i = 0, e = static_cast<unsigned>(Info.Abbrevs.size());
-           i != e; ++i)
-        Info.Abbrevs[i]->dropRef();
-      BlockInfoRecords.pop_back();
-    }
+    BlockScope.clear();
   }
-
+  
+  /// GetAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
+  unsigned GetAbbrevIDWidth() const { return CurCodeSize; }
+  
   bool AtEndOfStream() const {
-    return NextChar == LastChar && BitsInCurWord == 0;
+    return NextChar == BitStream->getLastChar() && BitsInCurWord == 0;
   }
-
+  
   /// GetCurrentBitNo - Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
-    return (NextChar-FirstChar)*CHAR_BIT - BitsInCurWord;
+    return (NextChar-BitStream->getFirstChar())*CHAR_BIT - BitsInCurWord;
   }
-
+  
+  
   /// JumpToBit - Reset the stream to the specified bit number.
   void JumpToBit(uint64_t BitNo) {
     uintptr_t ByteNo = uintptr_t(BitNo/8) & ~3;
     uintptr_t WordBitNo = uintptr_t(BitNo) & 31;
-    assert(ByteNo <= (uintptr_t)(LastChar-FirstChar) && "Invalid location");
-
+    assert(ByteNo <= (uintptr_t)(BitStream->getLastChar()-
+                                 BitStream->getFirstChar()) &&
+           "Invalid location");
+    
     // Move the cursor to the right word.
-    NextChar = FirstChar+ByteNo;
+    NextChar = BitStream->getFirstChar()+ByteNo;
     BitsInCurWord = 0;
     CurWord = 0;
-
+    
     // Skip over any bits that are already consumed.
-    if (WordBitNo) {
+    if (WordBitNo)
       Read(static_cast<unsigned>(WordBitNo));
-    }
   }
-
-  /// GetAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
-  unsigned GetAbbrevIDWidth() const { return CurCodeSize; }
-
+  
+  
   uint32_t Read(unsigned NumBits) {
     // If the field is fully contained by CurWord, return it quickly.
     if (BitsInCurWord >= NumBits) {
@@ -148,7 +214,7 @@ public:
     }
 
     // If we run out of data, stop at the end of the stream.
-    if (NextChar == LastChar) {
+    if (NextChar == BitStream->getLastChar()) {
       CurWord = 0;
       BitsInCurWord = 0;
       return 0;
@@ -224,31 +290,10 @@ public:
     CurWord = 0;
   }
 
-
   unsigned ReadCode() {
     return Read(CurCodeSize);
   }
 
-  //===--------------------------------------------------------------------===//
-  // Block Manipulation
-  //===--------------------------------------------------------------------===//
-
-private:
-  /// getBlockInfo - If there is block info for the specified ID, return it,
-  /// otherwise return null.
-  BlockInfo *getBlockInfo(unsigned BlockID) {
-    // Common case, the most recent entry matches BlockID.
-    if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
-      return &BlockInfoRecords.back();
-
-    for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
-         i != e; ++i)
-      if (BlockInfoRecords[i].BlockID == BlockID)
-        return &BlockInfoRecords[i];
-    return 0;
-  }
-public:
-
 
   // Block header:
   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
@@ -271,7 +316,7 @@ public:
 
     // Check that the block wasn't partially defined, and that the offset isn't
     // bogus.
-    if (AtEndOfStream() || NextChar+NumWords*4 > LastChar)
+    if (AtEndOfStream() || NextChar+NumWords*4 > BitStream->getLastChar())
       return true;
 
     NextChar += NumWords*4;
@@ -286,7 +331,7 @@ public:
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
 
     // Add the abbrevs specific to this block to the CurAbbrevs list.
-    if (BlockInfo *Info = getBlockInfo(BlockID)) {
+    if (BitstreamReader::BlockInfo *Info = BitStream->getBlockInfo(BlockID)) {
       for (unsigned i = 0, e = static_cast<unsigned>(Info->Abbrevs.size());
            i != e; ++i) {
         CurAbbrevs.push_back(Info->Abbrevs[i]);
@@ -301,7 +346,8 @@ public:
     if (NumWordsP) *NumWordsP = NumWords;
 
     // Validate that this block is sane.
-    if (CurCodeSize == 0 || AtEndOfStream() || NextChar+NumWords*4 > LastChar)
+    if (CurCodeSize == 0 || AtEndOfStream() ||
+        NextChar+NumWords*4 > BitStream->getLastChar())
       return true;
 
     return false;
@@ -331,7 +377,7 @@ private:
     BlockScope.pop_back();
   }
 
-  //===--------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
   // Record Processing
   //===--------------------------------------------------------------------===//
 
@@ -407,9 +453,9 @@ public:
         
         // If this would read off the end of the bitcode file, just set the
         // record to empty and return.
-        if (NewEnd > LastChar) {
+        if (NewEnd > BitStream->getLastChar()) {
           Vals.append(NumElts, 0);
-          NextChar = LastChar;
+          NextChar = BitStream->getLastChar();
           break;
         }
         
@@ -462,29 +508,14 @@ public:
     }
     CurAbbrevs.push_back(Abbv);
   }
-
-  //===--------------------------------------------------------------------===//
-  // BlockInfo Block Reading
-  //===--------------------------------------------------------------------===//
-
-private:
-  BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
-    if (BlockInfo *BI = getBlockInfo(BlockID))
-      return *BI;
-
-    // Otherwise, add a new record.
-    BlockInfoRecords.push_back(BlockInfo());
-    BlockInfoRecords.back().BlockID = BlockID;
-    return BlockInfoRecords.back();
-  }
-
+  
 public:
 
   bool ReadBlockInfoBlock() {
     if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true;
 
     SmallVector<uint64_t, 64> Record;
-    BlockInfo *CurBlockInfo = 0;
+    BitstreamReader::BlockInfo *CurBlockInfo = 0;
 
     // Read all the records for this module.
     while (1) {
@@ -516,13 +547,13 @@ public:
       default: break;  // Default behavior, ignore unknown content.
       case bitc::BLOCKINFO_CODE_SETBID:
         if (Record.size() < 1) return true;
-        CurBlockInfo = &getOrCreateBlockInfo((unsigned)Record[0]);
+        CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]);
         break;
       }
     }
   }
 };
-
+  
 } // End llvm namespace
 
 #endif
diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h
index cc85d9f..3e90227 100644
--- a/include/llvm/Bitcode/Deserialize.h
+++ b/include/llvm/Bitcode/Deserialize.h
@@ -116,7 +116,7 @@ public:
   //===----------------------------------------------------------===//
 
 private:
-  BitstreamReader& Stream;
+  BitstreamCursor Stream;
   SmallVector<uint64_t,20> Record;
   unsigned RecIdx;
   BumpPtrAllocator Allocator;
@@ -482,7 +482,7 @@ public:
 
   unsigned getRecordCode();
 
-  BitstreamReader& getStream() { return Stream; }
+  BitstreamCursor &getStream() { return Stream; }
 
 private:
   bool AdvanceStream();