Modify bitstream reader to allow parallel parses.

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 31 matching lines @@
 //===----------------------------------------------------------------------===//
 //  NaClBitstreamCursor implementation
 //===----------------------------------------------------------------------===//
 
 void NaClBitstreamCursor::ErrorHandler::
 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;
+  naclbitc::ErrorAt(StrBuf, naclbitc::Fatal, getCurrentBitNo()) << ErrorMessage;
   report_fatal_error(StrBuf.str());
 }
 
 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) {
   const bool IsFixed = true;
   NaClBitcodeSelectorAbbrev
       CodeAbbrev(IsFixed, ReadVBR(naclbitc::CodeLenWidth));
-  BlockScope.push_back(Block(&BitStream->getOrCreateBlockInfo(BlockID),
-                             CodeAbbrev));
+  BlockScope.push_back(Block(BitStream->getBlockInfo(BlockID), CodeAbbrev));
   SkipToFourByteBoundary();
   unsigned NumWords = Read(naclbitc::BlockSizeWidth);
   if (NumWordsP) *NumWordsP = NumWords;
 
   // Validate that this block is sane.
   if (BlockScope.back().getCodeAbbrev().NumBits == 0 || AtEndOfStream())
     return true;
 
   return false;
 }
@@ skipping 234 matching lines @@
       continue;
     }
     NaClBitCodeAbbrevOp::Encoding E = getEncoding(Read(3));
     if (NaClBitCodeAbbrevOp::hasValue(E)) {
       ReadVBR64(5);
     }
   }
   SkipToByteBoundaryIfAligned();
 }
 
+namespace {
+
+unsigned ValidBlockIDs[] = {
+  naclbitc::BLOCKINFO_BLOCK_ID,
+  naclbitc::CONSTANTS_BLOCK_ID,
+  naclbitc::FUNCTION_BLOCK_ID,
+  naclbitc::GLOBALVAR_BLOCK_ID,
+  naclbitc::MODULE_BLOCK_ID,
+  naclbitc::TOP_LEVEL_BLOCKID,
+  naclbitc::TYPE_BLOCK_ID_NEW,
+  naclbitc::VALUE_SYMTAB_BLOCK_ID
+};
+
+} // end of anonymous namespace
+
+NaClBitstreamReader::BlockInfoRecordsMap::
+BlockInfoRecordsMap() : IsFrozen(false) {
+  for (size_t BlockID : ValidBlockIDs) {
+    std::unique_ptr<BlockInfo> Info(new BlockInfo(BlockID));
+    KnownInfos.emplace(BlockID, std::move(Info));
+  }
+}
+
+NaClBitstreamReader::BlockInfo * NaClBitstreamReader::BlockInfoRecordsMap::
+getOrCreateUnknownBlockInfo(unsigned BlockID) {
+  std::unique_lock<std::mutex> Lock(UnknownBlockInfoLock);
+  while (true) {
+    auto Pos = UnknownInfos.find(BlockID);
+    if (Pos != UnknownInfos.end())
+      return Pos->second.get();
+    // Install, then let next iteration find.
+    std::unique_ptr<BlockInfo> Info(new BlockInfo(BlockID));
+    UnknownInfos.emplace(BlockID, std::move(Info));
+  }
+}
+
+NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock::
+UpdateLock(BlockInfoRecordsMap &BlockInfoRecords)
+    : BlockInfoRecords(BlockInfoRecords),
+      Lock(BlockInfoRecords.UpdateRecordsLock) {}
+
+NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock::
+~UpdateLock() {
+  if (BlockInfoRecords.freeze())
+    report_fatal_error("Global abbreviations block frozen while building.");
+}
+
 bool NaClBitstreamCursor::ReadBlockInfoBlock(NaClAbbrevListener *Listener) {
-  // If this is the second stream to get to the block info block, skip it.
-  if (BitStream->HasReadBlockInfoBlock)
+  // If this is the second read of the block info block, skip it.
+  if (BitStream->BlockInfoRecords->isFrozen())
     return SkipBlock();
 
-  BitStream->HasReadBlockInfoBlock = true;
-
+  NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock
+      Lock(*BitStream->BlockInfoRecords);
   unsigned NumWords;
   if (EnterSubBlock(naclbitc::BLOCKINFO_BLOCK_ID, &NumWords)) return true;
 
   if (Listener) Listener->BeginBlockInfoBlock(NumWords);
 
   NaClBitcodeRecordVector Record;
   Block &CurBlock = BlockScope.back();
   NaClBitstreamReader::AbbrevList *UpdateAbbrevs =
       &CurBlock.GlobalAbbrevs->getAbbrevs();
   bool FoundSetBID = false;
@@ skipping 30 matching lines @@
     // 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;
         FoundSetBID = true;
         UpdateAbbrevs =
-            &BitStream->getOrCreateBlockInfo((unsigned)Record[0]).getAbbrevs();
+            &BitStream->getBlockInfo((unsigned)Record[0])->getAbbrevs();
         if (Listener) {
           Listener->Values = Record;
           Listener->SetBID();
         }
         break;
     }
   }
 }