Bitcode: Add ability to support multiple block info blocks.

[pcc]

Summary

Each block info block is chained to its dependent block. This helps ensure
that block info blocks are read in dependency order.

[pcc]

• The check was previously unreachable, move it to the correct place

[pcc]

As discussed on IRC: let's not support multiple block info blocks like this. It'd be simpler to require each block info block to be independent.

llvm/include/llvm/Bitcode/BitCodes.h

namespace bitc {
   /// BlockInfoCodes - The blockinfo block contains metadata about user-defined
   /// blocks.
   enum BlockInfoCodes {
     // DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
     // block, instead of the BlockInfo block.
 
     BLOCKINFO_CODE_SETBID        = 1, // SETBID: [blockid#]
     BLOCKINFO_CODE_BLOCKNAME     = 2, // BLOCKNAME: [name]
-    BLOCKINFO_CODE_SETRECORDNAME = 3  // BLOCKINFO_CODE_SETRECORDNAME:
+    BLOCKINFO_CODE_SETRECORDNAME = 3, // BLOCKINFO_CODE_SETRECORDNAME:
                                       //                             [id, name]
+    BLOCKINFO_CODE_DEPENDENCY    = 4, // DEPENDENCY: [bitno]
   };
 
 } // End bitc namespace
 
 /// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
 /// This is actually a union of two different things:
 ///   1. It could be a literal integer value ("the operand is always 17").
 ///   2. It could be an encoding specification ("this operand encoded like so").

llvm/include/llvm/Bitcode/BitstreamReader.h

private:
   std::unique_ptr<MemoryObject> BitcodeBytes;
 
   std::vector<BlockInfo> BlockInfoRecords;
 
   /// This is set to true if we don't care about the block/record name
   /// information in the BlockInfo block. Only llvm-bcanalyzer uses this.
   bool IgnoreBlockInfoNames;
 
+  /// Tracks the bit number of the most recently read block info block. This is
+  /// used to interpret the BLOCKINFO_CODE_DEPENDENCY record which helps ensure
+  /// that block info blocks are read in dependency order.
+  uint64_t BlockInfoDependency = 0;
+
 public:
   BitstreamReader() : IgnoreBlockInfoNames(true) {
   }
 
   BitstreamReader(const unsigned char *Start, const unsigned char *End)
       : IgnoreBlockInfoNames(true) {
     init(Start, End);
   }
if (const BlockInfo *BI = getBlockInfo(BlockID))
       return *const_cast<BlockInfo*>(BI);
 
     // Otherwise, add a new record.
     BlockInfoRecords.emplace_back();
     BlockInfoRecords.back().BlockID = BlockID;
     return BlockInfoRecords.back();
   }
 
+  uint64_t getBlockInfoDependency() const { return BlockInfoDependency; }
+  void setBlockInfoDependency(uint64_t B) { BlockInfoDependency = B; }
+
   /// Takes block info from the other bitstream reader.
   ///
   /// This is a "take" operation because BlockInfo records are non-trivial, and
   /// indeed rather expensive.
   void takeBlockInfo(BitstreamReader &&Other) {
     assert(!hasBlockInfoRecords());
     BlockInfoRecords = std::move(Other.BlockInfoRecords);
   }

llvm/include/llvm/Bitcode/BitstreamWriter.h

class BitstreamWriter {
   /// CurCodeSize - This is the declared size of code values used for the
   /// current block, in bits.
   unsigned CurCodeSize;
 
   /// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
   /// selected BLOCK ID.
   unsigned BlockInfoCurBID;
 
+  /// Tracks the bit number of the most recently written block info block. This
+  /// is used to write the BLOCKINFO_CODE_DEPENDENCY record which helps ensure
+  /// that block info blocks are read in dependency order.
+  uint64_t BlockInfoDependency = 0;
+
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<IntrusiveRefCntPtr<BitCodeAbbrev>> CurAbbrevs;
 
   struct Block {
     unsigned PrevCodeSize;
     size_t StartSizeWord;
     std::vector<IntrusiveRefCntPtr<BitCodeAbbrev>> PrevAbbrevs;
     Block(unsigned PCS, size_t SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
public:
   }
 
   //===--------------------------------------------------------------------===//
   // BlockInfo Block Emission
   //===--------------------------------------------------------------------===//
 
   /// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
   void EnterBlockInfoBlock(unsigned CodeWidth) {
+    uint64_t LastBlockInfoDependency = BlockInfoDependency;
+    BlockInfoDependency = GetCurrentBitNo();
+
     EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, CodeWidth);
     BlockInfoCurBID = ~0U;
+    if (LastBlockInfoDependency)
+      EmitRecord(bitc::BLOCKINFO_CODE_DEPENDENCY,
+                 ArrayRef<uint64_t>{LastBlockInfoDependency});
   }
 private:
   /// SwitchToBlockID - If we aren't already talking about the specified block
   /// ID, emit a BLOCKINFO_CODE_SETBID record.
   void SwitchToBlockID(unsigned BlockID) {
     if (BlockInfoCurBID == BlockID) return;
     SmallVector<unsigned, 2> V;
     V.push_back(BlockID);

llvm/lib/Bitcode/Reader/BitstreamReader.cpp

void BitstreamCursor::ReadAbbrevRecord() {
   }
 
   if (Abbv->getNumOperandInfos() == 0)
     report_fatal_error("Abbrev record with no operands");
   CurAbbrevs.push_back(Abbv);
 }
 
 bool BitstreamCursor::ReadBlockInfoBlock() {
-  // We expect the client to read the block info block at most once.
-  if (getBitStreamReader()->hasBlockInfoRecords())
-    report_fatal_error("Duplicate read of block info block");
+  uint64_t BlockInfoDependency = GetCurrentBitNo();
 
   if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true;
 
   SmallVector<uint64_t, 64> Record;
+  uint64_t LastBlockInfoDependency = 0;
   BitstreamReader::BlockInfo *CurBlockInfo = nullptr;
 
   // Read all the records for this module.
   while (true) {
     BitstreamEntry Entry = advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs);
 
     switch (Entry.Kind) {
     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
if (Entry.ID == bitc::DEFINE_ABBREV) {
       CurAbbrevs.pop_back();
       continue;
     }
 
     // Read a record.
     Record.clear();
     switch (readRecord(Entry.ID, Record)) {
       default: break;  // Default behavior, ignore unknown content.
+      case bitc::BLOCKINFO_CODE_DEPENDENCY:
+        LastBlockInfoDependency = Record[0];
+        break;
       case bitc::BLOCKINFO_CODE_SETBID:
         if (Record.size() < 1) return true;
         CurBlockInfo =
             &getBitStreamReader()->getOrCreateBlockInfo((unsigned)Record[0]);
         break;
       case bitc::BLOCKINFO_CODE_BLOCKNAME: {
         if (!CurBlockInfo) return true;
         if (getBitStreamReader()->isIgnoringBlockInfoNames())
switch (readRecord(Entry.ID, Record)) {
         for (unsigned i = 1, e = Record.size(); i != e; ++i)
           Name += (char)Record[i];
         CurBlockInfo->RecordNames.push_back(std::make_pair((unsigned)Record[0],
                                                            Name));
         break;
       }
     }
   }
+
+  // We expect the client to read block info blocks in dependency order.
+  if (getBitStreamReader()->getBlockInfoDependency() != LastBlockInfoDependency)
+    report_fatal_error("Duplicate or out of order read of block info block");
+  getBitStreamReader()->setBlockInfoDependency(BlockInfoDependency);
 }