Fix abbreviation handling in munged bitcode writer.

include/llvm/Bitcode/NaCl/NaClBitstreamWriter.h

 //===- NaClBitstreamWriter.h - NaCl bitstream writer ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header defines the BitstreamWriter class.  This class can be used to
@@ skipping 26 matching lines @@
   NaClBitcodeSelectorAbbrev CurCodeSize;
 
   /// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
   /// selected BLOCK ID.
   unsigned BlockInfoCurBID;
 
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<NaClBitCodeAbbrev*> CurAbbrevs;
 
   struct Block {
-    NaClBitcodeSelectorAbbrev PrevCodeSize;
-    unsigned StartSizeWord;
+    const NaClBitcodeSelectorAbbrev PrevCodeSize;
+    const unsigned StartSizeWord;
     std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
-    Block(const NaClBitcodeSelectorAbbrev& PCS, unsigned SSW)
-        : PrevCodeSize(PCS), StartSizeWord(SSW) {}
+    const unsigned AbbreviationIndexLimit;
+    Block(const NaClBitcodeSelectorAbbrev& PCS, unsigned SSW,
+          unsigned AbbreviationIndexLimit)
+        : PrevCodeSize(PCS), StartSizeWord(SSW),
+          AbbreviationIndexLimit(AbbreviationIndexLimit) {}
   };
 
   /// BlockScope - This tracks the current blocks that we have entered.
   std::vector<Block> 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<NaClBitCodeAbbrev*> Abbrevs;
@@ skipping 89 matching lines @@
   /// \brief Returns the maximum abbreviation index allowed for the
   /// current block.
   size_t getMaxCurAbbrevIndex() const {
     return CurAbbrevs.size() + naclbitc::DEFAULT_MAX_ABBREV;
   }
 
   //===--------------------------------------------------------------------===//
   // Basic Primitives for emitting bits to the stream.
   //===--------------------------------------------------------------------===//
 
