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 168 matching lines @@
   /// 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;
+  int32_t CurCodeSize;

[Karl, 2013/05/17 20:52:18]

Changed to be an instance of NaClBitcodeSelectorAbrev.

 
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<NaClBitCodeAbbrev*> CurAbbrevs;
 
   struct Block {
-    unsigned PrevCodeSize;
+    int32_t PrevCodeSize;

[Karl, 2013/05/17 20:52:18]

Changed to be an instance of NaClBitcodeSelectorAbbrev.

     std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
-    explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
+    explicit Block(int32_t PCS) : PrevCodeSize(PCS) {}
   };
 
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
+  /// SignedValue - Convert unsigned to corresponding signed value,
+  /// based on the value of IsNegative.
+  int32_t SignedValue(uint32_t Val, bool IsNegative) {

[Karl, 2013/05/17 20:52:18]

Removed, no longer used.

+    int32_t Value = static_cast<int32_t>(Val);
+    return IsNegative ? -Value : Value;
+  }
   
 public:
   NaClBitstreamCursor() : BitStream(0), NextChar(0) {
   }
   NaClBitstreamCursor(const NaClBitstreamCursor &RHS)
       : BitStream(0), NextChar(0) {
     operator=(RHS);
   }
 
   explicit NaClBitstreamCursor(NaClBitstreamReader &R) : BitStream(&R) {
@@ skipping 35 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; }

[Karl, 2013/05/17 20:52:18]

return CurCodeSize -> 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 166 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) {

[jvoung (off chromium), 2013/05/14 23:47:14]

Can we just use BitcodeReader::decodeSignRotatedValue(Read...()) ?

[Karl, 2013/05/17 20:52:18]

Removed. Use NaClDecodeSignRotatedValue.

+    // Read extra bit for sign bit, and extract.
+    uint32_t Piece = Read(NumBits+1);
+    bool IsNegative = (Piece & (1U << NumBits)) == (1U << NumBits);
+    Piece &= (1U << (NumBits-1))-1;
+
+    if ((Piece & (1U << (NumBits-1))) == 0)
+      return SignedValue(Piece, IsNegative);
+
+    uint32_t Result = 0;
+    unsigned NextBit = 0;
+    while (1) {
+      Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
+
+      if ((Piece & (1U << (NumBits-1))) == 0)
+        return SignedValue(Result, IsNegative);
+
+      NextBit += NumBits-1;
+      Piece = Read(NumBits);
+    }
+  }
+
 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 < 0) ? ReadVBR(-CurCodeSize) : Read(CurCodeSize);

[Karl, 2013/05/17 20:52:18]

Changed to:
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);
@@ skipping 78 matching lines @@
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   void ReadAbbrevRecord();
   
   bool ReadBlockInfoBlock();
 };
 
 } // End llvm namespace
 
 #endif