6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-10 17:29:44 +00:00
Code Issues Projects Releases Wiki Activity

Implement suggestions from Chris:

Browse Source 
- Use a more accurate heuristic for the size of the hashtable.
  - Use bitwise and instead of modulo since the size is a power of two.
  - Use new[] instead of malloc().


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@52951 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2008-07-01 07:02:30 +00:00
parent ff4d609ec5
commit 57ce0319b7
2 changed files with 12 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Target/TargetRegisterInfo.h
View File

@ -413,14 +413,14 @@ public:
///
bool isSubRegister(unsigned regA, unsigned regB) const {
// SubregHash is a simple quadratically probed hash table.
size_t index = (regA + regB * 37) % SubregHashSize;
size_t index = (regA + regB * 37) & (SubregHashSize-1);
unsigned ProbeAmt = 2;
while (SubregHash[index*2] != 0 &&
SubregHash[index*2+1] != 0) {
if (SubregHash[index*2] == regA && SubregHash[index*2+1] == regB)
return true;
index = (index + ProbeAmt) % SubregHashSize;
index = (index + ProbeAmt) & (SubregHashSize-1);
ProbeAmt += 2;
}

19
utils/TableGen/RegisterInfoEmitter.cpp
View File

@ -466,15 +466,16 @@ void RegisterInfoEmitter::run(std::ostream &OS) {
// Print the SubregHashTable, a simple quadratically probed
// hash table for determining if a register is a subregister
// of another register.
unsigned SubregHashTableSize = NextPowerOf2(2 * Regs.size());
unsigned* SubregHashTable =
(unsigned*)malloc(2 * SubregHashTableSize * sizeof(unsigned));
for (unsigned i = 0; i < SubregHashTableSize * 2; ++i)
SubregHashTable[i] = ~0U;
unsigned NumSubRegs = 0;
std::map<Record*, unsigned> RegNo;
for (unsigned i = 0, e = Regs.size(); i != e; ++i)
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
RegNo[Regs[i].TheDef] = i;
NumSubRegs += RegisterSubRegs[Regs[i].TheDef].size();
}
unsigned SubregHashTableSize = NextPowerOf2(2 * NumSubRegs);
unsigned* SubregHashTable = new unsigned[2 * SubregHashTableSize];
std::fill(SubregHashTable, SubregHashTable + 2 * SubregHashTableSize, ~0U);
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
Record* R = Regs[i].TheDef;
@ -484,11 +485,11 @@ void RegisterInfoEmitter::run(std::ostream &OS) {
// We have to increase the indices of both registers by one when
// computing the hash because, in the generated code, there
// will be an extra empty slot at register 0.
size_t index = ((i+1) + (RegNo[RJ]+1) * 37) % SubregHashTableSize;
size_t index = ((i+1) + (RegNo[RJ]+1) * 37) & (SubregHashTableSize-1);
unsigned ProbeAmt = 2;
while (SubregHashTable[index*2] != ~0U &&
SubregHashTable[index*2+1] != ~0U) {
index = (index + ProbeAmt) % SubregHashTableSize;
index = (index + ProbeAmt) & (SubregHashTableSize-1);
ProbeAmt += 2;
}