+  // Max Number of bits that can be written using Emit.
+  static const unsigned MaxEmitNumBits = 32;
+
   void Emit(uint32_t Val, unsigned NumBits) {
-    assert(NumBits && NumBits <= 32 && "Invalid value size!");
-    assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!");
+    assert(NumBits && NumBits <= MaxEmitNumBits && "Invalid value size!");
+    assert((Val &
+            ~(~0U >> (MaxEmitNumBits-NumBits))) == 0 && "High bits set!");
     CurValue |= Val << CurBit;
-    if (CurBit + NumBits < 32) {
+    if (CurBit + NumBits < MaxEmitNumBits) {
       CurBit += NumBits;
       return;
     }
 
     // Add the current word.
     WriteWord(CurValue);
 
     if (CurBit)
-      CurValue = Val >> (32-CurBit);
+      CurValue = Val >> (MaxEmitNumBits-CurBit);
     else
       CurValue = 0;
-    CurBit = (CurBit+NumBits) & 31;
+    CurBit = (CurBit+NumBits) & (MaxEmitNumBits-1);
   }
 
   void Emit64(uint64_t Val, unsigned NumBits) {
-    if (NumBits <= 32)
-      Emit((uint32_t)Val, NumBits);
-    else {
-      Emit((uint32_t)Val, 32);
-      Emit((uint32_t)(Val >> 32), NumBits-32);
+    while (NumBits > MaxEmitNumBits) {
+      Emit((uint32_t)Val, MaxEmitNumBits);
+      Val >>= MaxEmitNumBits;
+      NumBits -= MaxEmitNumBits;
     }
+    Emit((uint32_t)Val, NumBits);
   }
 
   void flushToByte() {
     unsigned BitsToFlush = (32 - CurBit) % CHAR_BIT;
     if (BitsToFlush)
       Emit(0, BitsToFlush);
   }
 
   void flushToByteIfAligned() {
     if (AlignBitcodeRecords)
@@ skipping 83 matching lines @@
     unsigned BlockSizeWordIndex = GetWordIndex();
     NaClBitcodeSelectorAbbrev OldCodeSize(CurCodeSize);
 
     // Emit a placeholder, which will be replaced when the block is popped.
     Emit(0, naclbitc::BlockSizeWidth);
 
     CurCodeSize = CodeLen;
 
     // Push the outer block's abbrev set onto the stack, start out with an
     // empty abbrev set.
-    BlockScope.push_back(Block(OldCodeSize, BlockSizeWordIndex));
+    BlockScope.push_back(Block(OldCodeSize, BlockSizeWordIndex,
+                               1 << CodeLen.NumBits));
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
 
     // If there is a blockinfo for this BlockID, add all the predefined abbrevs
     // to the abbrev list.
     if (Info) {
       for (unsigned i = 0, e = static_cast<unsigned>(Info->Abbrevs.size());
            i != e; ++i) {
         CurAbbrevs.push_back(Info->Abbrevs[i]);
         Info->Abbrevs[i]->addRef();
       }
@@ skipping 81 matching lines @@
       Emit(NaClBitCodeAbbrevOp::EncodeChar6((char)V), 6);
       break;
     }
   }
 
   /// EmitRecordWithAbbrevImpl - This is the core implementation of the record
   /// emission code.
   template<typename uintty>
   void EmitRecordWithAbbrevImpl(unsigned Abbrev,
                                 const AbbrevValues<uintty> &Vals) {
-    unsigned AbbrevNo = Abbrev-naclbitc::FIRST_APPLICATION_ABBREV;
-    assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
-    NaClBitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
+    const NaClBitCodeAbbrev *Abbv = getAbbreviation(Abbrev);
+    assert(Abbv && "Abbreviation index is invalid");
 
     EmitCode(Abbrev);
 
     unsigned RecordIdx = 0;
     for (unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
          i != e; ++i) {
       const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
       if (Op.getEncoding() == NaClBitCodeAbbrevOp::Array) {
         // Array case.
         assert(i+2 == e && "array op not second to last?");
         const NaClBitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
 
         // Emit a vbr6 to indicate the number of elements present.
         EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
 
         // Emit each field.
         for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
           EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
       } else {
         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
         EmitAbbreviatedField(Op, Vals[RecordIdx]);
         ++RecordIdx;
       }
     }
     assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
   }
 
 public:
 
-  /// Returns true if the given abbreviation index corresponds to a user-defined
-  /// abbreviation.
-  bool isUserRecordAbbreviation(unsigned Abbrev) const {
-    return Abbrev >= naclbitc::FIRST_APPLICATION_ABBREV
-        && Abbrev < (CurAbbrevs.size() + naclbitc::FIRST_APPLICATION_ABBREV);
+  /// Returns a pointer to the abbreviation currently associated with
+  /// the abbreviation index. Returns nullptr if no such abbreviation.
+  const NaClBitCodeAbbrev *getAbbreviation(unsigned Index) const {
+    if (Index < naclbitc::FIRST_APPLICATION_ABBREV)
+      return nullptr;
+    if (Index >= BlockScope.back().AbbreviationIndexLimit)
+      return nullptr;
+    unsigned AbbrevNo = Index - naclbitc::FIRST_APPLICATION_ABBREV;
+    if (AbbrevNo >= CurAbbrevs.size())
+      return nullptr;
+    return CurAbbrevs[AbbrevNo];
   }
 
   /// EmitRecord - Emit the specified record to the stream, using an abbrev if
   /// we have one to compress the output.
   template<typename uintty>
   void EmitRecord(unsigned Code, const SmallVectorImpl<uintty> &Vals,
                   unsigned Abbrev = 0) {
     if (!Abbrev) {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
@@ skipping 92 matching lines @@
     Info.Abbrevs.push_back(Abbv);
 
     return Info.Abbrevs.size()-1+naclbitc::FIRST_APPLICATION_ABBREV;
   }
 };
 
 
 } // End llvm namespace
 
 #endif