Copy LLVM bitcode reader to generate a PNaCl wire format reader.

lib/Bitcode/NaCl/Reader/NaClBitstreamReader.cpp

-//===- BitstreamReader.cpp - BitstreamReader implementation ---------------===//
+//===- 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.
 //

[jvoung (off chromium), 2013/04/29 18:02:08]

Should the merge script in native_client/pnacl/scripts/merge-tool-git.sh have
some notice about guidelines for merging changes in the upstream
BitstreamReader.cpp?

Or, will this file change quite a bit in following CLs?  Sounded like you wanted
to replace Abbrevs, Records, etc.?

I think the changes since 3.0 to this low-level interface hasn't been about the
format, but more performance related (e.g., enabling streaming compilation). 
After 4.0, there might be more drastic changes that we wouldn't want to merge
though.

[Karl, 2013/04/29 20:44:37]

The problem (as I see it) is that the way I want to approach abbreviations and
records will break bc-analyzer. As such, my guess is that a lot of the changes
will not be upstreamable.

I agree that some performance related changes can be upstreamed (See CL on
types).

Also, the goal of forking is to make sure that our ABI doesn't change under
upstream changes.

 //===----------------------------------------------------------------------===//
 
-#include "llvm/Bitcode/BitstreamReader.h"
+#include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
 
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
-//  BitstreamCursor implementation
+//  NaClBitstreamCursor implementation
 //===----------------------------------------------------------------------===//
 
-void BitstreamCursor::operator=(const BitstreamCursor &RHS) {
+void NaClBitstreamCursor::operator=(const NaClBitstreamCursor &RHS) {
   freeState();
 
   BitStream = RHS.BitStream;
   NextChar = RHS.NextChar;
   CurWord = RHS.CurWord;
   BitsInCurWord = RHS.BitsInCurWord;
   CurCodeSize = RHS.CurCodeSize;
 
   // Copy abbreviations, and bump ref counts.
   CurAbbrevs = RHS.CurAbbrevs;
   for (size_t i = 0, e = CurAbbrevs.size(); i != e; ++i)
     CurAbbrevs[i]->addRef();
 
   // Copy block scope and bump ref counts.
   BlockScope = RHS.BlockScope;
   for (size_t S = 0, e = BlockScope.size(); S != e; ++S) {
     std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
     for (size_t i = 0, e = Abbrevs.size(); i != e; ++i)
       Abbrevs[i]->addRef();
   }
 }
 
-void BitstreamCursor::freeState() {
+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<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
     for (size_t i = 0, e = Abbrevs.size(); i != e; ++i)
       Abbrevs[i]->dropRef();
   }
   BlockScope.clear();
 }
 
 /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
 /// the block, and return true if the block has an error.
-bool BitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) {
+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 BitstreamReader::BlockInfo *Info =
+  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 = ReadVBR(bitc::CodeLenWidth);
   SkipToFourByteBoundary();
   unsigned NumWords = Read(bitc::BlockSizeWidth);
   if (NumWordsP) *NumWordsP = NumWords;
 
   // Validate that this block is sane.
   if (CurCodeSize == 0 || AtEndOfStream())
     return true;
 
   return false;
 }
 
