From 962dde3cef3184f1683d5070c298c9a29509d62e Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 26 Apr 2009 20:59:02 +0000 Subject: [PATCH] Make a major API change to BitstreamReader: split all the reading state out of the BitstreamReader class into a BitstreamCursor class. Doing this allows the client to have multiple cursors into the same file, each with potentially different live block stacks and abbreviation records. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@70157 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bitcode/BitstreamReader.h | 259 ++++++++++++---------- include/llvm/Bitcode/Deserialize.h | 4 +- lib/Bitcode/Reader/BitcodeReader.cpp | 3 +- lib/Bitcode/Reader/BitcodeReader.h | 3 +- lib/Bitcode/Reader/Deserialize.cpp | 2 +- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 6 +- 6 files changed, 155 insertions(+), 122 deletions(-) diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h index 7ff4e26fd8c..ae18f2c57b3 100644 --- a/include/llvm/Bitcode/BitstreamReader.h +++ b/include/llvm/Bitcode/BitstreamReader.h @@ -24,50 +24,22 @@ 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; - +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 Abbrevs; }; +private: + /// FirstChar/LastChar - This remembers the first and last bytes of the + /// stream. + const unsigned char *FirstChar, *LastChar; + std::vector BlockInfoRecords; - /// FirstChar - This remembers the first byte of the stream. - const unsigned char *FirstChar; public: - BitstreamReader() { - NextChar = FirstChar = LastChar = 0; - CurWord = 0; - BitsInCurWord = 0; - CurCodeSize = 0; + BitstreamReader() : FirstChar(0), LastChar(0) { } BitstreamReader(const unsigned char *Start, const unsigned char *End) { @@ -75,29 +47,12 @@ public: } void init(const unsigned char *Start, const unsigned char *End) { - NextChar = FirstChar = Start; + FirstChar = Start; LastChar = End; assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes"); - CurWord = 0; - BitsInCurWord = 0; - CurCodeSize = 2; } ~BitstreamReader() { - // Abbrevs could still exist if the stream was broken. If so, don't leak - // them. - for (unsigned i = 0, e = static_cast(CurAbbrevs.size()); - i != e; ++i) - CurAbbrevs[i]->dropRef(); - - for (unsigned S = 0, e = static_cast(BlockScope.size()); - S != e; ++S) { - std::vector &Abbrevs = BlockScope[S].PrevAbbrevs; - for (unsigned i = 0, e = static_cast(Abbrevs.size()); - i != e; ++i) - Abbrevs[i]->dropRef(); - } - // Free the BlockInfoRecords. while (!BlockInfoRecords.empty()) { BlockInfo &Info = BlockInfoRecords.back(); @@ -108,36 +63,147 @@ public: BlockInfoRecords.pop_back(); } } + + const unsigned char *getFirstChar() const { return FirstChar; } + const unsigned char *getLastChar() const { return LastChar; } - bool AtEndOfStream() const { - return NextChar == LastChar && BitsInCurWord == 0; + //===--------------------------------------------------------------------===// + // 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; } + 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(); + } + +}; + +class BitstreamCursor { + friend class Deserializer; + BitstreamReader *BitStream; + const unsigned char *NextChar; + + /// 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; + + BitstreamCursor(const BitstreamCursor&); // NOT YET IMPLEMENTED. + void operator=(const BitstreamCursor&); // NOT YET IMPLEMENTED. +public: + BitstreamCursor() : BitStream(0), NextChar(0) { + } + explicit BitstreamCursor(BitstreamReader &R) : BitStream(&R) { + NextChar = R.getFirstChar(); + assert(NextChar && "Bitstream not initialized yet"); + CurWord = 0; + BitsInCurWord = 0; + CurCodeSize = 2; + } + + void init(BitstreamReader &R) { + freeState(); + + BitStream = &R; + NextChar = R.getFirstChar(); + assert(NextChar && "Bitstream not initialized yet"); + CurWord = 0; + BitsInCurWord = 0; + CurCodeSize = 2; + } + + ~BitstreamCursor() { + freeState(); + } + + void freeState() { + // Free all the Abbrevs. + for (unsigned i = 0, e = static_cast(CurAbbrevs.size()); + i != e; ++i) + CurAbbrevs[i]->dropRef(); + CurAbbrevs.clear(); + + // Free all the Abbrevs in the block scope. + for (unsigned S = 0, e = static_cast(BlockScope.size()); + S != e; ++S) { + std::vector &Abbrevs = BlockScope[S].PrevAbbrevs; + for (unsigned i = 0, e = static_cast(Abbrevs.size()); + i != e; ++i) + Abbrevs[i]->dropRef(); + } + BlockScope.clear(); + } + + /// GetAbbrevIDWidth - Return the number of bits used to encode an abbrev #. + unsigned GetAbbrevIDWidth() const { return CurCodeSize; } + + bool AtEndOfStream() const { + return NextChar == BitStream->getLastChar() && BitsInCurWord == 0; + } + /// GetCurrentBitNo - Return the bit # of the bit we are reading. uint64_t GetCurrentBitNo() const { - return (NextChar-FirstChar)*CHAR_BIT - BitsInCurWord; + return (NextChar-BitStream->getFirstChar())*CHAR_BIT - BitsInCurWord; } - + + /// 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"); - + assert(ByteNo <= (uintptr_t)(BitStream->getLastChar()- + BitStream->getFirstChar()) && + "Invalid location"); + // Move the cursor to the right word. - NextChar = FirstChar+ByteNo; + NextChar = BitStream->getFirstChar()+ByteNo; BitsInCurWord = 0; CurWord = 0; - + // Skip over any bits that are already consumed. - if (WordBitNo) { + if (WordBitNo) 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) { @@ -148,7 +214,7 @@ public: } // If we run out of data, stop at the end of the stream. - if (NextChar == LastChar) { + if (NextChar == BitStream->getLastChar()) { CurWord = 0; BitsInCurWord = 0; return 0; @@ -224,31 +290,10 @@ public: CurWord = 0; } - unsigned ReadCode() { return Read(CurCodeSize); } - //===--------------------------------------------------------------------===// - // Block Manipulation - //===--------------------------------------------------------------------===// - -private: - /// 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; - } -public: - // Block header: // [ENTER_SUBBLOCK, blockid, newcodelen, , blocklen] @@ -271,7 +316,7 @@ public: // Check that the block wasn't partially defined, and that the offset isn't // bogus. - if (AtEndOfStream() || NextChar+NumWords*4 > LastChar) + if (AtEndOfStream() || NextChar+NumWords*4 > BitStream->getLastChar()) return true; NextChar += NumWords*4; @@ -286,7 +331,7 @@ public: BlockScope.back().PrevAbbrevs.swap(CurAbbrevs); // Add the abbrevs specific to this block to the CurAbbrevs list. - if (BlockInfo *Info = getBlockInfo(BlockID)) { + if (BitstreamReader::BlockInfo *Info = BitStream->getBlockInfo(BlockID)) { for (unsigned i = 0, e = static_cast(Info->Abbrevs.size()); i != e; ++i) { CurAbbrevs.push_back(Info->Abbrevs[i]); @@ -301,7 +346,8 @@ public: if (NumWordsP) *NumWordsP = NumWords; // Validate that this block is sane. - if (CurCodeSize == 0 || AtEndOfStream() || NextChar+NumWords*4 > LastChar) + if (CurCodeSize == 0 || AtEndOfStream() || + NextChar+NumWords*4 > BitStream->getLastChar()) return true; return false; @@ -331,7 +377,7 @@ private: BlockScope.pop_back(); } - //===--------------------------------------------------------------------===// + //===--------------------------------------------------------------------===// // Record Processing //===--------------------------------------------------------------------===// @@ -407,9 +453,9 @@ public: // If this would read off the end of the bitcode file, just set the // record to empty and return. - if (NewEnd > LastChar) { + if (NewEnd > BitStream->getLastChar()) { Vals.append(NumElts, 0); - NextChar = LastChar; + NextChar = BitStream->getLastChar(); break; } @@ -462,29 +508,14 @@ public: } CurAbbrevs.push_back(Abbv); } - - //===--------------------------------------------------------------------===// - // BlockInfo Block Reading - //===--------------------------------------------------------------------===// - -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; + BitstreamReader::BlockInfo *CurBlockInfo = 0; // Read all the records for this module. while (1) { @@ -516,13 +547,13 @@ public: default: break; // Default behavior, ignore unknown content. case bitc::BLOCKINFO_CODE_SETBID: if (Record.size() < 1) return true; - CurBlockInfo = &getOrCreateBlockInfo((unsigned)Record[0]); + CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]); break; } } } }; - + } // End llvm namespace #endif diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h index cc85d9fb5e8..3e90227591a 100644 --- a/include/llvm/Bitcode/Deserialize.h +++ b/include/llvm/Bitcode/Deserialize.h @@ -116,7 +116,7 @@ public: //===----------------------------------------------------------===// private: - BitstreamReader& Stream; + BitstreamCursor Stream; SmallVector Record; unsigned RecIdx; BumpPtrAllocator Allocator; @@ -482,7 +482,7 @@ public: unsigned getRecordCode(); - BitstreamReader& getStream() { return Stream; } + BitstreamCursor &getStream() { return Stream; } private: bool AdvanceStream(); diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 8079acddb06..fe20f725878 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -1346,7 +1346,8 @@ bool BitcodeReader::ParseBitcode() { if (SkipBitcodeWrapperHeader(BufPtr, BufEnd)) return Error("Invalid bitcode wrapper header"); - Stream.init(BufPtr, BufEnd); + StreamFile.init(BufPtr, BufEnd); + Stream.init(StreamFile); // Sniff for the signature. if (Stream.Read(8) != 'B' || diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h index 1fbf219fb8e..0dc470b24a2 100644 --- a/lib/Bitcode/Reader/BitcodeReader.h +++ b/lib/Bitcode/Reader/BitcodeReader.h @@ -86,7 +86,8 @@ public: class BitcodeReader : public ModuleProvider { MemoryBuffer *Buffer; - BitstreamReader Stream; + BitstreamReader StreamFile; + BitstreamCursor Stream; const char *ErrorString; diff --git a/lib/Bitcode/Reader/Deserialize.cpp b/lib/Bitcode/Reader/Deserialize.cpp index 2014557a101..06da6ce7272 100644 --- a/lib/Bitcode/Reader/Deserialize.cpp +++ b/lib/Bitcode/Reader/Deserialize.cpp @@ -22,7 +22,7 @@ using namespace llvm; Deserializer::Deserializer(BitstreamReader& stream) : Stream(stream), RecIdx(0), FreeList(NULL), AbbrevNo(0), RecordCode(0) { - StreamStart = Stream.GetCurrentBitNo(); + StreamStart = Stream.GetCurrentBitNo(); } Deserializer::~Deserializer() { diff --git a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index 4832a4c0b21..182404c4d15 100644 --- a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -262,7 +262,7 @@ static bool Error(const std::string &Err) { } /// ParseBlock - Read a block, updating statistics, etc. -static bool ParseBlock(BitstreamReader &Stream, unsigned IndentLevel) { +static bool ParseBlock(BitstreamCursor &Stream, unsigned IndentLevel) { std::string Indent(IndentLevel*2, ' '); uint64_t BlockBitStart = Stream.GetCurrentBitNo(); unsigned BlockID = Stream.ReadSubBlockID(); @@ -420,8 +420,8 @@ static int AnalyzeBitcode() { if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr)) return Error("Invalid bitcode wrapper header"); - BitstreamReader Stream(BufPtr, EndBufPtr); - + BitstreamReader StreamFile(BufPtr, EndBufPtr); + BitstreamCursor Stream(StreamFile); // Read the stream signature. char Signature[6];