6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-09 11:25:55 +00:00
Code Issues Projects Releases Wiki Activity

Make a major API change to BitstreamReader: split all the reading

Browse Source 
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
This commit is contained in:
Chris Lattner
2009-04-26 20:59:02 +00:00
parent 3485d25a0e
commit 962dde3cef
6 changed files with 155 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

259
include/llvm/Bitcode/BitstreamReader.h
View File

@@ -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<BitCodeAbbrev*> CurAbbrevs;
struct Block {
unsigned PrevCodeSize;
std::vector<BitCodeAbbrev*> PrevAbbrevs;
explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
};
/// BlockScope - This tracks the codesize of parent blocks.
SmallVector<Block, 8> 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<BitCodeAbbrev*> Abbrevs;
};
private:
/// FirstChar/LastChar - This remembers the first and last bytes of the
/// stream.
const unsigned char *FirstChar, *LastChar;
std::vector<BlockInfo> 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<unsigned>(CurAbbrevs.size());
i != e; ++i)
CurAbbrevs[i]->dropRef();
for (unsigned S = 0, e = static_cast<unsigned>(BlockScope.size());
S != e; ++S) {
std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
for (unsigned i = 0, e = static_cast<unsigned>(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<unsigned>(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<BitCodeAbbrev*> CurAbbrevs;
struct Block {
unsigned PrevCodeSize;
std::vector<BitCodeAbbrev*> PrevAbbrevs;
explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
};
/// BlockScope - This tracks the codesize of parent blocks.
SmallVector<Block, 8> 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<unsigned>(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<unsigned>(BlockScope.size());
S != e; ++S) {
std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
for (unsigned i = 0, e = static_cast<unsigned>(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<unsigned>(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<unsigned>(BlockInfoRecords.size());
i != e; ++i)
if (BlockInfoRecords[i].BlockID == BlockID)
return &BlockInfoRecords[i];
return 0;
}
public:
// Block header:
// [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, 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<unsigned>(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<uint64_t, 64> 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

4
include/llvm/Bitcode/Deserialize.h
View File

@@ -116,7 +116,7 @@ public:
//===----------------------------------------------------------===//
private:
BitstreamReader& Stream;
BitstreamCursor Stream;
SmallVector<uint64_t,20> Record;
unsigned RecIdx;
BumpPtrAllocator Allocator;
@@ -482,7 +482,7 @@ public:
unsigned getRecordCode();
BitstreamReader& getStream() { return Stream; }
BitstreamCursor &getStream() { return Stream; }
private:
bool AdvanceStream();

3
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@@ -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' ||

3
lib/Bitcode/Reader/BitcodeReader.h
View File

@@ -86,7 +86,8 @@ public:
class BitcodeReader : public ModuleProvider {
MemoryBuffer *Buffer;
BitstreamReader Stream;
BitstreamReader StreamFile;
BitstreamCursor Stream;
const char *ErrorString;

2
lib/Bitcode/Reader/Deserialize.cpp
View File

@@ -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() {

6
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
View File

@@ -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];