Copy BitCodes.h to NaCl/NaClBitCodes.h

include/llvm/Bitcode/NaCl/NaClBitstreamWriter.h

 //===- NaClBitstreamWriter.h - NaCl bitstream writer ------------*- C++ -*-===//
 //
 //                     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 BitstreamWriter class.  This class can be used to
 // write an arbitrary bitstream, regardless of its contents.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_NACL_NACLBITSTREAMWRITER_H
 #define LLVM_BITCODE_NACL_NACLBITSTREAMWRITER_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Bitcode/BitCodes.h"
+#include "llvm/Bitcode/NaCl/NaClBitCodes.h"
 #include <vector>
 
 namespace llvm {
 
 class NaClBitstreamWriter {
   SmallVectorImpl<char> &Out;
 
   /// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
   unsigned CurBit;
 
   /// CurValue - The current value.  Only bits < CurBit are valid.
   uint32_t CurValue;
 
   /// 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;
 
   /// CurAbbrevs - Abbrevs installed at in this block.
-  std::vector<BitCodeAbbrev*> CurAbbrevs;
+  std::vector<NaClBitCodeAbbrev*> CurAbbrevs;
 
   struct Block {
     unsigned PrevCodeSize;
     unsigned StartSizeWord;
-    std::vector<BitCodeAbbrev*> PrevAbbrevs;
+    std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
     Block(unsigned PCS, unsigned SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
   };
 
   /// BlockScope - This tracks the current blocks that we have entered.
   std::vector<Block> BlockScope;
 
   /// 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::vector<BlockInfo> BlockInfoRecords;
 
   // BackpatchWord - Backpatch a 32-bit word in the output with the specified
   // value.
   void BackpatchWord(unsigned ByteNo, unsigned NewWord) {
     Out[ByteNo++] = (unsigned char)(NewWord >>  0);
     Out[ByteNo++] = (unsigned char)(NewWord >>  8);
     Out[ByteNo++] = (unsigned char)(NewWord >> 16);
     Out[ByteNo  ] = (unsigned char)(NewWord >> 24);
@@ skipping 133 matching lines @@
     for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
          i != e; ++i)
       if (BlockInfoRecords[i].BlockID == BlockID)
         return &BlockInfoRecords[i];
     return 0;
   }
 
   void EnterSubblock(unsigned BlockID, unsigned CodeLen) {
     // Block header:
     //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
-    EmitCode(bitc::ENTER_SUBBLOCK);
-    EmitVBR(BlockID, bitc::BlockIDWidth);
-    EmitVBR(CodeLen, bitc::CodeLenWidth);
+    EmitCode(naclbitc::ENTER_SUBBLOCK);
+    EmitVBR(BlockID, naclbitc::BlockIDWidth);
+    EmitVBR(CodeLen, naclbitc::CodeLenWidth);
     FlushToWord();
 
     unsigned BlockSizeWordIndex = GetWordIndex();
     unsigned OldCodeSize = CurCodeSize;
 
     // Emit a placeholder, which will be replaced when the block is popped.
-    Emit(0, bitc::BlockSizeWidth);
+    Emit(0, naclbitc::BlockSizeWidth);
 
     CurCodeSize = CodeLen;
 
     // Push the outer block's abbrev set onto the stack, start out with an
     // empty abbrev set.
     BlockScope.push_back(Block(OldCodeSize, BlockSizeWordIndex));
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
 
     // If there is a blockinfo for this BlockID, add all the predefined abbrevs
     // to the abbrev list.
@@ skipping 11 matching lines @@
 
     // Delete all abbrevs.
     for (unsigned i = 0, e = static_cast<unsigned>(CurAbbrevs.size());
          i != e; ++i)
       CurAbbrevs[i]->dropRef();
 
     const Block &B = BlockScope.back();
 
     // Block tail:
     //    [END_BLOCK, <align4bytes>]
-    EmitCode(bitc::END_BLOCK);
+    EmitCode(naclbitc::END_BLOCK);
     FlushToWord();
 
     // Compute the size of the block, in words, not counting the size field.
     unsigned SizeInWords = GetWordIndex() - B.StartSizeWord - 1;
     unsigned ByteNo = B.StartSizeWord*4;
 
     // Update the block size field in the header of this sub-block.
     BackpatchWord(ByteNo, SizeInWords);
 
     // Restore the inner block's code size and abbrev table.
     CurCodeSize = B.PrevCodeSize;
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
     BlockScope.pop_back();
   }
 
   //===--------------------------------------------------------------------===//
   // Record Emission
   //===--------------------------------------------------------------------===//
 
 private:
   /// EmitAbbreviatedLiteral - Emit a literal value according to its abbrev
   /// record.  This is a no-op, since the abbrev specifies the literal to use.
   template<typename uintty>
-  void EmitAbbreviatedLiteral(const BitCodeAbbrevOp &Op, uintty V) {
+  void EmitAbbreviatedLiteral(const NaClBitCodeAbbrevOp &Op, uintty V) {
     assert(Op.isLiteral() && "Not a literal");
     // If the abbrev specifies the literal value to use, don't emit
     // anything.
     assert(V == Op.getLiteralValue() &&
            "Invalid abbrev for record!");
   }
 
   /// EmitAbbreviatedField - Emit a single scalar field value with the specified
   /// encoding.
   template<typename uintty>
-  void EmitAbbreviatedField(const BitCodeAbbrevOp &Op, uintty V) {
+  void EmitAbbreviatedField(const NaClBitCodeAbbrevOp &Op, uintty V) {
     assert(!Op.isLiteral() && "Literals should use EmitAbbreviatedLiteral!");
 
     // Encode the value as we are commanded.
     switch (Op.getEncoding()) {
     default: llvm_unreachable("Unknown encoding!");
-    case BitCodeAbbrevOp::Fixed:
+    case NaClBitCodeAbbrevOp::Fixed:
       if (Op.getEncodingData())
         Emit((unsigned)V, (unsigned)Op.getEncodingData());
       break;
-    case BitCodeAbbrevOp::VBR:
+    case NaClBitCodeAbbrevOp::VBR:
       if (Op.getEncodingData())
         EmitVBR64(V, (unsigned)Op.getEncodingData());
       break;
-    case BitCodeAbbrevOp::Char6:
-      Emit(BitCodeAbbrevOp::EncodeChar6((char)V), 6);
+    case NaClBitCodeAbbrevOp::Char6:
+      Emit(NaClBitCodeAbbrevOp::EncodeChar6((char)V), 6);
       break;
     }
   }
 
   /// EmitRecordWithAbbrevImpl - This is the core implementation of the record
   /// emission code.  If BlobData is non-null, then it specifies an array of
   /// data that should be emitted as part of the Blob or Array operand that is
   /// known to exist at the end of the record.
   template<typename uintty>
   void EmitRecordWithAbbrevImpl(unsigned Abbrev, SmallVectorImpl<uintty> &Vals,
                                 StringRef Blob) {
     const char *BlobData = Blob.data();
     unsigned BlobLen = (unsigned) Blob.size();
-    unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
+    unsigned AbbrevNo = Abbrev-naclbitc::FIRST_APPLICATION_ABBREV;
     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
-    BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
+    NaClBitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
 
     EmitCode(Abbrev);
 
     unsigned RecordIdx = 0;
     for (unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
          i != e; ++i) {
-      const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+      const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
       if (Op.isLiteral()) {
         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
         EmitAbbreviatedLiteral(Op, Vals[RecordIdx]);
         ++RecordIdx;
-      } else if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
+      } else if (Op.getEncoding() == NaClBitCodeAbbrevOp::Array) {
         // Array case.
         assert(i+2 == e && "array op not second to last?");
-        const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
+        const NaClBitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
 
         // If this record has blob data, emit it, otherwise we must have record
         // entries to encode this way.
         if (BlobData) {
           assert(RecordIdx == Vals.size() &&
                  "Blob data and record entries specified for array!");
           // Emit a vbr6 to indicate the number of elements present.
           EmitVBR(static_cast<uint32_t>(BlobLen), 6);
 
           // Emit each field.
           for (unsigned i = 0; i != BlobLen; ++i)
             EmitAbbreviatedField(EltEnc, (unsigned char)BlobData[i]);
 
           // Know that blob data is consumed for assertion below.
           BlobData = 0;
         } else {
           // Emit a vbr6 to indicate the number of elements present.
           EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
 
           // Emit each field.
           for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
             EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
         }
-      } else if (Op.getEncoding() == BitCodeAbbrevOp::Blob) {
+      } else if (Op.getEncoding() == NaClBitCodeAbbrevOp::Blob) {
         // If this record has blob data, emit it, otherwise we must have record
         // entries to encode this way.
 
         // Emit a vbr6 to indicate the number of elements present.
         if (BlobData) {
           EmitVBR(static_cast<uint32_t>(BlobLen), 6);
           assert(RecordIdx == Vals.size() &&
                  "Blob data and record entries specified for blob operand!");
         } else {
           EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
@@ skipping 33 matching lines @@
 public:
 
   /// EmitRecord - Emit the specified record to the stream, using an abbrev if
   /// we have one to compress the output.
   template<typename uintty>
   void EmitRecord(unsigned Code, SmallVectorImpl<uintty> &Vals,
                   unsigned Abbrev = 0) {
     if (!Abbrev) {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
-      EmitCode(bitc::UNABBREV_RECORD);
+      EmitCode(naclbitc::UNABBREV_RECORD);
       EmitVBR(Code, 6);
       EmitVBR(static_cast<uint32_t>(Vals.size()), 6);
       for (unsigned i = 0, e = static_cast<unsigned>(Vals.size()); i != e; ++i)
         EmitVBR64(Vals[i], 6);
       return;
     }
 
     // Insert the code into Vals to treat it uniformly.
     Vals.insert(Vals.begin(), Code);
 
@@ skipping 37 matching lines @@
     return EmitRecordWithAbbrevImpl(Abbrev, Vals, StringRef(ArrayData, 
                                                             ArrayLen));
   }
 
   //===--------------------------------------------------------------------===//
   // Abbrev Emission
   //===--------------------------------------------------------------------===//
 
 private:
   // Emit the abbreviation as a DEFINE_ABBREV record.
-  void EncodeAbbrev(BitCodeAbbrev *Abbv) {
-    EmitCode(bitc::DEFINE_ABBREV);
+  void EncodeAbbrev(NaClBitCodeAbbrev *Abbv) {
+    EmitCode(naclbitc::DEFINE_ABBREV);
     EmitVBR(Abbv->getNumOperandInfos(), 5);
     for (unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
          i != e; ++i) {
-      const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+      const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
       Emit(Op.isLiteral(), 1);
       if (Op.isLiteral()) {
         EmitVBR64(Op.getLiteralValue(), 8);
       } else {
         Emit(Op.getEncoding(), 3);
         if (Op.hasEncodingData())
           EmitVBR64(Op.getEncodingData(), 5);
       }
     }
   }
 public:
 
   /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
   /// method takes ownership of the specified abbrev.
-  unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
+  unsigned EmitAbbrev(NaClBitCodeAbbrev *Abbv) {
     // Emit the abbreviation as a record.
     EncodeAbbrev(Abbv);
     CurAbbrevs.push_back(Abbv);
     return static_cast<unsigned>(CurAbbrevs.size())-1 +
-      bitc::FIRST_APPLICATION_ABBREV;
+      naclbitc::FIRST_APPLICATION_ABBREV;
   }
 
   //===--------------------------------------------------------------------===//
   // BlockInfo Block Emission
   //===--------------------------------------------------------------------===//
 
   /// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
   void EnterBlockInfoBlock(unsigned CodeWidth) {
-    EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, CodeWidth);
+    EnterSubblock(naclbitc::BLOCKINFO_BLOCK_ID, CodeWidth);
     BlockInfoCurBID = ~0U;
   }
 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);
-    EmitRecord(bitc::BLOCKINFO_CODE_SETBID, V);
+    EmitRecord(naclbitc::BLOCKINFO_CODE_SETBID, V);
     BlockInfoCurBID = BlockID;
   }
 
   BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
     if (BlockInfo *BI = getBlockInfo(BlockID))
       return *BI;
 
     // Otherwise, add a new record.
     BlockInfoRecords.push_back(BlockInfo());
     BlockInfoRecords.back().BlockID = BlockID;
     return BlockInfoRecords.back();
   }
 
 public:
 
   /// EmitBlockInfoAbbrev - Emit a DEFINE_ABBREV record for the specified
   /// BlockID.
-  unsigned EmitBlockInfoAbbrev(unsigned BlockID, BitCodeAbbrev *Abbv) {
+  unsigned EmitBlockInfoAbbrev(unsigned BlockID, NaClBitCodeAbbrev *Abbv) {
     SwitchToBlockID(BlockID);
     EncodeAbbrev(Abbv);
 
     // Add the abbrev to the specified block record.
     BlockInfo &Info = getOrCreateBlockInfo(BlockID);
     Info.Abbrevs.push_back(Abbv);
 
-    return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
+    return Info.Abbrevs.size()-1+naclbitc::FIRST_APPLICATION_ABBREV;
   }
 };
 
 
 } // End llvm namespace
 
 #endif