Copy BitCodes.h to NaCl/NaClBitCodes.h

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- 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.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 21 matching lines @@
 /// 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::vector<NaClBitCodeAbbrev*> 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
@@ skipping 129 matching lines @@
 
   /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
   /// is always from [0...31/63] inclusive (depending on word size).
   unsigned BitsInCurWord;
 
   // CurCodeSize - This is the declared size of code values used for the current
   // block, in bits.
   unsigned CurCodeSize;
 
   /// CurAbbrevs - Abbrevs installed at in this block.
-  std::vector<BitCodeAbbrev*> CurAbbrevs;
+  std::vector<NaClBitCodeAbbrev*> CurAbbrevs;
 
   struct Block {
     unsigned PrevCodeSize;
-    std::vector<BitCodeAbbrev*> PrevAbbrevs;
+    std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
     explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
   };
 
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
   
 public:
   NaClBitstreamCursor() : BitStream(0), NextChar(0) {
   }
@@ skipping 72 matching lines @@
     /// 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.
   NaClBitstreamEntry advance(unsigned Flags = 0) {
     while (1) {
       unsigned Code = ReadCode();
-      if (Code == bitc::END_BLOCK) {
+      if (Code == naclbitc::END_BLOCK) {
         // Pop the end of the block unless Flags tells us not to.
         if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
           return NaClBitstreamEntry::getError();
         return NaClBitstreamEntry::getEndBlock();
       }
       
-      if (Code == bitc::ENTER_SUBBLOCK)
+      if (Code == naclbitc::ENTER_SUBBLOCK)
         return NaClBitstreamEntry::getSubBlock(ReadSubBlockID());
       
-      if (Code == bitc::DEFINE_ABBREV &&
+      if (Code == naclbitc::DEFINE_ABBREV &&
           !(Flags & AF_DontAutoprocessAbbrevs)) {
         // We read and accumulate abbrev's, the client can't do anything with
         // them anyway.
         ReadAbbrevRecord();
         continue;
       }
 
       return NaClBitstreamEntry::getRecord(Code);
     }
   }
@@ skipping 152 matching lines @@
     return Read(CurCodeSize);
   }
 
 
   // Block header:
   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
 
   /// ReadSubBlockID - Having read the ENTER_SUBBLOCK code, read the BlockID for
   /// the block.
   unsigned ReadSubBlockID() {
-    return ReadVBR(bitc::BlockIDWidth);
+    return ReadVBR(naclbitc::BlockIDWidth);
   }
 
   /// SkipBlock - Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip
   /// over the body of this block.  If the block record is malformed, return
   /// true.
   bool SkipBlock() {
     // Read and ignore the codelen value.  Since we are skipping this block, we
     // don't care what code widths are used inside of it.
-    ReadVBR(bitc::CodeLenWidth);
+    ReadVBR(naclbitc::CodeLenWidth);
     SkipToFourByteBoundary();
-    unsigned NumFourBytes = Read(bitc::BlockSizeWidth);
+    unsigned NumFourBytes = Read(naclbitc::BlockSizeWidth);
 
     // Check that the block wasn't partially defined, and that the offset isn't
     // bogus.
     size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
     if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
       return true;
 
     JumpToBit(SkipTo);
     return false;
   }
@@ skipping 25 matching lines @@
 
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
     BlockScope.pop_back();
   }
 
   //===--------------------------------------------------------------------===//
   // Record Processing
   //===--------------------------------------------------------------------===//
 
 private:
-  void readAbbreviatedLiteral(const BitCodeAbbrevOp &Op,
+  void readAbbreviatedLiteral(const NaClBitCodeAbbrevOp &Op,
                               SmallVectorImpl<uint64_t> &Vals);
-  void readAbbreviatedField(const BitCodeAbbrevOp &Op,
+  void readAbbreviatedField(const NaClBitCodeAbbrevOp &Op,
                             SmallVectorImpl<uint64_t> &Vals);
-  void skipAbbreviatedField(const BitCodeAbbrevOp &Op);
+  void skipAbbreviatedField(const NaClBitCodeAbbrevOp &Op);
   
 public:
 
   /// getAbbrev - Return the abbreviation for the specified AbbrevId.
-  const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
-    unsigned AbbrevNo = AbbrevID-bitc::FIRST_APPLICATION_ABBREV;
+  const NaClBitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
+    unsigned AbbrevNo = AbbrevID-naclbitc::FIRST_APPLICATION_ABBREV;
     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
     return CurAbbrevs[AbbrevNo];
   }
 
   /// skipRecord - Read the current record and discard it.
   void skipRecord(unsigned AbbrevID);
   
   unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
                       StringRef *Blob = 0);
 
   //===--------------------------------------------------------------------===//
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   void ReadAbbrevRecord();
   
   bool ReadBlockInfoBlock();
 };
 
 } // End llvm namespace
 
 #endif