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

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

-//===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
+//===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
+//     Low-level bitstream reader interface
 //
 //                     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 BitstreamReader class.  This class can be used to
 // read an arbitrary bitstream, regardless of its contents.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_BITCODE_BITSTREAMREADER_H
-#define LLVM_BITCODE_BITSTREAMREADER_H
+#ifndef LLVM_BITCODE_NACL_NACLBITSTREAMREADER_H
+#define LLVM_BITCODE_NACL_NACLBITSTREAMREADER_H
 
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/Bitcode/BitCodes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/StreamableMemoryObject.h"
 #include <climits>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
   class Deserializer;
 
-/// BitstreamReader - This class is used to read from an LLVM bitcode stream,
+/// NaClBitstreamReader - This class is used to read from an LLVM bitcode stream,
 /// maintaining information that is global to decoding the entire file.  While
 /// a file is being read, multiple cursors can be independently advanced or
 /// skipped around within the file.  These are represented by the
-/// BitstreamCursor class.
-class BitstreamReader {
+/// NaClBitstreamCursor class.
+class NaClBitstreamReader {
 public:
   /// 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<BitCodeAbbrev*> Abbrevs;
     std::string Name;
 
     std::vector<std::pair<unsigned, std::string> > RecordNames;
   };
 private:
   OwningPtr<StreamableMemoryObject> BitcodeBytes;
 
   std::vector<BlockInfo> BlockInfoRecords;
 
   /// IgnoreBlockInfoNames - 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;
 
-  BitstreamReader(const BitstreamReader&) LLVM_DELETED_FUNCTION;
-  void operator=(const BitstreamReader&) LLVM_DELETED_FUNCTION;
+  NaClBitstreamReader(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
+  void operator=(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
 public:
-  BitstreamReader() : IgnoreBlockInfoNames(true) {
+  NaClBitstreamReader() : IgnoreBlockInfoNames(true) {
   }
 
-  BitstreamReader(const unsigned char *Start, const unsigned char *End) {
+  NaClBitstreamReader(const unsigned char *Start, const unsigned char *End) {
     IgnoreBlockInfoNames = true;
     init(Start, End);
   }
 
-  BitstreamReader(StreamableMemoryObject *bytes) {
+  NaClBitstreamReader(StreamableMemoryObject *bytes) {
     BitcodeBytes.reset(bytes);
   }
 
   void init(const unsigned char *Start, const unsigned char *End) {
     assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
     BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));
   }
 
   StreamableMemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
 
-  ~BitstreamReader() {
+  ~NaClBitstreamReader() {
     // Free the BlockInfoRecords.
     while (!BlockInfoRecords.empty()) {
       BlockInfo &Info = BlockInfoRecords.back();
       // Free blockinfo abbrev info.
       for (unsigned i = 0, e = static_cast<unsigned>(Info.Abbrevs.size());
            i != e; ++i)
         Info.Abbrevs[i]->dropRef();
       BlockInfoRecords.pop_back();
     }
   }
@@ skipping 31 matching lines @@
       return *const_cast<BlockInfo*>(BI);
 
     // Otherwise, add a new record.
     BlockInfoRecords.push_back(BlockInfo());
     BlockInfoRecords.back().BlockID = BlockID;
     return BlockInfoRecords.back();
   }
 };
 
   
 /// BitstreamEntry - When advancing through a bitstream cursor, each advance can

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

Should this top-level struct be made NaClBitstreamEntry?

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

Good point. Renaming.

 /// discover a few different kinds of entries:
 ///   Error    - Malformed bitcode was found.
 ///   EndBlock - We've reached the end of the current block, (or the end of the
 ///              file, which is treated like a series of EndBlock records.
 ///   SubBlock - This is the start of a new subblock of a specific ID.
 ///   Record   - This is a record with a specific AbbrevID.
 ///
 struct BitstreamEntry {
   enum {
     Error,
@@ skipping 11 matching lines @@
     BitstreamEntry E; E.Kind = EndBlock; return E;
   }
   static BitstreamEntry getSubBlock(unsigned ID) {
     BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
   }
   static BitstreamEntry getRecord(unsigned AbbrevID) {
     BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
   }
 };
 
-/// BitstreamCursor - This represents a position within a bitcode file.  There
-/// may be multiple independent cursors reading within one bitstream, each
-/// maintaining their own local state.
+/// NaClBitstreamCursor - This represents a position within a bitcode
+/// file.  There may be multiple independent cursors reading within
+/// one bitstream, each maintaining their own local state.
 ///
-/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
-/// be passed by value.
-class BitstreamCursor {
+/// Unlike iterators, NaClBitstreamCursors are heavy-weight objects
+/// that should not be passed by value.
+class NaClBitstreamCursor {
   friend class Deserializer;
-  BitstreamReader *BitStream;
+  NaClBitstreamReader *BitStream;
   size_t NextChar;
 
   
   /// CurWord/word_t - This is the current data we have pulled from the stream
   /// but have not returned to the client.  This is specifically and
   /// intentionally defined to follow the word size of the host machine for
   /// efficiency.  We use word_t in places that are aware of this to make it
   /// perfectly explicit what is going on.
   typedef uint32_t word_t;
   word_t CurWord;
@@ skipping 13 matching lines @@
     unsigned PrevCodeSize;
     std::vector<BitCodeAbbrev*> PrevAbbrevs;
     explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
   };
 
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
   
 public:
-  BitstreamCursor() : BitStream(0), NextChar(0) {
+  NaClBitstreamCursor() : BitStream(0), NextChar(0) {
   }
-  BitstreamCursor(const BitstreamCursor &RHS) : BitStream(0), NextChar(0) {
+  NaClBitstreamCursor(const NaClBitstreamCursor &RHS)
+      : BitStream(0), NextChar(0) {
     operator=(RHS);
   }
 
-  explicit BitstreamCursor(BitstreamReader &R) : BitStream(&R) {
+  explicit NaClBitstreamCursor(NaClBitstreamReader &R) : BitStream(&R) {
     NextChar = 0;
     CurWord = 0;
     BitsInCurWord = 0;
     CurCodeSize = 2;
   }
 
-  void init(BitstreamReader &R) {
+  void init(NaClBitstreamReader &R) {
     freeState();
 
     BitStream = &R;
     NextChar = 0;
     CurWord = 0;
     BitsInCurWord = 0;
     CurCodeSize = 2;
   }
 
-  ~BitstreamCursor() {
+  ~NaClBitstreamCursor() {
     freeState();
   }
 
-  void operator=(const BitstreamCursor &RHS);
+  void operator=(const NaClBitstreamCursor &RHS);
 
   void freeState();
   
   bool isEndPos(size_t pos) {
     return BitStream->getBitcodeBytes().isObjectEnd(static_cast<uint64_t>(pos));
   }
 
   bool canSkipToPos(size_t pos) const {
     // pos can be skipped to if it is a valid address or one byte past the end.
     return pos == 0 || BitStream->getBitcodeBytes().isValidAddress(
@@ skipping 11 matching lines @@
   }
 
   /// getAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
   unsigned getAbbrevIDWidth() const { return CurCodeSize; }
 
   /// GetCurrentBitNo - Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
     return NextChar*CHAR_BIT - BitsInCurWord;
   }
 
-  BitstreamReader *getBitStreamReader() {
+  NaClBitstreamReader *getBitStreamReader() {
     return BitStream;
   }
-  const BitstreamReader *getBitStreamReader() const {
+  const NaClBitstreamReader *getBitStreamReader() const {
     return BitStream;
   }
 
   /// Flags that modify the behavior of advance().
   enum {
     /// AF_DontPopBlockAtEnd - If this flag is used, the advance() method does
     /// not automatically pop the block scope when the end of a block is
     /// reached.
     AF_DontPopBlockAtEnd = 1,
 
@@ skipping 272 matching lines @@
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   void ReadAbbrevRecord();
   
   bool ReadBlockInfoBlock();
 };
 
 } // End llvm namespace
 
 #endif