From: Misha Brukman Date: Fri, 20 Feb 2009 23:04:06 +0000 (+0000) Subject: Removed trailing whitespace. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=d3ff4a188e823baa141c288d31eb532ddf632b6e;p=oota-llvm.git Removed trailing whitespace. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@65199 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Bitcode/Archive.h b/include/llvm/Bitcode/Archive.h index 6ba11531ddb..a3631ace545 100644 --- a/include/llvm/Bitcode/Archive.h +++ b/include/llvm/Bitcode/Archive.h @@ -204,7 +204,7 @@ class ArchiveMember : public ilist_node { /// applications and the linkers. Consequently, the implementation of the class /// is optimized for reading. class Archive { - + /// @name Types /// @{ public: @@ -485,7 +485,7 @@ class Archive { void writeSymbolTable(std::ofstream& ARFile); /// Writes one ArchiveMember to an ofstream. If an error occurs, returns - /// false, otherwise true. If an error occurs and error is non-null then + /// false, otherwise true. If an error occurs and error is non-null then /// it will be set to an error message. /// @returns false Writing member succeeded /// @returns true Writing member failed, \p error set to error message diff --git a/include/llvm/Bitcode/BitCodes.h b/include/llvm/Bitcode/BitCodes.h index 111b1e4fea1..277ae9e1d41 100644 --- a/include/llvm/Bitcode/BitCodes.h +++ b/include/llvm/Bitcode/BitCodes.h @@ -29,7 +29,7 @@ namespace bitc { 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 { @@ -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,11 +58,11 @@ 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 { @@ -71,7 +71,7 @@ namespace bitc { // block, instead of the BlockInfo block. // BLOCKNAME: give string name to block, if desired. }; - + } // End bitc namespace /// BitCodeAbbrevOp - This describes one or more operands in an abbreviation. @@ -90,24 +90,24 @@ public: 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._]. }; - + 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) { @@ -120,7 +120,7 @@ public: 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; @@ -138,7 +138,7 @@ public: 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'; @@ -149,7 +149,7 @@ public: assert(0 && "Not a value Char6 character!"); return ' '; } - + }; /// BitCodeAbbrev - This class represents an abbreviation record. An @@ -161,7 +161,7 @@ class BitCodeAbbrev { ~BitCodeAbbrev() {} public: BitCodeAbbrev() : RefCount(1) {} - + void addRef() { ++RefCount; } void dropRef() { if (--RefCount == 0) delete this; } @@ -171,7 +171,7 @@ public: const BitCodeAbbrevOp &getOperandInfo(unsigned N) const { return OperandList[N]; } - + void Add(const BitCodeAbbrevOp &OpInfo) { OperandList.push_back(OpInfo); } diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h index 3b7a9b61e6a..7cbd10f532c 100644 --- a/include/llvm/Bitcode/BitstreamReader.h +++ b/include/llvm/Bitcode/BitstreamReader.h @@ -19,35 +19,35 @@ #include namespace llvm { - + class Deserializer; - + class BitstreamReader { const unsigned char *NextChar; const unsigned char *LastChar; friend class Deserializer; - + /// CurWord - This is the current data we have pulled from the stream but have /// not returned to the client. uint32_t CurWord; - + /// BitsInCurWord - This is the number of bits in CurWord that are valid. This /// is always from [0...31] inclusive. 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 CurAbbrevs; - + struct Block { unsigned PrevCodeSize; std::vector PrevAbbrevs; explicit Block(unsigned PCS) : PrevCodeSize(PCS) {} }; - + /// BlockScope - This tracks the codesize of parent blocks. SmallVector BlockScope; @@ -58,7 +58,7 @@ class BitstreamReader { std::vector Abbrevs; }; std::vector BlockInfoRecords; - + /// FirstChar - This remembers the first byte of the stream. const unsigned char *FirstChar; public: @@ -72,7 +72,7 @@ public: BitstreamReader(const unsigned char *Start, const unsigned char *End) { init(Start, End); } - + void init(const unsigned char *Start, const unsigned char *End) { NextChar = FirstChar = Start; LastChar = End; @@ -81,7 +81,7 @@ public: BitsInCurWord = 0; CurCodeSize = 2; } - + ~BitstreamReader() { // Abbrevs could still exist if the stream was broken. If so, don't leak // them. @@ -96,7 +96,7 @@ public: i != e; ++i) Abbrevs[i]->dropRef(); } - + // Free the BlockInfoRecords. while (!BlockInfoRecords.empty()) { BlockInfo &Info = BlockInfoRecords.back(); @@ -107,37 +107,37 @@ public: BlockInfoRecords.pop_back(); } } - + bool AtEndOfStream() const { return NextChar == LastChar && BitsInCurWord == 0; } - + /// GetCurrentBitNo - Return the bit # of the bit we are reading. uint64_t GetCurrentBitNo() const { return (NextChar-FirstChar)*8 + ((32-BitsInCurWord) & 31); } - + /// JumpToBit - Reset the stream to the specified bit number. void JumpToBit(uint64_t BitNo) { uintptr_t ByteNo = uintptr_t(BitNo/8) & ~3; uintptr_t WordBitNo = uintptr_t(BitNo) & 31; assert(ByteNo < (uintptr_t)(LastChar-FirstChar) && "Invalid location"); - + // Move the cursor to the right word. NextChar = FirstChar+ByteNo; BitsInCurWord = 0; CurWord = 0; - + // Skip over any bits that are already consumed. if (WordBitNo) { NextChar -= 4; Read(static_cast(WordBitNo)); } } - + /// GetAbbrevIDWidth - Return the number of bits used to encode an abbrev #. unsigned GetAbbrevIDWidth() const { return CurCodeSize; } - + uint32_t Read(unsigned NumBits) { // If the field is fully contained by CurWord, return it quickly. if (BitsInCurWord >= NumBits) { @@ -153,20 +153,20 @@ public: BitsInCurWord = 0; return 0; } - + unsigned R = CurWord; // Read the next word from the stream. CurWord = (NextChar[0] << 0) | (NextChar[1] << 8) | (NextChar[2] << 16) | (NextChar[3] << 24); NextChar += 4; - + // Extract NumBits-BitsInCurWord from what we just read. unsigned BitsLeft = NumBits-BitsInCurWord; - + // Be careful here, BitsLeft is in the range [1..32] inclusive. R |= (CurWord & (~0U >> (32-BitsLeft))) << BitsInCurWord; - + // BitsLeft bits have just been used up from CurWord. if (BitsLeft != 32) CurWord >>= BitsLeft; @@ -175,14 +175,14 @@ public: BitsInCurWord = 32-BitsLeft; return R; } - + uint64_t Read64(unsigned NumBits) { if (NumBits <= 32) return Read(NumBits); - + uint64_t V = Read(32); return V | (uint64_t)Read(NumBits-32) << 32; } - + uint32_t ReadVBR(unsigned NumBits) { uint32_t Piece = Read(NumBits); if ((Piece & (1U << (NumBits-1))) == 0) @@ -195,25 +195,25 @@ public: if ((Piece & (1U << (NumBits-1))) == 0) return Result; - + NextBit += NumBits-1; Piece = Read(NumBits); } } - + uint64_t ReadVBR64(unsigned NumBits) { uint64_t Piece = Read(NumBits); if ((Piece & (1U << (NumBits-1))) == 0) return Piece; - + uint64_t Result = 0; unsigned NextBit = 0; while (1) { Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit; - + if ((Piece & (1U << (NumBits-1))) == 0) return Result; - + NextBit += NumBits-1; Piece = Read(NumBits); } @@ -224,7 +224,7 @@ public: CurWord = 0; } - + unsigned ReadCode() { return Read(CurCodeSize); } @@ -232,7 +232,7 @@ public: //===--------------------------------------------------------------------===// // Block Manipulation //===--------------------------------------------------------------------===// - + private: /// getBlockInfo - If there is block info for the specified ID, return it, /// otherwise return null. @@ -240,7 +240,7 @@ private: // Common case, the most recent entry matches BlockID. if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID) return &BlockInfoRecords.back(); - + for (unsigned i = 0, e = static_cast(BlockInfoRecords.size()); i != e; ++i) if (BlockInfoRecords[i].BlockID == BlockID) @@ -248,8 +248,8 @@ private: return 0; } public: - - + + // Block header: // [ENTER_SUBBLOCK, blockid, newcodelen, , blocklen] @@ -258,7 +258,7 @@ public: unsigned ReadSubBlockID() { return ReadVBR(bitc::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. @@ -268,23 +268,23 @@ public: ReadVBR(bitc::CodeLenWidth); SkipToWord(); unsigned NumWords = Read(bitc::BlockSizeWidth); - + // Check that the block wasn't partially defined, and that the offset isn't // bogus. if (AtEndOfStream() || NextChar+NumWords*4 > LastChar) return true; - + NextChar += NumWords*4; return false; } - + /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter /// the block, and return true if the block is valid. bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = 0) { // Save the current block's state on BlockScope. BlockScope.push_back(Block(CurCodeSize)); BlockScope.back().PrevAbbrevs.swap(CurAbbrevs); - + // Add the abbrevs specific to this block to the CurAbbrevs list. if (BlockInfo *Info = getBlockInfo(BlockID)) { for (unsigned i = 0, e = static_cast(Info->Abbrevs.size()); @@ -293,50 +293,50 @@ public: CurAbbrevs.back()->addRef(); } } - + // Get the codesize of this block. CurCodeSize = ReadVBR(bitc::CodeLenWidth); SkipToWord(); unsigned NumWords = Read(bitc::BlockSizeWidth); if (NumWordsP) *NumWordsP = NumWords; - + // Validate that this block is sane. if (CurCodeSize == 0 || AtEndOfStream() || NextChar+NumWords*4 > LastChar) return true; - + return false; } - + bool ReadBlockEnd() { if (BlockScope.empty()) return true; - + // Block tail: // [END_BLOCK, ] SkipToWord(); - + PopBlockScope(); return false; } - + private: void PopBlockScope() { CurCodeSize = BlockScope.back().PrevCodeSize; - + // Delete abbrevs from popped scope. for (unsigned i = 0, e = static_cast(CurAbbrevs.size()); i != e; ++i) CurAbbrevs[i]->dropRef(); - + BlockScope.back().PrevAbbrevs.swap(CurAbbrevs); BlockScope.pop_back(); - } - + } + //===--------------------------------------------------------------------===// // Record Processing //===--------------------------------------------------------------------===// - + private: - void ReadAbbreviatedField(const BitCodeAbbrevOp &Op, + void ReadAbbreviatedField(const BitCodeAbbrevOp &Op, SmallVectorImpl &Vals) { if (Op.isLiteral()) { // If the abbrev specifies the literal value to use, use it. @@ -366,7 +366,7 @@ public: Vals.push_back(ReadVBR64(6)); return Code; } - + unsigned AbbrevNo = AbbrevID-bitc::FIRST_APPLICATION_ABBREV; assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!"); BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo]; @@ -388,16 +388,16 @@ public: ReadAbbreviatedField(EltEnc, Vals); } } - + unsigned Code = (unsigned)Vals[0]; Vals.erase(Vals.begin()); return Code; } - + //===--------------------------------------------------------------------===// // Abbrev Processing //===--------------------------------------------------------------------===// - + void ReadAbbrevRecord() { BitCodeAbbrev *Abbv = new BitCodeAbbrev(); unsigned NumOpInfo = ReadVBR(5); @@ -416,30 +416,30 @@ public: } CurAbbrevs.push_back(Abbv); } - + //===--------------------------------------------------------------------===// // BlockInfo Block Reading //===--------------------------------------------------------------------===// - -private: + +private: 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: - + bool ReadBlockInfoBlock() { if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true; SmallVector Record; BlockInfo *CurBlockInfo = 0; - + // Read all the records for this module. while (1) { unsigned Code = ReadCode(); @@ -455,7 +455,7 @@ public: if (Code == bitc::DEFINE_ABBREV) { if (!CurBlockInfo) return true; ReadAbbrevRecord(); - + // ReadAbbrevRecord installs the abbrev in CurAbbrevs. Move it to the // appropriate BlockInfo. BitCodeAbbrev *Abbv = CurAbbrevs.back(); @@ -473,7 +473,7 @@ public: CurBlockInfo = &getOrCreateBlockInfo((unsigned)Record[0]); break; } - } + } } }; diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h index 7fd23fe4166..aed7c2f48a1 100644 --- a/include/llvm/Bitcode/BitstreamWriter.h +++ b/include/llvm/Bitcode/BitstreamWriter.h @@ -25,10 +25,10 @@ class BitstreamWriter { /// 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; @@ -36,7 +36,7 @@ class BitstreamWriter { /// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently /// selected BLOCK ID. unsigned BlockInfoCurBID; - + /// CurAbbrevs - Abbrevs installed at in this block. std::vector CurAbbrevs; @@ -46,10 +46,10 @@ class BitstreamWriter { std::vector PrevAbbrevs; Block(unsigned PCS, unsigned SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {} }; - + /// BlockScope - This tracks the current blocks that we have entered. std::vector BlockScope; - + /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks. /// These describe abbreviations that all blocks of the specified ID inherit. struct BlockInfo { @@ -57,15 +57,15 @@ class BitstreamWriter { std::vector Abbrevs; }; std::vector BlockInfoRecords; - + public: - explicit BitstreamWriter(std::vector &O) + explicit BitstreamWriter(std::vector &O) : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {} ~BitstreamWriter() { assert(CurBit == 0 && "Unflused data remaining"); assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance"); - + // Free the BlockInfoRecords. while (!BlockInfoRecords.empty()) { BlockInfo &Info = BlockInfoRecords.back(); @@ -82,7 +82,7 @@ public: //===--------------------------------------------------------------------===// // Basic Primitives for emitting bits to the stream. //===--------------------------------------------------------------------===// - + void Emit(uint32_t Val, unsigned NumBits) { assert(NumBits <= 32 && "Invalid value size!"); assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!"); @@ -91,21 +91,21 @@ public: CurBit += NumBits; return; } - + // Add the current word. unsigned V = CurValue; Out.push_back((unsigned char)(V >> 0)); Out.push_back((unsigned char)(V >> 8)); Out.push_back((unsigned char)(V >> 16)); Out.push_back((unsigned char)(V >> 24)); - + if (CurBit) CurValue = Val >> (32-CurBit); else CurValue = 0; CurBit = (CurBit+NumBits) & 31; } - + void Emit64(uint64_t Val, unsigned NumBits) { if (NumBits <= 32) Emit((uint32_t)Val, NumBits); @@ -114,7 +114,7 @@ public: Emit((uint32_t)(Val >> 32), NumBits-32); } } - + void FlushToWord() { if (CurBit) { unsigned V = CurValue; @@ -126,40 +126,40 @@ public: CurValue = 0; } } - + void EmitVBR(uint32_t Val, unsigned NumBits) { uint32_t Threshold = 1U << (NumBits-1); - + // Emit the bits with VBR encoding, NumBits-1 bits at a time. while (Val >= Threshold) { Emit((Val & ((1 << (NumBits-1))-1)) | (1 << (NumBits-1)), NumBits); Val >>= NumBits-1; } - + Emit(Val, NumBits); } - + void EmitVBR64(uint64_t Val, unsigned NumBits) { if ((uint32_t)Val == Val) return EmitVBR((uint32_t)Val, NumBits); - + uint64_t Threshold = 1U << (NumBits-1); - + // Emit the bits with VBR encoding, NumBits-1 bits at a time. while (Val >= Threshold) { Emit(((uint32_t)Val & ((1 << (NumBits-1))-1)) | (1 << (NumBits-1)), NumBits); Val >>= NumBits-1; } - + Emit((uint32_t)Val, NumBits); } - + /// EmitCode - Emit the specified code. void EmitCode(unsigned Val) { Emit(Val, CurCodeSize); } - + // BackpatchWord - Backpatch a 32-bit word in the output with the specified // value. void BackpatchWord(unsigned ByteNo, unsigned NewWord) { @@ -168,25 +168,25 @@ public: Out[ByteNo++] = (unsigned char)(NewWord >> 16); Out[ByteNo ] = (unsigned char)(NewWord >> 24); } - + //===--------------------------------------------------------------------===// // Block Manipulation //===--------------------------------------------------------------------===// - + /// getBlockInfo - If there is block info for the specified ID, return it, /// otherwise return null. BlockInfo *getBlockInfo(unsigned BlockID) { // Common case, the most recent entry matches BlockID. if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID) return &BlockInfoRecords.back(); - + for (unsigned i = 0, e = static_cast(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, , blocklen] @@ -194,15 +194,15 @@ public: EmitVBR(BlockID, bitc::BlockIDWidth); EmitVBR(CodeLen, bitc::CodeLenWidth); FlushToWord(); - + unsigned BlockSizeWordLoc = static_cast(Out.size()); unsigned OldCodeSize = CurCodeSize; - + // Emit a placeholder, which will be replaced when the block is popped. Emit(0, bitc::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, BlockSizeWordLoc/4)); @@ -218,17 +218,17 @@ public: } } } - + void ExitBlock() { assert(!BlockScope.empty() && "Block scope imbalance!"); - + // Delete all abbrevs. for (unsigned i = 0, e = static_cast(CurAbbrevs.size()); i != e; ++i) CurAbbrevs[i]->dropRef(); - + const Block &B = BlockScope.back(); - + // Block tail: // [END_BLOCK, ] EmitCode(bitc::END_BLOCK); @@ -237,20 +237,20 @@ public: // Compute the size of the block, in words, not counting the size field. unsigned SizeInWords= static_cast(Out.size())/4-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: /// EmitAbbreviatedField - Emit a single scalar field value with the specified /// encoding. @@ -263,7 +263,7 @@ private: "Invalid abbrev for record!"); return; } - + // Encode the value as we are commanded. switch (Op.getEncoding()) { default: assert(0 && "Unknown encoding!"); @@ -276,10 +276,10 @@ private: case BitCodeAbbrevOp::Char6: Emit(BitCodeAbbrevOp::EncodeChar6((char)V), 6); break; - } + } } public: - + /// EmitRecord - Emit the specified record to the stream, using an abbrev if /// we have one to compress the output. template @@ -289,12 +289,12 @@ public: unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV; assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!"); BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo]; - + EmitCode(Abbrev); - + // Insert the code into Vals to treat it uniformly. Vals.insert(Vals.begin(), Code); - + unsigned RecordIdx = 0; for (unsigned i = 0, e = static_cast(Abbv->getNumOperandInfos()); i != e; ++i) { @@ -307,10 +307,10 @@ public: // Array case. assert(i+2 == e && "array op not second to last?"); const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); - + // Emit a vbr6 to indicate the number of elements present. EmitVBR(static_cast(Vals.size()-RecordIdx), 6); - + // Emit each field. for (; RecordIdx != Vals.size(); ++RecordIdx) EmitAbbreviatedField(EltEnc, Vals[RecordIdx]); @@ -331,7 +331,7 @@ public: //===--------------------------------------------------------------------===// // Abbrev Emission //===--------------------------------------------------------------------===// - + private: // Emit the abbreviation as a DEFINE_ABBREV record. void EncodeAbbrev(BitCodeAbbrev *Abbv) { @@ -351,7 +351,7 @@ private: } } public: - + /// EmitAbbrev - This emits an abbreviation to the stream. Note that this /// method takes ownership of the specified abbrev. unsigned EmitAbbrev(BitCodeAbbrev *Abbv) { @@ -361,17 +361,17 @@ public: return static_cast(CurAbbrevs.size())-1 + bitc::FIRST_APPLICATION_ABBREV; } - + //===--------------------------------------------------------------------===// // BlockInfo Block Emission //===--------------------------------------------------------------------===// - + /// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK. void EnterBlockInfoBlock(unsigned CodeWidth) { EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, CodeWidth); BlockInfoCurBID = -1U; } -private: +private: /// SwitchToBlockID - If we aren't already talking about the specified block /// ID, emit a BLOCKINFO_CODE_SETBID record. void SwitchToBlockID(unsigned BlockID) { @@ -385,25 +385,25 @@ private: 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) { 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; } }; diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h index 8c9ea89d152..cc85d9fb5e8 100644 --- a/include/llvm/Bitcode/Deserialize.h +++ b/include/llvm/Bitcode/Deserialize.h @@ -24,44 +24,44 @@ #include namespace llvm { - -class Deserializer { + +class Deserializer { //===----------------------------------------------------------===// // Internal type definitions. //===----------------------------------------------------------===// - + struct BPNode { BPNode* Next; uintptr_t& PtrRef; - - BPNode(BPNode* n, uintptr_t& pref) + + BPNode(BPNode* n, uintptr_t& pref) : Next(n), PtrRef(pref) { PtrRef = 0; } }; - - struct BPEntry { + + struct BPEntry { union { BPNode* Head; void* Ptr; }; - + BPEntry() : Head(NULL) {} - + static inline bool isPod() { return true; } - - void SetPtr(BPNode*& FreeList, void* P); - }; - + + void SetPtr(BPNode*& FreeList, void* P); + }; + class BPKey { unsigned Raw; - + public: BPKey(SerializedPtrID PtrId) : Raw(PtrId << 1) { assert (PtrId > 0); } BPKey(unsigned code, unsigned) : Raw(code) {} - + void MarkFinal() { Raw |= 0x1; } bool hasFinalPtr() const { return Raw & 0x1 ? true : false; } SerializedPtrID getID() const { return Raw >> 1; } - + static inline BPKey getEmptyKey() { return BPKey(0,0); } static inline BPKey getTombstoneKey() { return BPKey(1,0); } static inline unsigned getHashValue(const BPKey& K) { return K.Raw & ~0x1; } @@ -69,25 +69,25 @@ class Deserializer { static bool isEqual(const BPKey& K1, const BPKey& K2) { return (K1.Raw ^ K2.Raw) & ~0x1 ? false : true; } - + static bool isPod() { return true; } }; - + typedef llvm::DenseMap MapTy; //===----------------------------------------------------------===// // Publicly visible types. //===----------------------------------------------------------===// - -public: + +public: struct Location { uint64_t BitNo; unsigned BlockID; unsigned NumWords; - - Location(uint64_t bit, unsigned bid, unsigned words) + + Location(uint64_t bit, unsigned bid, unsigned words) : BitNo(bit), BlockID(bid), NumWords(words) {} - + Location() : BitNo(0), BlockID(0), NumWords(0) {} Location& operator=(Location& RHS) { @@ -96,21 +96,21 @@ public: NumWords = RHS.NumWords; return *this; } - - bool operator==(const Location& RHS) const { return BitNo == RHS.BitNo; } + + bool operator==(const Location& RHS) const { return BitNo == RHS.BitNo; } bool operator!=(const Location& RHS) const { return BitNo != RHS.BitNo; } - + bool contains(const Location& RHS) const { if (RHS.BitNo < BitNo) return false; if ((RHS.BitNo - BitNo) >> 5 < NumWords) return true; - + return false; } }; - + //===----------------------------------------------------------===// // Internal data members. //===----------------------------------------------------------===// @@ -126,20 +126,20 @@ private: unsigned AbbrevNo; unsigned RecordCode; uint64_t StreamStart; - + //===----------------------------------------------------------===// // Public Interface. //===----------------------------------------------------------===// - -public: + +public: Deserializer(BitstreamReader& stream); ~Deserializer(); uint64_t ReadInt(); int64_t ReadSInt(); SerializedPtrID ReadPtrID() { return (SerializedPtrID) ReadInt(); } - - + + bool ReadBool() { return ReadInt() ? true : false; } @@ -154,22 +154,22 @@ public: inline T* Create() { return SerializeTrait::Create(*this); } - + char* ReadCStr(char* cstr = NULL, unsigned MaxLen=0, bool isNullTerm=true); void ReadCStr(std::vector& buff, bool isNullTerm=false, unsigned Idx=0); template inline T* ReadOwnedPtr(bool AutoRegister = true) { - SerializedPtrID PtrID = ReadPtrID(); + SerializedPtrID PtrID = ReadPtrID(); if (!PtrID) return NULL; - + T* x = SerializeTrait::Create(*this); if (AutoRegister) RegisterPtr(PtrID,x); - + return x; } @@ -192,7 +192,7 @@ public: inline void ReadOwnedPtr(T*& Ptr, bool AutoRegister = true) { Ptr = ReadOwnedPtr(AutoRegister); } - + template void BatchReadOwnedPtrs(T1*& P1, T2*& P2, bool A1=true, bool A2=true) { @@ -224,17 +224,17 @@ public: template void BatchReadOwnedPtrs(T1*& P1, T2*& P2, T3*& P3, bool A1=true, bool A2=true, bool A3=true) { - + SerializedPtrID ID1 = ReadPtrID(); SerializedPtrID ID2 = ReadPtrID(); SerializedPtrID ID3 = ReadPtrID(); - + P1 = (ID1) ? SerializeTrait::Create(*this) : NULL; - if (ID1 && A1) RegisterPtr(ID1,P1); - + if (ID1 && A1) RegisterPtr(ID1,P1); + P2 = (ID2) ? SerializeTrait::Create(*this) : NULL; if (ID2 && A2) RegisterPtr(ID2,P2); - + P3 = (ID3) ? SerializeTrait::Create(*this) : NULL; if (ID3 && A3) RegisterPtr(ID3,P3); } @@ -260,22 +260,22 @@ public: template void BatchReadOwnedPtrs(unsigned NumPtrs, T** Ptrs, bool AutoRegister=true) { llvm::SmallVector BatchIDVec; - + for (unsigned i = 0; i < NumPtrs; ++i) BatchIDVec.push_back(ReadPtrID()); - + for (unsigned i = 0; i < NumPtrs; ++i) { SerializedPtrID& PtrID = BatchIDVec[i]; - + T* p = PtrID ? SerializeTrait::Create(*this) : NULL; - + if (PtrID && AutoRegister) RegisterPtr(PtrID,p); - + Ptrs[i] = p; } } - + template void BatchReadOwnedPtrs(unsigned NumPtrs, T** Ptrs, Arg1& arg1, bool AutoRegister=true) { @@ -300,29 +300,29 @@ public: template void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, T2*& P2, bool A1=true, bool A2=true) { - + llvm::SmallVector BatchIDVec; for (unsigned i = 0; i < NumT1Ptrs; ++i) BatchIDVec.push_back(ReadPtrID()); - + SerializedPtrID ID2 = ReadPtrID(); - + for (unsigned i = 0; i < NumT1Ptrs; ++i) { SerializedPtrID& PtrID = BatchIDVec[i]; - + T1* p = PtrID ? SerializeTrait::Create(*this) : NULL; - + if (PtrID && A1) RegisterPtr(PtrID,p); - + Ptrs[i] = p; } - + P2 = (ID2) ? SerializeTrait::Create(*this) : NULL; - if (ID2 && A2) RegisterPtr(ID2,P2); - } - + if (ID2 && A2) RegisterPtr(ID2,P2); + } + template void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, T2*& P2, Arg1& arg1, bool A1=true, bool A2=true) { @@ -350,35 +350,35 @@ public: } template - void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, + void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, T2*& P2, T3*& P3, bool A1=true, bool A2=true, bool A3=true) { - + llvm::SmallVector BatchIDVec; - + for (unsigned i = 0; i < NumT1Ptrs; ++i) BatchIDVec.push_back(ReadPtrID()); - + SerializedPtrID ID2 = ReadPtrID(); - SerializedPtrID ID3 = ReadPtrID(); - + SerializedPtrID ID3 = ReadPtrID(); + for (unsigned i = 0; i < NumT1Ptrs; ++i) { SerializedPtrID& PtrID = BatchIDVec[i]; - + T1* p = PtrID ? SerializeTrait::Create(*this) : NULL; - + if (PtrID && A1) RegisterPtr(PtrID,p); - + Ptrs[i] = p; } - + P2 = (ID2) ? SerializeTrait::Create(*this) : NULL; if (ID2 && A2) RegisterPtr(ID2,P2); - + P3 = (ID3) ? SerializeTrait::Create(*this) : NULL; - if (ID3 && A3) RegisterPtr(ID3,P3); - } + if (ID3 && A3) RegisterPtr(ID3,P3); + } template void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, @@ -415,36 +415,36 @@ public: void ReadPtr(T*& PtrRef, bool AllowBackpatch = true) { ReadUIntPtr(reinterpret_cast(PtrRef), AllowBackpatch); } - + template void ReadPtr(const T*& PtrRef, bool AllowBackpatch = true) { ReadPtr(const_cast(PtrRef), AllowBackpatch); } - - + + template - void ReadPtr(T*& PtrRef, const SerializedPtrID& PtrID, + void ReadPtr(T*& PtrRef, const SerializedPtrID& PtrID, bool AllowBackpatch = true) { ReadUIntPtr(reinterpret_cast(PtrRef), PtrID, AllowBackpatch); } - + template - void ReadPtr(const T*& PtrRef, const SerializedPtrID& PtrID, + void ReadPtr(const T*& PtrRef, const SerializedPtrID& PtrID, bool AllowBackpatch = true) { - + ReadPtr(const_cast(PtrRef), PtrID, AllowBackpatch); } - + template T* ReadPtr() { T* x = 0; ReadPtr(x,false); return x; } - void ReadUIntPtr(uintptr_t& PtrRef, const SerializedPtrID& PtrID, + void ReadUIntPtr(uintptr_t& PtrRef, const SerializedPtrID& PtrID, bool AllowBackpatch = true); - + void ReadUIntPtr(uintptr_t& PtrRef, bool AllowBackpatch = true) { ReadUIntPtr(PtrRef,ReadPtrID(),AllowBackpatch); } - + template T& ReadRef() { T* p = reinterpret_cast(ReadInternalRefPtr()); @@ -452,66 +452,66 @@ public: } void RegisterPtr(const SerializedPtrID& PtrID, const void* Ptr); - + void RegisterPtr(const void* Ptr) { RegisterPtr(ReadPtrID(),Ptr); } - + template void RegisterRef(const T& x) { RegisterPtr(&x); } - + template void RegisterRef(const SerializedPtrID& PtrID, const T& x) { RegisterPtr(PtrID,&x); - } - + } + Location getCurrentBlockLocation(); unsigned getCurrentBlockID(); unsigned getAbbrevNo(); - + bool FinishedBlock(Location BlockLoc); bool JumpTo(const Location& BlockLoc); void Rewind(); - + bool AtEnd(); bool inRecord(); void SkipBlock(); bool SkipToBlock(unsigned BlockID); - + unsigned getRecordCode(); - + BitstreamReader& getStream() { return Stream; } - + private: - bool AdvanceStream(); + bool AdvanceStream(); void ReadRecord(); - + uintptr_t ReadInternalRefPtr(); - + static inline bool HasFinalPtr(MapTy::value_type& V) { return V.first.hasFinalPtr(); } - + static inline uintptr_t GetFinalPtr(MapTy::value_type& V) { return reinterpret_cast(V.second.Ptr); } - + static inline BPNode* GetBPNode(MapTy::value_type& V) { return V.second.Head; } - + static inline void SetBPNode(MapTy::value_type& V, BPNode* N) { V.second.Head = N; } - + void SetPtr(MapTy::value_type& V, const void* P) { V.first.MarkFinal(); V.second.SetPtr(FreeList,const_cast(P)); } }; - + } // end namespace llvm #endif diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h index f1809a25d09..7770b39615e 100644 --- a/include/llvm/Bitcode/LLVMBitCodes.h +++ b/include/llvm/Bitcode/LLVMBitCodes.h @@ -26,7 +26,7 @@ namespace bitc { enum BlockIDs { // Blocks MODULE_BLOCK_ID = FIRST_APPLICATION_BLOCKID, - + // Module sub-block id's. PARAMATTR_BLOCK_ID, TYPE_BLOCK_ID, @@ -35,8 +35,8 @@ namespace bitc { TYPE_SYMTAB_BLOCK_ID, VALUE_SYMTAB_BLOCK_ID }; - - + + /// MODULE blocks have a number of optional fields and subblocks. enum ModuleCodes { MODULE_CODE_VERSION = 1, // VERSION: [version#] @@ -46,32 +46,32 @@ namespace bitc { MODULE_CODE_SECTIONNAME = 5, // SECTIONNAME: [strchr x N] MODULE_CODE_DEPLIB = 6, // DEPLIB: [strchr x N] - // GLOBALVAR: [pointer type, isconst, initid, + // GLOBALVAR: [pointer type, isconst, initid, // linkage, alignment, section, visibility, threadlocal] MODULE_CODE_GLOBALVAR = 7, // FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment, // section, visibility] MODULE_CODE_FUNCTION = 8, - + // ALIAS: [alias type, aliasee val#, linkage] MODULE_CODE_ALIAS = 9, - + /// MODULE_CODE_PURGEVALS: [numvals] MODULE_CODE_PURGEVALS = 10, - + MODULE_CODE_GCNAME = 11 // GCNAME: [strchr x N] }; - + /// PARAMATTR blocks have code for defining a parameter attribute set. enum AttributeCodes { PARAMATTR_CODE_ENTRY = 1 // ENTRY: [paramidx0, attr0, paramidx1, attr1...] }; - + /// TYPE blocks have codes for each type primitive they use. enum TypeCodes { TYPE_CODE_NUMENTRY = 1, // NUMENTRY: [numentries] - + // Type Codes TYPE_CODE_VOID = 2, // VOID TYPE_CODE_FLOAT = 3, // FLOAT @@ -93,18 +93,18 @@ namespace bitc { TYPE_CODE_PPC_FP128= 15 // PPC LONG DOUBLE (2 doubles) // Any other type code is assumed to be an unknown type. }; - + // The type symbol table only has one code (TST_ENTRY_CODE). enum TypeSymtabCodes { TST_CODE_ENTRY = 1 // TST_ENTRY: [typeid, namechar x N] }; - + // The value symbol table only has one code (VST_ENTRY_CODE). enum ValueSymtabCodes { VST_CODE_ENTRY = 1, // VST_ENTRY: [valid, namechar x N] VST_CODE_BBENTRY = 2 // VST_BBENTRY: [bbid, namechar x N] }; - + // The constants block (CONSTANTS_BLOCK_ID) describes emission for each // constant and maintains an implicit current type value. enum ConstantsCodes { @@ -128,7 +128,7 @@ namespace bitc { CST_CODE_INLINEASM = 18, // INLINEASM: [sideeffect,asmstr,conststr] CST_CODE_CE_SHUFVEC_EX = 19 // SHUFVEC_EX: [opty, opval, opval, opval] }; - + /// CastOpcodes - These are values used in the bitcode files to encode which /// cast a CST_CODE_CE_CAST or a XXX refers to. The values of these enums /// have no fixed relation to the LLVM IR enum values. Changing these will @@ -147,7 +147,7 @@ namespace bitc { CAST_INTTOPTR = 10, CAST_BITCAST = 11 }; - + /// BinaryOpcodes - These are values used in the bitcode files to encode which /// binop a CST_CODE_CE_BINOP or a XXX refers to. The values of these enums /// have no fixed relation to the LLVM IR enum values. Changing these will @@ -167,13 +167,13 @@ namespace bitc { BINOP_OR = 11, BINOP_XOR = 12 }; - - + + // The function body block (FUNCTION_BLOCK_ID) describes function bodies. It // can contain a constant block (CONSTANTS_BLOCK_ID). enum FunctionCodes { FUNC_CODE_DECLAREBLOCKS = 1, // DECLAREBLOCKS: [n] - + FUNC_CODE_INST_BINOP = 2, // BINOP: [opcode, ty, opval, opval] FUNC_CODE_INST_CAST = 3, // CAST: [opcode, ty, opty, opval] FUNC_CODE_INST_GEP = 4, // GEP: [n x operands] @@ -182,14 +182,14 @@ namespace bitc { FUNC_CODE_INST_INSERTELT = 7, // INSERTELT: [ty, opval, opval, opval] FUNC_CODE_INST_SHUFFLEVEC = 8, // SHUFFLEVEC: [ty, opval, opval, opval] FUNC_CODE_INST_CMP = 9, // CMP: [opty, opval, opval, pred] - + FUNC_CODE_INST_RET = 10, // RET: [opty,opval] FUNC_CODE_INST_BR = 11, // BR: [bb#, bb#, cond] or [bb#] FUNC_CODE_INST_SWITCH = 12, // SWITCH: [opty, opval, n, n x ops] FUNC_CODE_INST_INVOKE = 13, // INVOKE: [attr, fnty, op0,op1, ...] FUNC_CODE_INST_UNWIND = 14, // UNWIND FUNC_CODE_INST_UNREACHABLE = 15, // UNREACHABLE - + FUNC_CODE_INST_PHI = 16, // PHI: [ty, val0,bb0, ...] FUNC_CODE_INST_MALLOC = 17, // MALLOC: [instty, op, align] FUNC_CODE_INST_FREE = 18, // FREE: [opty, op] diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h index 7b1e06f6553..ce5c29cf9f6 100644 --- a/include/llvm/Bitcode/ReaderWriter.h +++ b/include/llvm/Bitcode/ReaderWriter.h @@ -24,7 +24,7 @@ namespace llvm { class ModulePass; class BitstreamWriter; class raw_ostream; - + /// getBitcodeModuleProvider - Read the header of the specified bitcode buffer /// and prepare for lazy deserialization of function bodies. If successful, /// this takes ownership of 'buffer' and returns a non-null pointer. On @@ -37,11 +37,11 @@ namespace llvm { /// If an error occurs, this returns null and fills in *ErrMsg if it is /// non-null. This method *never* takes ownership of Buffer. Module *ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg = 0); - + /// WriteBitcodeToFile - Write the specified module to the specified output /// stream. void WriteBitcodeToFile(const Module *M, std::ostream &Out); - + /// WriteBitcodeToFile - Write the specified module to the specified /// raw output stream. void WriteBitcodeToFile(const Module *M, raw_ostream &Out); diff --git a/include/llvm/Bitcode/Serialization.h b/include/llvm/Bitcode/Serialization.h index 6b64f5ecb5d..2f0d35034c8 100644 --- a/include/llvm/Bitcode/Serialization.h +++ b/include/llvm/Bitcode/Serialization.h @@ -18,7 +18,7 @@ #include "llvm/Bitcode/SerializationFwd.h" namespace llvm { - + /// SerializeTrait - SerializeTrait bridges between the Serializer/Deserializer /// and the functions that serialize objects of specific types. The default /// behavior is to call static methods of the class for the object being @@ -38,7 +38,7 @@ struct SerializeTrait { static inline void Emit(Serializer& S, const T& X) { X.Emit(S); } static inline void Read(Deserializer& D, T& X) { X.Read(D); } static inline T* Create(Deserializer& D) { return T::Create(D); } - + template static inline T* Create(Deserializer& D, Arg1& arg1) { return T::Create(D, arg1); @@ -55,14 +55,14 @@ SERIALIZE_INT_TRAIT(unsigned char) SERIALIZE_INT_TRAIT(unsigned short) SERIALIZE_INT_TRAIT(unsigned int) SERIALIZE_INT_TRAIT(unsigned long) - + SERIALIZE_INT_TRAIT(signed char) SERIALIZE_INT_TRAIT(signed short) SERIALIZE_INT_TRAIT(signed int) SERIALIZE_INT_TRAIT(signed long) #undef SERIALIZE_INT_TRAIT - + } // end namespace llvm #endif diff --git a/include/llvm/Bitcode/SerializationFwd.h b/include/llvm/Bitcode/SerializationFwd.h index f15683fb4ae..722419035c7 100644 --- a/include/llvm/Bitcode/SerializationFwd.h +++ b/include/llvm/Bitcode/SerializationFwd.h @@ -17,8 +17,8 @@ namespace llvm { class Serializer; -class Deserializer; -template struct SerializeTrait; +class Deserializer; +template struct SerializeTrait; typedef unsigned SerializedPtrID; diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h index eae9e7cdc89..6fe4f0228d5 100644 --- a/include/llvm/Bitcode/Serialize.h +++ b/include/llvm/Bitcode/Serialize.h @@ -26,10 +26,10 @@ class Serializer { BitstreamWriter& Stream; SmallVector Record; unsigned BlockLevel; - + typedef DenseMap MapTy; MapTy PtrMap; - + public: explicit Serializer(BitstreamWriter& stream); ~Serializer(); @@ -37,26 +37,26 @@ public: //==------------------------------------------------==// // Template-based dispatch to emit arbitrary types. //==------------------------------------------------==// - - template + + template inline void Emit(const T& X) { SerializeTrait::Emit(*this,X); } - + //==------------------------------------------------==// // Methods to emit primitive types. - //==------------------------------------------------==// - + //==------------------------------------------------==// + void EmitInt(uint64_t X); void EmitSInt(int64_t X); - + inline void EmitBool(bool X) { EmitInt(X); } void EmitCStr(const char* beg, const char* end); void EmitCStr(const char* cstr); - + void EmitPtr(const void* ptr) { EmitInt(getPtrId(ptr)); } - + template inline void EmitRef(const T& ref) { EmitPtr(&ref); } - + // Emit a pointer and the object pointed to. (This has no relation to the // OwningPtr<> class.) template @@ -64,18 +64,18 @@ public: EmitPtr(ptr); if (ptr) SerializeTrait::Emit(*this,*ptr); } - - + + //==------------------------------------------------==// // Batch emission of pointers. //==------------------------------------------------==// - + template void BatchEmitOwnedPtrs(T1* p1, T2* p2) { EmitPtr(p1); EmitPtr(p2); if (p1) SerializeTrait::Emit(*this,*p1); - if (p2) SerializeTrait::Emit(*this,*p2); + if (p2) SerializeTrait::Emit(*this,*p2); } template @@ -87,7 +87,7 @@ public: if (p2) SerializeTrait::Emit(*this,*p2); if (p3) SerializeTrait::Emit(*this,*p3); } - + template void BatchEmitOwnedPtrs(T1* p1, T2* p2, T3* p3, T4& p4) { EmitPtr(p1); @@ -108,99 +108,99 @@ public: for (unsigned i = 0; i < NumPtrs; ++i) if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); } - + template void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs, T2* p2) { - + for (unsigned i = 0; i < NumT1Ptrs; ++i) EmitPtr(Ptrs[i]); - + EmitPtr(p2); - + for (unsigned i = 0; i < NumT1Ptrs; ++i) if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); - + if (p2) SerializeTrait::Emit(*this,*p2); } - + template void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs, T2* p2, T3* p3) { - + for (unsigned i = 0; i < NumT1Ptrs; ++i) EmitPtr(Ptrs[i]); - + EmitPtr(p2); EmitPtr(p3); - + for (unsigned i = 0; i < NumT1Ptrs; ++i) if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); - + if (p2) SerializeTrait::Emit(*this,*p2); if (p3) SerializeTrait::Emit(*this,*p3); } - + //==------------------------------------------------==// // Emitter Functors //==------------------------------------------------==// - + template struct Emitter0 { - Serializer& S; + Serializer& S; Emitter0(Serializer& s) : S(s) {} void operator()(const T& x) const { SerializeTrait::Emit(S,x); } }; - + template struct Emitter1 { Serializer& S; Arg1 A1; - + Emitter1(Serializer& s, Arg1 a1) : S(s), A1(a1) {} void operator()(const T& x) const { SerializeTrait::Emit(S,x,A1); } }; - + template struct Emitter2 { Serializer& S; Arg1 A1; Arg2 A2; - + Emitter2(Serializer& s, Arg1 a1, Arg2 a2) : S(s), A1(a1), A2(a2) {} void operator()(const T& x) const { SerializeTrait::Emit(S,x,A1,A2); } }; - + template Emitter0 MakeEmitter() { return Emitter0(*this); } - + template Emitter1 MakeEmitter(Arg1 a1) { return Emitter1(*this,a1); } - + template Emitter2 MakeEmitter(Arg1 a1, Arg2 a2) { return Emitter2(*this,a1,a2); } - + //==------------------------------------------------==// // Misc. query and block/record manipulation methods. - //==------------------------------------------------==// - + //==------------------------------------------------==// + bool isRegistered(const void* p) const; - - void FlushRecord() { if (inRecord()) EmitRecord(); } + + void FlushRecord() { if (inRecord()) EmitRecord(); } void EnterBlock(unsigned BlockID = 8, unsigned CodeLen = 3); - void ExitBlock(); - + void ExitBlock(); + private: void EmitRecord(); inline bool inRecord() { return Record.size() > 0; }