Copy BitCodes.h to NaCl/NaClBitCodes.h

include/llvm/Bitcode/NaCl/NaClBitCodes.h

-//===- BitCodes.h - Enum values for the bitcode format ----------*- C++ -*-===//
+//===- NaClBitCodes.h - Enum values for the bitcode format ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header Bitcode enum values.
 //
 // The enum values defined in this file should be considered permanent.  If
 // new features are added, they should have values added at the end of the
 // respective lists.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_BITCODE_BITCODES_H
-#define LLVM_BITCODE_BITCODES_H
+#ifndef LLVM_BITCODE_NACL_NACLBITCODES_H
+#define LLVM_BITCODE_NACL_NACLBITCODES_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 
 namespace llvm {
-namespace bitc {
+namespace naclbitc {
   enum StandardWidths {
     BlockIDWidth   = 8,  // We use VBR-8 for block IDs.
     CodeLenWidth   = 4,  // Codelen are VBR-4.
     BlockSizeWidth = 32  // BlockSize up to 2^32 32-bit words = 16GB per block.
   };
 
   // The standard abbrev namespace always has a way to exit a block, enter a
   // nested block, define abbrevs, and define an unabbreviated record.
   enum FixedAbbrevIDs {
     END_BLOCK = 0,  // Must be zero to guarantee termination for broken bitcode.
@@ skipping 31 matching lines @@
   enum BlockInfoCodes {
     // DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
     // block, instead of the BlockInfo block.
 
     BLOCKINFO_CODE_SETBID        = 1, // SETBID: [blockid#]
     BLOCKINFO_CODE_BLOCKNAME     = 2, // BLOCKNAME: [name]
     BLOCKINFO_CODE_SETRECORDNAME = 3  // BLOCKINFO_CODE_SETRECORDNAME:
                                       //                             [id, name]
   };
 
 } // End bitc namespace

[jvoung (off chromium), 2013/05/01 23:41:13]

naclbitc

[Karl, 2013/05/02 14:32:14]

Done.

 
-/// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
+/// NaClBitCodeAbbrevOp - This describes one or more operands in an abbreviation.
 /// This is actually a union of two different things:
 ///   1. It could be a literal integer value ("the operand is always 17").
 ///   2. It could be an encoding specification ("this operand encoded like so").
 ///
-class BitCodeAbbrevOp {
+class NaClBitCodeAbbrevOp {
   uint64_t Val;           // A literal value or data for an encoding.
   bool IsLiteral : 1;     // Indicate whether this is a literal value or not.
   unsigned Enc   : 3;     // The encoding to use.
 public:
   enum Encoding {
     Fixed = 1,  // A fixed width field, Val specifies number of bits.
     VBR   = 2,  // A VBR field where Val specifies the width of each chunk.
     Array = 3,  // A sequence of fields, next field species elt encoding.
     Char6 = 4,  // A 6-bit fixed field which maps to [a-zA-Z0-9._].
     Blob  = 5   // 32-bit aligned array of 8-bit characters.
   };
 
-  explicit BitCodeAbbrevOp(uint64_t V) :  Val(V), IsLiteral(true) {}
-  explicit BitCodeAbbrevOp(Encoding E, uint64_t Data = 0)
+  explicit NaClBitCodeAbbrevOp(uint64_t V) :  Val(V), IsLiteral(true) {}
+  explicit NaClBitCodeAbbrevOp(Encoding E, uint64_t Data = 0)
     : Val(Data), IsLiteral(false), Enc(E) {}
 
   bool isLiteral() const  { return IsLiteral; }
   bool isEncoding() const { return !IsLiteral; }
 
   // Accessors for literals.
   uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
 
   // Accessors for encoding info.
   Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
@@ skipping 38 matching lines @@
     if (V < 26)       return V+'a';
     if (V < 26+26)    return V-26+'A';
     if (V < 26+26+10) return V-26-26+'0';
     if (V == 62)      return '.';
     if (V == 63)      return '_';
     llvm_unreachable("Not a value Char6 character!");
   }
 
 };
 
-template <> struct isPodLike<BitCodeAbbrevOp> { static const bool value=true; };
+template <> struct isPodLike<NaClBitCodeAbbrevOp> {
+  static const bool value=true;
+};
 
-/// BitCodeAbbrev - This class represents an abbreviation record.  An
+/// NaClBitCodeAbbrev - This class represents an abbreviation record.  An
 /// abbreviation allows a complex record that has redundancy to be stored in a
 /// specialized format instead of the fully-general, fully-vbr, format.
-class BitCodeAbbrev {
-  SmallVector<BitCodeAbbrevOp, 32> OperandList;
+class NaClBitCodeAbbrev {
+  SmallVector<NaClBitCodeAbbrevOp, 32> OperandList;
   unsigned char RefCount; // Number of things using this.
-  ~BitCodeAbbrev() {}
+  ~NaClBitCodeAbbrev() {}
 public:
-  BitCodeAbbrev() : RefCount(1) {}
+  NaClBitCodeAbbrev() : RefCount(1) {}
 
   void addRef() { ++RefCount; }
   void dropRef() { if (--RefCount == 0) delete this; }
 
   unsigned getNumOperandInfos() const {
     return static_cast<unsigned>(OperandList.size());
   }
-  const BitCodeAbbrevOp &getOperandInfo(unsigned N) const {
+  const NaClBitCodeAbbrevOp &getOperandInfo(unsigned N) const {
     return OperandList[N];
   }
 
-  void Add(const BitCodeAbbrevOp &OpInfo) {
+  void Add(const NaClBitCodeAbbrevOp &OpInfo) {
     OperandList.push_back(OpInfo);
   }
 };
 } // End llvm namespace
 
 #endif