6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 04:30:23 +00:00
Code Issues Projects Releases Wiki Activity

Use a sorted array to store the information about a few address spaces.

Browse Source 
We don't have any test with more than 6 address spaces, so a DenseMap is
probably not the correct answer.

An unsorted array would also be OK, but we have to sort it for printing anyway.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@202275 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2014-02-26 16:58:35 +00:00
parent 3c4c95e522
commit e3561972d4
2 changed files with 44 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/IR/DataLayout.h
View File

@ -115,7 +115,14 @@ private:
/// pointers vs. 64-bit pointers by extending LayoutAlignment, but for now,
/// we don't.
SmallVector<LayoutAlignElem, 16> Alignments;
DenseMap<unsigned, PointerAlignElem> Pointers;
typedef SmallVector<PointerAlignElem, 8> PointersTy;
PointersTy Pointers;
PointersTy::const_iterator findPoiterLowerBound(uint32_t AddressSpace) const {
return const_cast<DataLayout *>(this)->findPoiterLowerBound(AddressSpace);
}
PointersTy::iterator findPoiterLowerBound(uint32_t AddressSpace);
/// InvalidAlignmentElem - This member is a signal that a requested alignment
/// type and bit width were not found in the SmallVector.

68
lib/IR/DataLayout.cpp
View File

@ -374,18 +374,29 @@ DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
pref_align, bit_width));
}
static bool comparePointerAlignElem(const PointerAlignElem &A,
uint32_t AddressSpace) {
return A.AddressSpace < AddressSpace;
}
DataLayout::PointersTy::iterator
DataLayout::findPoiterLowerBound(uint32_t AddressSpace) {
return std::lower_bound(Pointers.begin(), Pointers.end(), AddressSpace,
comparePointerAlignElem);
}
void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
unsigned PrefAlign,
uint32_t TypeByteWidth) {
assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(AddrSpace);
if (val == Pointers.end()) {
Pointers[AddrSpace] =
PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign, TypeByteWidth);
PointersTy::iterator I = findPoiterLowerBound(AddrSpace);
if (I == Pointers.end() || I->AddressSpace != AddrSpace) {
Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign,
TypeByteWidth));
} else {
val->second.ABIAlign = ABIAlign;
val->second.PrefAlign = PrefAlign;
val->second.TypeByteWidth = TypeByteWidth;
I->ABIAlign = ABIAlign;
I->PrefAlign = PrefAlign;
I->TypeByteWidth = TypeByteWidth;
}
}
@ -529,19 +540,9 @@ std::string DataLayout::getStringRepresentation() const {
break;
}
SmallVector<unsigned, 8> addrSpaces;
// Lets get all of the known address spaces and sort them
// into increasing order so that we can emit the string
// in a cleaner format.
for (DenseMap<unsigned, PointerAlignElem>::const_iterator
pib = Pointers.begin(), pie = Pointers.end();
pib != pie; ++pib) {
addrSpaces.push_back(pib->first);
}
std::sort(addrSpaces.begin(), addrSpaces.end());
for (SmallVectorImpl<unsigned>::iterator asb = addrSpaces.begin(),
ase = addrSpaces.end(); asb != ase; ++asb) {
const PointerAlignElem &PI = Pointers.find(*asb)->second;
for (PointersTy::const_iterator I = Pointers.begin(), E = Pointers.end();
I != E; ++I) {
const PointerAlignElem &PI = *I;
// Skip default.
if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
@ -586,27 +587,30 @@ std::string DataLayout::getStringRepresentation() const {
}
unsigned DataLayout::getPointerABIAlignment(unsigned AS) const {
DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
if (val == Pointers.end()) {
val = Pointers.find(0);
PointersTy::const_iterator I = findPoiterLowerBound(AS);
if (I == Pointers.end() || I->AddressSpace != AS) {
I = findPoiterLowerBound(0);
assert(I->AddressSpace == 0);
}
return val->second.ABIAlign;
return I->ABIAlign;
}
unsigned DataLayout::getPointerPrefAlignment(unsigned AS) const {
DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
if (val == Pointers.end()) {
val = Pointers.find(0);
PointersTy::const_iterator I = findPoiterLowerBound(AS);
if (I == Pointers.end() || I->AddressSpace != AS) {
I = findPoiterLowerBound(0);
assert(I->AddressSpace == 0);
}
return val->second.PrefAlign;
return I->PrefAlign;
}
unsigned DataLayout::getPointerSize(unsigned AS) const {
DenseMap<unsigned, PointerAlignElem>::const_iterator val = Pointers.find(AS);
if (val == Pointers.end()) {
val = Pointers.find(0);
PointersTy::const_iterator I = findPoiterLowerBound(AS);
if (I == Pointers.end() || I->AddressSpace != AS) {
I = findPoiterLowerBound(0);
assert(I->AddressSpace == 0);
}
return val->second.TypeByteWidth;
return I->TypeByteWidth;
}
unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {