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/Bitcode/NaCl/NaClLLVMBitCodes.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,
-/// 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 {
+/// NaClBitstreamReader - This class is used to read from a NaCl
+/// bitcode wire format 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 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
-/// discover a few different kinds of entries:
+/// NaClBitstreamEntry - When advancing through a bitstream cursor,
+/// each advance can 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 {
+struct NaClBitstreamEntry {
   enum {
     Error,
     EndBlock,
     SubBlock,
     Record
   } Kind;
   
   unsigned ID;
 
-  static BitstreamEntry getError() {
-    BitstreamEntry E; E.Kind = Error; return E;
+  static NaClBitstreamEntry getError() {
+    NaClBitstreamEntry E; E.Kind = Error; return E;
   }
-  static BitstreamEntry getEndBlock() {
-    BitstreamEntry E; E.Kind = EndBlock; return E;
+  static NaClBitstreamEntry getEndBlock() {
+    NaClBitstreamEntry E; E.Kind = EndBlock; return E;
   }
-  static BitstreamEntry getSubBlock(unsigned ID) {
-    BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
+  static NaClBitstreamEntry getSubBlock(unsigned ID) {
+    NaClBitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
   }
-  static BitstreamEntry getRecord(unsigned AbbrevID) {
-    BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
+  static NaClBitstreamEntry getRecord(unsigned AbbrevID) {
+    NaClBitstreamEntry 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,
 
     /// AF_DontAutoprocessAbbrevs - If this flag is used, abbrev entries are
     /// returned just like normal records.
     AF_DontAutoprocessAbbrevs = 2
   };
   
   /// advance - Advance the current bitstream, returning the next entry in the
   /// stream.
-  BitstreamEntry advance(unsigned Flags = 0) {
+  NaClBitstreamEntry advance(unsigned Flags = 0) {
     while (1) {
       unsigned Code = ReadCode();
       if (Code == bitc::END_BLOCK) {
         // Pop the end of the block unless Flags tells us not to.
         if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
-          return BitstreamEntry::getError();
-        return BitstreamEntry::getEndBlock();
+          return NaClBitstreamEntry::getError();
+        return NaClBitstreamEntry::getEndBlock();
       }
       
       if (Code == bitc::ENTER_SUBBLOCK)
-        return BitstreamEntry::getSubBlock(ReadSubBlockID());
+        return NaClBitstreamEntry::getSubBlock(ReadSubBlockID());
       
       if (Code == bitc::DEFINE_ABBREV &&
           !(Flags & AF_DontAutoprocessAbbrevs)) {
         // We read and accumulate abbrev's, the client can't do anything with
         // them anyway.
         ReadAbbrevRecord();
         continue;
       }
 
-      return BitstreamEntry::getRecord(Code);
+      return NaClBitstreamEntry::getRecord(Code);
     }
   }
 
   /// advanceSkippingSubblocks - This is a convenience function for clients that
   /// don't expect any subblocks.  This just skips over them automatically.
-  BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
+  NaClBitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
     while (1) {
       // If we found a normal entry, return it.
-      BitstreamEntry Entry = advance(Flags);
-      if (Entry.Kind != BitstreamEntry::SubBlock)
+      NaClBitstreamEntry Entry = advance(Flags);
+      if (Entry.Kind != NaClBitstreamEntry::SubBlock)
         return Entry;
       
       // If we found a sub-block, just skip over it and check the next entry.
       if (SkipBlock())
-        return BitstreamEntry::getError();
+        return NaClBitstreamEntry::getError();
     }
   }
 
   /// JumpToBit - Reset the stream to the specified bit number.
   void JumpToBit(uint64_t BitNo) {
     uintptr_t ByteNo = uintptr_t(BitNo/8) & ~(sizeof(word_t)-1);
     unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
     assert(canSkipToPos(ByteNo) && "Invalid location");
 
     // Move the cursor to the right word.
@@ skipping 218 matching lines @@
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   void ReadAbbrevRecord();
   
   bool ReadBlockInfoBlock();
 };
 
 } // End llvm namespace
 
 #endif