6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-04 05:31:06 +00:00
Code Issues Projects Releases Wiki Activity

rework the Bitstream reader to actually work a machine word at a time, instead of 32-bits at a time.

Browse Source 
This cuts in half the number of virtual methods called to refill that word when compiling on a 64-bit
host, and will make 64-bit read operations faster.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173072 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2013-01-21 18:48:26 +00:00
parent 69582cf6c4
commit 02b206f6d8
1 changed files with 49 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -170,12 +170,17 @@ class BitstreamCursor {
BitstreamReader *BitStream; BitstreamReader *BitStream;
size_t NextChar; size_t NextChar;
/// CurWord - This is the current data we have pulled from the stream but have
/// not returned to the client. /// CurWord/word_t - This is the current data we have pulled from the stream
uint32_t CurWord; /// but have not returned to the client. This is specifically and
/// intentionally defined to follow the word size of the host machine for
/// efficiency. We use word_t in places that are aware of this to make it
/// perfectly explicit what is going on.
typedef size_t word_t;
word_t CurWord;
/// BitsInCurWord - This is the number of bits in CurWord that are valid. This /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
/// is always from [0...31] inclusive. /// is always from [0...31/63] inclusive (depending on word size).
unsigned BitsInCurWord; unsigned BitsInCurWord;
// CurCodeSize - This is the declared size of code values used for the current // CurCodeSize - This is the declared size of code values used for the current
@ -318,8 +323,8 @@ public:
/// JumpToBit - Reset the stream to the specified bit number. /// JumpToBit - Reset the stream to the specified bit number.
void JumpToBit(uint64_t BitNo) { void JumpToBit(uint64_t BitNo) {
uintptr_t ByteNo = uintptr_t(BitNo/8) & ~3; uintptr_t ByteNo = uintptr_t(BitNo/8) & ~(sizeof(word_t)-1);
uintptr_t WordBitNo = uintptr_t(BitNo) & 31; unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
assert(canSkipToPos(ByteNo) && "Invalid location"); assert(canSkipToPos(ByteNo) && "Invalid location");
// Move the cursor to the right word. // Move the cursor to the right word.
@ -328,8 +333,12 @@ public:
CurWord = 0; CurWord = 0;
// Skip over any bits that are already consumed. // Skip over any bits that are already consumed.
if (WordBitNo) if (WordBitNo) {
Read(static_cast<unsigned>(WordBitNo)); if (sizeof(word_t) > 4)
Read64(WordBitNo);
else
Read(WordBitNo);
}
} }
@ -337,7 +346,7 @@ public:
assert(NumBits <= 32 && "Cannot return more than 32 bits!"); assert(NumBits <= 32 && "Cannot return more than 32 bits!");
// If the field is fully contained by CurWord, return it quickly. // If the field is fully contained by CurWord, return it quickly.
if (BitsInCurWord >= NumBits) { if (BitsInCurWord >= NumBits) {
uint32_t R = CurWord & ((1U << NumBits)-1); uint32_t R = uint32_t(CurWord) & (~0U >> (32-NumBits));
CurWord >>= NumBits; CurWord >>= NumBits;
BitsInCurWord -= NumBits; BitsInCurWord -= NumBits;
return R; return R;
@ -350,24 +359,32 @@ public:
return 0; return 0;
} }
unsigned R = CurWord; uint32_t R = uint32_t(CurWord);
// Read the next word from the stream. // Read the next word from the stream.
CurWord = getWord(NextChar); uint8_t buf[sizeof(word_t)] = {0};
NextChar += 4; BitStream->getBitcodeBytes().readBytes(NextChar, sizeof(buf), buf, NULL);
typedef support::detail::packed_endian_specific_integral
<word_t, support::little, support::unaligned> Endian_T;
CurWord = *reinterpret_cast<Endian_T*>(buf);
NextChar += sizeof(word_t);
// Extract NumBits-BitsInCurWord from what we just read. // Extract NumBits-BitsInCurWord from what we just read.
unsigned BitsLeft = NumBits-BitsInCurWord; unsigned BitsLeft = NumBits-BitsInCurWord;
// Be careful here, BitsLeft is in the range [1..32] inclusive. // Be careful here, BitsLeft is in the range [1..32]/[1..64] inclusive.
R |= (CurWord & (~0U >> (32-BitsLeft))) << BitsInCurWord; R |= uint32_t((CurWord & (word_t(~0ULL) >> (sizeof(word_t)*8-BitsLeft)))
<< BitsInCurWord);
// BitsLeft bits have just been used up from CurWord. // BitsLeft bits have just been used up from CurWord. BitsLeft is in the
if (BitsLeft != 32) // range [1..32]/[1..64] so be careful how we shift.
if (BitsLeft != sizeof(word_t)*8)
CurWord >>= BitsLeft; CurWord >>= BitsLeft;
else else
CurWord = 0; CurWord = 0;
BitsInCurWord = 32-BitsLeft; BitsInCurWord = sizeof(word_t)*8-BitsLeft;
return R; return R;
} }
@ -416,10 +433,21 @@ public:
} }
} }
private:
void SkipToFourByteBoundary() { void SkipToFourByteBoundary() {
// If word_t is 64-bits and if we've read less than 32 bits, just dump
// the bits we have up to the next 32-bit boundary.
if (sizeof(word_t) > 4 &&
BitsInCurWord > 32) {
CurWord >>= BitsInCurWord-32;
BitsInCurWord = 32;
return;
}
BitsInCurWord = 0; BitsInCurWord = 0;
CurWord = 0; CurWord = 0;
} }
public:
unsigned ReadCode() { unsigned ReadCode() {
return Read(CurCodeSize); return Read(CurCodeSize);
@ -443,15 +471,15 @@ public:
// don't care what code widths are used inside of it. // don't care what code widths are used inside of it.
ReadVBR(bitc::CodeLenWidth); ReadVBR(bitc::CodeLenWidth);
SkipToFourByteBoundary(); SkipToFourByteBoundary();
unsigned NumWords = Read(bitc::BlockSizeWidth); unsigned NumFourBytes = Read(bitc::BlockSizeWidth);
// Check that the block wasn't partially defined, and that the offset isn't // Check that the block wasn't partially defined, and that the offset isn't
// bogus. // bogus.
size_t SkipTo = NextChar + NumWords*4; size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
if (AtEndOfStream() || !canSkipToPos(SkipTo)) if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
return true; return true;
NextChar = SkipTo; JumpToBit(SkipTo);
return false; return false;
} }