Fix the block stack used by the bitstream cursor.

lib/Bitcode/NaCl/Reader/NaClBitstreamReader.cpp

 //===- NaClBitstreamReader.cpp --------------------------------------------===//
 //     NaClBitstreamReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 36 matching lines @@
 Fatal(const std::string &ErrorMessage) const {
   // Default implementation is simply print message, and the bit where
   // the error occurred.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   naclbitc::ErrorAt(StrBuf, naclbitc::Fatal, Cursor.GetCurrentBitNo())
       << ErrorMessage;
   report_fatal_error(StrBuf.str());
 }
 
-void NaClBitstreamCursor::freeState() {
-  // Free all the Abbrevs.
-  for (size_t i = 0, e = CurAbbrevs.size(); i != e; ++i)
-    CurAbbrevs[i]->dropRef();
-  CurAbbrevs.clear();
-
-  // Free all the Abbrevs in the block scope.
-  for (size_t S = 0, e = BlockScope.size(); S != e; ++S) {
-    std::vector<NaClBitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
-    for (size_t i = 0, e = Abbrevs.size(); i != e; ++i)
-      Abbrevs[i]->dropRef();
-  }
-  BlockScope.clear();
-}
-
 void NaClBitstreamCursor::reportInvalidAbbrevNumber(unsigned AbbrevNo) const {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid abbreviation # " << AbbrevNo << " defined for record";
   ErrHandler->Fatal(StrBuf.str());
 }
 
 void NaClBitstreamCursor::reportInvalidJumpToBit(uint64_t BitNo) const {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid jump to bit " << BitNo;
   ErrHandler->Fatal(StrBuf.str());
 }
 
 /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
 /// the block, and return true if the block has an error.
 bool NaClBitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) {
-  // Save the current block's state on BlockScope.
-  BlockScope.push_back(Block(CurCodeSize));
-  BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
-
-  // Add the abbrevs specific to this block to the CurAbbrevs list.
-  if (const NaClBitstreamReader::BlockInfo *Info =
-      BitStream->getBlockInfo(BlockID)) {
-    for (size_t i = 0, e = Info->Abbrevs.size(); i != e; ++i) {
-      CurAbbrevs.push_back(Info->Abbrevs[i]);
-      CurAbbrevs.back()->addRef();
-    }
-  }
-
-  // Get the codesize of this block.
-  CurCodeSize.IsFixed = true;
-  CurCodeSize.NumBits = ReadVBR(naclbitc::CodeLenWidth);
+  const bool IsFixed = true;
+  NaClBitcodeSelectorAbbrev
+      CodeAbbrev(IsFixed, ReadVBR(naclbitc::CodeLenWidth));
+  BlockScope.push_back(Block(&BitStream->getOrCreateBlockInfo(BlockID),
+                             CodeAbbrev));
   SkipToFourByteBoundary();
   unsigned NumWords = Read(naclbitc::BlockSizeWidth);
   if (NumWordsP) *NumWordsP = NumWords;
 
   // Validate that this block is sane.
-  if (CurCodeSize.NumBits == 0 || AtEndOfStream())
+  if (BlockScope.back().getCodeAbbrev().NumBits == 0 || AtEndOfStream())
     return true;
 
   return false;
 }
 
 void NaClBitstreamCursor::skipAbbreviatedField(const NaClBitCodeAbbrevOp &Op) {
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case NaClBitCodeAbbrevOp::Literal:
     // No read necessary for literal.
@@ skipping 154 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Invalid abbreviation encoding specified in bitcode file: "
            << Value;
     ErrHandler->Fatal(StrBuf.str());
   }
   return NaClBitCodeAbbrevOp::Encoding(Value);
 }
 
 void NaClBitstreamCursor::ReadAbbrevRecord(bool IsLocal,
                                            NaClAbbrevListener *Listener) {
-  NaClBitCodeAbbrev *Abbv = new NaClBitCodeAbbrev();
+  NaClBitCodeAbbrev *Abbv = BlockScope.back().appendLocalCreate();
   unsigned NumOpInfo = ReadVBR(5);
   if (Listener) Listener->Values.push_back(NumOpInfo);
   for (unsigned i = 0; i != NumOpInfo; ++i) {
     bool IsLiteral = Read(1) ? true : false;
     if (Listener) Listener->Values.push_back(IsLiteral);
     if (IsLiteral) {
       uint64_t Value = ReadVBR64(8);
       if (Listener) Listener->Values.push_back(Value);
       Abbv->Add(NaClBitCodeAbbrevOp(Value));
       continue;
@@ skipping 29 matching lines @@
         StrBuf << "Invalid abbreviation encoding ("
                << NaClBitCodeAbbrevOp::getEncodingName(E) << ")";
         ErrHandler->Fatal(StrBuf.str());
       }
       Abbv->Add(NaClBitCodeAbbrevOp(E));
     }
   }
   SkipToByteBoundaryIfAligned();
   if (!Abbv->isValid())
     ErrHandler->Fatal("Invalid abbreviation specified in bitcode file");
