X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FBitcode%2FBitCodes.h;h=449dc35d7de2edcaeb3e1febf9d8f787b6a7fa2a;hb=770772e831d1ff1dfbc0e94fb3212437e597d7a5;hp=2cf8b7b72347a2c4a858cee470711200bb892fbc;hpb=e17b658c792abd4a1552144b8a8808e44970da76;p=oota-llvm.git diff --git a/include/llvm/Bitcode/BitCodes.h b/include/llvm/Bitcode/BitCodes.h index 2cf8b7b7234..449dc35d7de 100644 --- a/include/llvm/Bitcode/BitCodes.h +++ b/include/llvm/Bitcode/BitCodes.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -27,9 +27,9 @@ namespace bitc { 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 = 32GB per block. + 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 { @@ -41,16 +41,16 @@ namespace bitc { /// single bit to indicate if it is a literal encoding. If so, the value is /// emitted with a vbr8. If not, the encoding is emitted as 3 bits followed /// by the info value as a vbr5 if needed. - DEFINE_ABBREV = 2, - + DEFINE_ABBREV = 2, + // UNABBREV_RECORDs are emitted with a vbr6 for the record code, followed by // a vbr6 for the # operands, followed by vbr6's for each operand. UNABBREV_RECORD = 3, - + // This is not a code, this is a marker for the first abbrev assignment. FIRST_APPLICATION_ABBREV = 4 }; - + /// StandardBlockIDs - All bitcode files can optionally include a BLOCKINFO /// block, which contains metadata about other blocks in the file. enum StandardBlockIDs { @@ -58,20 +58,22 @@ namespace bitc { /// standard abbrevs that should be available to all blocks of a specified /// ID. BLOCKINFO_BLOCK_ID = 0, - + // Block IDs 1-7 are reserved for future expansion. FIRST_APPLICATION_BLOCKID = 8 }; - + /// BlockInfoCodes - The blockinfo block contains metadata about user-defined /// blocks. enum BlockInfoCodes { - BLOCKINFO_CODE_SETBID = 1 // SETBID: [blockid#] // DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd // block, instead of the BlockInfo block. - // BLOCKNAME: give string name to block, if desired. + + BLOCKINFO_CODE_SETBID = 1, // SETBID: [blockid#] + BLOCKINFO_CODE_BLOCKNAME = 2, // BLOCKNAME: [name] + BLOCKINFO_CODE_SETRECORDNAME = 3 // BLOCKINFO_CODE_SETRECORDNAME: [id, name] }; - + } // End bitc namespace /// BitCodeAbbrevOp - This describes one or more operands in an abbreviation. @@ -85,29 +87,30 @@ class BitCodeAbbrevOp { unsigned Enc : 3; // The encoding to use. public: enum Encoding { - Fixed = 1, // A fixed with field, Val specifies number of bits. + 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. + 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. }; - - BitCodeAbbrevOp(uint64_t V) : Val(V), IsLiteral(true) {} - BitCodeAbbrevOp(Encoding E, uint64_t Data = 0) + + explicit BitCodeAbbrevOp(uint64_t V) : Val(V), IsLiteral(true) {} + explicit BitCodeAbbrevOp(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; } uint64_t getEncodingData() const { assert(isEncoding() && hasEncodingData()); return Val; } - + bool hasEncodingData() const { return hasEncodingData(getEncoding()); } static bool hasEncodingData(Encoding E) { switch (E) { @@ -116,9 +119,41 @@ public: case VBR: return true; case Array: + case Char6: + case Blob: return false; } } + + /// isChar6 - Return true if this character is legal in the Char6 encoding. + static bool isChar6(char C) { + if (C >= 'a' && C <= 'z') return true; + if (C >= 'A' && C <= 'Z') return true; + if (C >= '0' && C <= '9') return true; + if (C == '.' || C == '_') return true; + return false; + } + static unsigned EncodeChar6(char C) { + if (C >= 'a' && C <= 'z') return C-'a'; + if (C >= 'A' && C <= 'Z') return C-'A'+26; + if (C >= '0' && C <= '9') return C-'0'+26+26; + if (C == '.') return 62; + if (C == '_') return 63; + assert(0 && "Not a value Char6 character!"); + return 0; + } + + static char DecodeChar6(unsigned V) { + assert((V & ~63) == 0 && "Not a Char6 encoded character!"); + 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 '_'; + assert(0 && "Not a value Char6 character!"); + return ' '; + } + }; /// BitCodeAbbrev - This class represents an abbreviation record. An @@ -130,15 +165,17 @@ class BitCodeAbbrev { ~BitCodeAbbrev() {} public: BitCodeAbbrev() : RefCount(1) {} - + void addRef() { ++RefCount; } void dropRef() { if (--RefCount == 0) delete this; } - unsigned getNumOperandInfos() const { return OperandList.size(); } + unsigned getNumOperandInfos() const { + return static_cast(OperandList.size()); + } const BitCodeAbbrevOp &getOperandInfo(unsigned N) const { return OperandList[N]; } - + void Add(const BitCodeAbbrevOp &OpInfo) { OperandList.push_back(OpInfo); }