Make abbreviations explicit in pnacl-freeze/thaw.

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
 //     Low-level bitstream reader interface
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 153 matching lines @@
 /// file.  There may be multiple independent cursors reading within
 /// one bitstream, each maintaining their own local state.
 ///
 /// Unlike iterators, NaClBitstreamCursors are heavy-weight objects
 /// that should not be passed by value.
 class NaClBitstreamCursor {
   friend class Deserializer;
   NaClBitstreamReader *BitStream;
   size_t NextChar;
 
-  
   /// CurWord/word_t - This is the current data we have pulled from the stream
   /// but have not returned to the client.  This is specifically and
   /// intentionally defined to follow the word size of the host machine for
   /// efficiency.  We use word_t in places that are aware of this to make it
   /// perfectly explicit what is going on.
   typedef uint32_t word_t;
   word_t CurWord;
 
   /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
   /// is always from [0...31/63] inclusive (depending on word size).
   unsigned BitsInCurWord;
 
   // CurCodeSize - This is the declared size of code values used for the current
   // block, in bits.
-  unsigned CurCodeSize;
+  NaClBitcodeSelectorAbbrev CurCodeSize;
 
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<NaClBitCodeAbbrev*> CurAbbrevs;
 
   struct Block {
-    unsigned PrevCodeSize;
+    NaClBitcodeSelectorAbbrev PrevCodeSize;
     std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
-    explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
+    explicit Block() : PrevCodeSize() {}
+    explicit Block(const NaClBitcodeSelectorAbbrev& PCS)
+        : PrevCodeSize(PCS) {}
   };
 
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
-  
 public:
   NaClBitstreamCursor() : BitStream(0), NextChar(0) {
   }
   NaClBitstreamCursor(const NaClBitstreamCursor &RHS)
       : BitStream(0), NextChar(0) {
     operator=(RHS);
   }
 
   explicit NaClBitstreamCursor(NaClBitstreamReader &R) : BitStream(&R) {
     NextChar = 0;
     CurWord = 0;
     BitsInCurWord = 0;
-    CurCodeSize = 2;
   }
 
   void init(NaClBitstreamReader &R) {
     freeState();
 
     BitStream = &R;
     NextChar = 0;
     CurWord = 0;
     BitsInCurWord = 0;
-    CurCodeSize = 2;
   }
 
   ~NaClBitstreamCursor() {
     freeState();
   }
 
   void operator=(const NaClBitstreamCursor &RHS);
 
   void freeState();
   
@@ skipping 11 matching lines @@
     uint8_t buf[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
     BitStream->getBitcodeBytes().readBytes(pos, sizeof(buf), buf, NULL);
     return *reinterpret_cast<support::ulittle32_t *>(buf);
   }
 
   bool AtEndOfStream() {
     return BitsInCurWord == 0 && isEndPos(NextChar);
   }
 
   /// getAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
-  unsigned getAbbrevIDWidth() const { return CurCodeSize; }
+  unsigned getAbbrevIDWidth() const { return CurCodeSize.NumBits; }
 
   /// GetCurrentBitNo - Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
     return NextChar*CHAR_BIT - BitsInCurWord;
   }
 
   NaClBitstreamReader *getBitStreamReader() {
     return BitStream;
   }
   const NaClBitstreamReader *getBitStreamReader() const {
@@ skipping 67 matching lines @@
 
     // Skip over any bits that are already consumed.
     if (WordBitNo) {
       if (sizeof(word_t) > 4)
         Read64(WordBitNo);
       else
         Read(WordBitNo);
     }
   }
 
-
   uint32_t Read(unsigned NumBits) {
     assert(NumBits && NumBits <= 32 &&
            "Cannot return zero or more than 32 bits!");
     
     // If the field is fully contained by CurWord, return it quickly.
     if (BitsInCurWord >= NumBits) {
       uint32_t R = uint32_t(CurWord) & (~0U >> (32-NumBits));
       CurWord >>= NumBits;
       BitsInCurWord -= NumBits;
       return R;
@@ skipping 78 matching lines @@
       Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
 
       if ((Piece & (1U << (NumBits-1))) == 0)
         return Result;
 
       NextBit += NumBits-1;
       Piece = Read(NumBits);
     }
   }
 
+  int32_t ReadIntVBR(unsigned NumBits) {
+    return (uint32_t) NaClDecodeSignRotatedValue(ReadVBR64(NumBits));

[jvoung (off chromium), 2013/05/21 17:24:17]

doesn't look like this readintvbr is used

[Karl, 2013/05/21 23:06:52]

Removed.

+  }
+
 private:
   void SkipToFourByteBoundary() {
     // If word_t is 64-bits and if we've read less than 32 bits, just dump
     // the bits we have up to the next 32-bit boundary.
     if (sizeof(word_t) > 4 &&
         BitsInCurWord >= 32) {
       CurWord >>= BitsInCurWord-32;
       BitsInCurWord = 32;
       return;
     }
     
     BitsInCurWord = 0;
     CurWord = 0;
   }
 public:
 
   unsigned ReadCode() {
-    return Read(CurCodeSize);
+    return CurCodeSize.IsFixed
+        ? Read(CurCodeSize.NumBits)
+        : ReadVBR(CurCodeSize.NumBits);
   }
 
-
   // Block header:
   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
 
   /// ReadSubBlockID - Having read the ENTER_SUBBLOCK code, read the BlockID for
   /// the block.
   unsigned ReadSubBlockID() {
     return ReadVBR(naclbitc::BlockIDWidth);
   }
 
   /// SkipBlock - Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip
@@ skipping 75 matching lines @@
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   void ReadAbbrevRecord();
   
   bool ReadBlockInfoBlock();
 };
 
 } // End llvm namespace
 
 #endif