-  CurAbbrevs.push_back(Abbv);
   if (Listener) {
     Listener->ProcessAbbreviation(Abbv, IsLocal);
     // Reset record information of the listener.
     Listener->Values.clear();
     Listener->StartBit = GetCurrentBitNo();
   }
 }
 
 void NaClBitstreamCursor::SkipAbbrevRecord() {
   unsigned NumOpInfo = ReadVBR(5);
   for (unsigned i = 0; i != NumOpInfo; ++i) {
     bool IsLiteral = Read(1) ? true : false;
     if (IsLiteral) {
       ReadVBR64(8);
       continue;
     }
     NaClBitCodeAbbrevOp::Encoding E = getEncoding(Read(3));
     if (NaClBitCodeAbbrevOp::hasValue(E)) {
       ReadVBR64(5);
     }
   }
   SkipToByteBoundaryIfAligned();
 }
 
 bool NaClBitstreamCursor::ReadBlockInfoBlock(NaClAbbrevListener *Listener) {
   // If this is the second stream to get to the block info block, skip it.
-  if (BitStream->hasBlockInfoRecords())
+  if (BitStream->HasReadBlockInfoBlock)
     return SkipBlock();
 
+  BitStream->HasReadBlockInfoBlock = true;
+
   unsigned NumWords;
   if (EnterSubBlock(naclbitc::BLOCKINFO_BLOCK_ID, &NumWords)) return true;
 
   if (Listener) Listener->BeginBlockInfoBlock(NumWords);
 
   NaClBitcodeRecordVector Record;
-  NaClBitstreamReader::BlockInfo *CurBlockInfo = 0;
+  Block &CurBlock = BlockScope.back();
+  NaClBitstreamReader::AbbrevList *UpdateAbbrevs =
+      &CurBlock.GlobalAbbrevs->getAbbrevs();
+  bool FoundSetBID = false;
 
   // Read records of the BlockInfo block.
   while (1) {
     if (Listener) Listener->StartBit = GetCurrentBitNo();
     NaClBitstreamEntry Entry = advance(AF_DontAutoprocessAbbrevs, Listener);
 
     switch (Entry.Kind) {
     case llvm::NaClBitstreamEntry::SubBlock:  // PNaCl doesn't allow!
     case llvm::NaClBitstreamEntry::Error:
       return true;
     case llvm::NaClBitstreamEntry::EndBlock:
       if (Listener) Listener->EndBlockInfoBlock();
       return false;
     case llvm::NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read abbrev records, associate them with CurBID.
     if (Entry.ID == naclbitc::DEFINE_ABBREV) {
-      if (!CurBlockInfo) return true;
       ReadAbbrevRecord(false, Listener);
 
-      // ReadAbbrevRecord installs the abbrev in CurAbbrevs.  Move it to the
-      // appropriate BlockInfo.
-      NaClBitCodeAbbrev *Abbv = CurAbbrevs.back();
-      CurAbbrevs.pop_back();
-      CurBlockInfo->Abbrevs.push_back(Abbv);
+      // ReadAbbrevRecord installs a local abbreviation.  Move it to the
+      // appropriate BlockInfo if the corresponding SetBID record has been
+      // found.
+      if (FoundSetBID)
+        CurBlock.moveLocalAbbrevToAbbrevList(UpdateAbbrevs);
       continue;
     }
 
     // Read a record.
     Record.clear();
     switch (readRecord(Entry.ID, Record)) {
       default: 
         // No other records should be found!
         return true;
       case naclbitc::BLOCKINFO_CODE_SETBID:
         if (Record.size() < 1) return true;
-        CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]);
+        FoundSetBID = true;
+        UpdateAbbrevs =
+            &BitStream->getOrCreateBlockInfo((unsigned)Record[0]).getAbbrevs();
         if (Listener) {
           Listener->Values = Record;
           Listener->SetBID();
         }
         break;
     }
   }
 }