-void BitstreamCursor::readAbbreviatedLiteral(const BitCodeAbbrevOp &Op,
-                                             SmallVectorImpl<uint64_t> &Vals) {
+void NaClBitstreamCursor::readAbbreviatedLiteral(
+    const BitCodeAbbrevOp &Op,
+    SmallVectorImpl<uint64_t> &Vals) {
   assert(Op.isLiteral() && "Not a literal");
   // If the abbrev specifies the literal value to use, use it.
   Vals.push_back(Op.getLiteralValue());
 }
 
-void BitstreamCursor::readAbbreviatedField(const BitCodeAbbrevOp &Op,
-                                           SmallVectorImpl<uint64_t> &Vals) {
+void NaClBitstreamCursor::readAbbreviatedField(
+    const BitCodeAbbrevOp &Op,
+    SmallVectorImpl<uint64_t> &Vals) {
   assert(!Op.isLiteral() && "Use ReadAbbreviatedLiteral for literals!");
 
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case BitCodeAbbrevOp::Array:
   case BitCodeAbbrevOp::Blob:
     assert(0 && "Should not reach here");
   case BitCodeAbbrevOp::Fixed:
     Vals.push_back(Read((unsigned)Op.getEncodingData()));
     break;
   case BitCodeAbbrevOp::VBR:
     Vals.push_back(ReadVBR64((unsigned)Op.getEncodingData()));
     break;
   case BitCodeAbbrevOp::Char6:
     Vals.push_back(BitCodeAbbrevOp::DecodeChar6(Read(6)));
     break;
   }
 }
 
-void BitstreamCursor::skipAbbreviatedField(const BitCodeAbbrevOp &Op) {
+void NaClBitstreamCursor::skipAbbreviatedField(const BitCodeAbbrevOp &Op) {
   assert(!Op.isLiteral() && "Use ReadAbbreviatedLiteral for literals!");
 
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case BitCodeAbbrevOp::Array:
   case BitCodeAbbrevOp::Blob:
     assert(0 && "Should not reach here");
   case BitCodeAbbrevOp::Fixed:
     (void)Read((unsigned)Op.getEncodingData());
     break;
   case BitCodeAbbrevOp::VBR:
     (void)ReadVBR64((unsigned)Op.getEncodingData());
     break;
   case BitCodeAbbrevOp::Char6:
     (void)Read(6);
     break;
   }
 }
 
 
 
 /// skipRecord - Read the current record and discard it.
-void BitstreamCursor::skipRecord(unsigned AbbrevID) {
+void NaClBitstreamCursor::skipRecord(unsigned AbbrevID) {
   // Skip unabbreviated records by reading past their entries.
   if (AbbrevID == bitc::UNABBREV_RECORD) {
     unsigned Code = ReadVBR(6);
     (void)Code;
     unsigned NumElts = ReadVBR(6);
     for (unsigned i = 0; i != NumElts; ++i)
       (void)ReadVBR64(6);
     return;
   }
 
@@ skipping 37 matching lines @@
     if (!canSkipToPos(NewEnd/8)) {
       NextChar = BitStream->getBitcodeBytes().getExtent();
       break;
     }
 
     // Skip over the blob.
     JumpToBit(NewEnd);
   }
 }
 
-unsigned BitstreamCursor::readRecord(unsigned AbbrevID,
-                                     SmallVectorImpl<uint64_t> &Vals,
-                                     StringRef *Blob) {
+unsigned NaClBitstreamCursor::readRecord(unsigned AbbrevID,
+                                         SmallVectorImpl<uint64_t> &Vals,
+                                         StringRef *Blob) {
   if (AbbrevID == bitc::UNABBREV_RECORD) {
     unsigned Code = ReadVBR(6);
     unsigned NumElts = ReadVBR(6);
     for (unsigned i = 0; i != NumElts; ++i)
       Vals.push_back(ReadVBR64(6));
     return Code;
   }
 
   const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
 
@@ skipping 56 matching lines @@
     // Skip over tail padding.
     JumpToBit(NewEnd);
   }
 
   unsigned Code = (unsigned)Vals[0];
   Vals.erase(Vals.begin());
   return Code;
 }
 
 
-void BitstreamCursor::ReadAbbrevRecord() {
+void NaClBitstreamCursor::ReadAbbrevRecord() {
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   unsigned NumOpInfo = ReadVBR(5);
   for (unsigned i = 0; i != NumOpInfo; ++i) {
     bool IsLiteral = Read(1) ? true : false;
     if (IsLiteral) {
       Abbv->Add(BitCodeAbbrevOp(ReadVBR64(8)));
       continue;
     }
 
     BitCodeAbbrevOp::Encoding E = (BitCodeAbbrevOp::Encoding)Read(3);
     if (BitCodeAbbrevOp::hasEncodingData(E)) {
       unsigned Data = ReadVBR64(5);
 
       // As a special case, handle fixed(0) (i.e., a fixed field with zero bits)
       // and vbr(0) as a literal zero.  This is decoded the same way, and avoids
       // a slow path in Read() to have to handle reading zero bits.
       if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) &&
           Data == 0) {
         Abbv->Add(BitCodeAbbrevOp(0));
         continue;
       }
       
       Abbv->Add(BitCodeAbbrevOp(E, Data));
     } else
       Abbv->Add(BitCodeAbbrevOp(E));
   }
   CurAbbrevs.push_back(Abbv);
 }
 
-bool BitstreamCursor::ReadBlockInfoBlock() {
+bool NaClBitstreamCursor::ReadBlockInfoBlock() {
   // If this is the second stream to get to the block info block, skip it.
   if (BitStream->hasBlockInfoRecords())
     return SkipBlock();
 
   if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true;
 
   SmallVector<uint64_t, 64> Record;
-  BitstreamReader::BlockInfo *CurBlockInfo = 0;
+  NaClBitstreamReader::BlockInfo *CurBlockInfo = 0;
 
   // Read all the records for this module.
   while (1) {
     BitstreamEntry Entry = advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs);
 
     switch (Entry.Kind) {
     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
     case llvm::BitstreamEntry::Error:
       return true;
     case llvm::BitstreamEntry::EndBlock:
@@ skipping 39 matching lines @@
         std::string Name;
         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;
       }
     }
   }
 }
-