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

Don't use unsigned char for alignments in TargetData. There aren't

Browse Source 
that many of these things, so the memory savings isn't significant,
and there are now situations where there can be alignments greater
than 128.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@110836 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2010-08-11 18:15:01 +00:00
parent d881627d33
commit b68f274b6d
2 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
include/llvm/Target/TargetData.h
View File

@ -50,13 +50,13 @@ enum AlignTypeEnum {
/// padding and make the structure slightly more cache friendly. /// padding and make the structure slightly more cache friendly.
struct TargetAlignElem { struct TargetAlignElem {
AlignTypeEnum AlignType : 8; //< Alignment type (AlignTypeEnum) AlignTypeEnum AlignType : 8; //< Alignment type (AlignTypeEnum)
unsigned char ABIAlign; //< ABI alignment for this type/bitw unsigned ABIAlign; //< ABI alignment for this type/bitw
unsigned char PrefAlign; //< Pref. alignment for this type/bitw unsigned PrefAlign; //< Pref. alignment for this type/bitw
uint32_t TypeBitWidth; //< Type bit width uint32_t TypeBitWidth; //< Type bit width
/// Initializer /// Initializer
static TargetAlignElem get(AlignTypeEnum align_type, unsigned char abi_align, static TargetAlignElem get(AlignTypeEnum align_type, unsigned abi_align,
unsigned char pref_align, uint32_t bit_width); unsigned pref_align, uint32_t bit_width);
/// Equality predicate /// Equality predicate
bool operator==(const TargetAlignElem &rhs) const; bool operator==(const TargetAlignElem &rhs) const;
}; };
@ -64,9 +64,9 @@ struct TargetAlignElem {
class TargetData : public ImmutablePass { class TargetData : public ImmutablePass {
private: private:
bool LittleEndian; ///< Defaults to false bool LittleEndian; ///< Defaults to false
unsigned char PointerMemSize; ///< Pointer size in bytes unsigned PointerMemSize; ///< Pointer size in bytes
unsigned char PointerABIAlign; ///< Pointer ABI alignment unsigned PointerABIAlign; ///< Pointer ABI alignment
unsigned char PointerPrefAlign; ///< Pointer preferred alignment unsigned PointerPrefAlign; ///< Pointer preferred alignment
SmallVector<unsigned char, 8> LegalIntWidths; ///< Legal Integers. SmallVector<unsigned char, 8> LegalIntWidths; ///< Legal Integers.
@ -86,12 +86,12 @@ private:
mutable void *LayoutMap; mutable void *LayoutMap;
//! Set/initialize target alignments //! Set/initialize target alignments
void setAlignment(AlignTypeEnum align_type, unsigned char abi_align, void setAlignment(AlignTypeEnum align_type, unsigned abi_align,
unsigned char pref_align, uint32_t bit_width); unsigned pref_align, uint32_t bit_width);
unsigned getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width, unsigned getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width,
bool ABIAlign, const Type *Ty) const; bool ABIAlign, const Type *Ty) const;
//! Internal helper method that returns requested alignment for type. //! Internal helper method that returns requested alignment for type.
unsigned char getAlignment(const Type *Ty, bool abi_or_pref) const; unsigned getAlignment(const Type *Ty, bool abi_or_pref) const;
/// Valid alignment predicate. /// Valid alignment predicate.
/// ///
@ -161,13 +161,13 @@ public:
} }
/// Target pointer alignment /// Target pointer alignment
unsigned char getPointerABIAlignment() const { return PointerABIAlign; } unsigned getPointerABIAlignment() const { return PointerABIAlign; }
/// Return target's alignment for stack-based pointers /// Return target's alignment for stack-based pointers
unsigned char getPointerPrefAlignment() const { return PointerPrefAlign; } unsigned getPointerPrefAlignment() const { return PointerPrefAlign; }
/// Target pointer size /// Target pointer size
unsigned char getPointerSize() const { return PointerMemSize; } unsigned getPointerSize() const { return PointerMemSize; }
/// Target pointer size, in bits /// Target pointer size, in bits
unsigned char getPointerSizeInBits() const { return 8*PointerMemSize; } unsigned getPointerSizeInBits() const { return 8*PointerMemSize; }
/// Size examples: /// Size examples:
/// ///
@ -223,26 +223,26 @@ public:
/// getABITypeAlignment - Return the minimum ABI-required alignment for the /// getABITypeAlignment - Return the minimum ABI-required alignment for the
/// specified type. /// specified type.
unsigned char getABITypeAlignment(const Type *Ty) const; unsigned getABITypeAlignment(const Type *Ty) const;
/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
/// an integer type of the specified bitwidth. /// an integer type of the specified bitwidth.
unsigned char getABIIntegerTypeAlignment(unsigned BitWidth) const; unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const;
/// getCallFrameTypeAlignment - Return the minimum ABI-required alignment /// getCallFrameTypeAlignment - Return the minimum ABI-required alignment
/// for the specified type when it is part of a call frame. /// for the specified type when it is part of a call frame.
unsigned char getCallFrameTypeAlignment(const Type *Ty) const; unsigned getCallFrameTypeAlignment(const Type *Ty) const;
/// getPrefTypeAlignment - Return the preferred stack/global alignment for /// getPrefTypeAlignment - Return the preferred stack/global alignment for
/// the specified type. This is always at least as good as the ABI alignment. /// the specified type. This is always at least as good as the ABI alignment.
unsigned char getPrefTypeAlignment(const Type *Ty) const; unsigned getPrefTypeAlignment(const Type *Ty) const;
/// getPreferredTypeAlignmentShift - Return the preferred alignment for the /// getPreferredTypeAlignmentShift - Return the preferred alignment for the
/// specified type, returned as log2 of the value (a shift amount). /// specified type, returned as log2 of the value (a shift amount).
/// ///
unsigned char getPreferredTypeAlignmentShift(const Type *Ty) const; unsigned getPreferredTypeAlignmentShift(const Type *Ty) const;
/// getIntPtrType - Return an unsigned integer type that is the same size or /// getIntPtrType - Return an unsigned integer type that is the same size or
/// greater to the host pointer size. /// greater to the host pointer size.

30
lib/Target/TargetData.cpp
View File

@ -97,8 +97,8 @@ unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
TargetAlignElem TargetAlignElem
TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align, TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
unsigned char pref_align, uint32_t bit_width) { unsigned pref_align, uint32_t bit_width) {
assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
TargetAlignElem retval; TargetAlignElem retval;
retval.AlignType = align_type; retval.AlignType = align_type;
@ -196,10 +196,10 @@ void TargetData::init(StringRef Desc) {
} }
unsigned Size = getInt(Specifier.substr(1)); unsigned Size = getInt(Specifier.substr(1));
Split = Token.split(':'); Split = Token.split(':');
unsigned char ABIAlign = getInt(Split.first) / 8; unsigned ABIAlign = getInt(Split.first) / 8;
Split = Split.second.split(':'); Split = Split.second.split(':');
unsigned char PrefAlign = getInt(Split.first) / 8; unsigned PrefAlign = getInt(Split.first) / 8;
if (PrefAlign == 0) if (PrefAlign == 0)
PrefAlign = ABIAlign; PrefAlign = ABIAlign;
setAlignment(AlignType, ABIAlign, PrefAlign, Size); setAlignment(AlignType, ABIAlign, PrefAlign, Size);
@ -237,8 +237,8 @@ TargetData::TargetData(const Module *M)
} }
void void
TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align, TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
unsigned char pref_align, uint32_t bit_width) { unsigned pref_align, uint32_t bit_width) {
assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
if (Alignments[i].AlignType == align_type && if (Alignments[i].AlignType == align_type &&
@ -495,7 +495,7 @@ uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
== false) for the requested type \a Ty. == false) for the requested type \a Ty.
*/ */
unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const { unsigned TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
int AlignType = -1; int AlignType = -1;
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
@ -517,7 +517,7 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
// Get the layout annotation... which is lazily created on demand. // Get the layout annotation... which is lazily created on demand.
const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
return std::max(Align, (unsigned)Layout->getAlignment()); return std::max(Align, Layout->getAlignment());
} }
case Type::UnionTyID: { case Type::UnionTyID: {
const UnionType *UnTy = cast<UnionType>(Ty); const UnionType *UnTy = cast<UnionType>(Ty);
@ -526,7 +526,7 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
// Unions need the maximum alignment of all their entries // Unions need the maximum alignment of all their entries
for (UnionType::element_iterator i = UnTy->element_begin(), for (UnionType::element_iterator i = UnTy->element_begin(),
e = UnTy->element_end(); i != e; ++i) { e = UnTy->element_end(); i != e; ++i) {
Align = std::max(Align, (unsigned)getAlignment(*i, abi_or_pref)); Align = std::max(Align, getAlignment(*i, abi_or_pref));
} }
return Align; return Align;
} }
@ -555,18 +555,18 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
abi_or_pref, Ty); abi_or_pref, Ty);
} }
unsigned char TargetData::getABITypeAlignment(const Type *Ty) const { unsigned TargetData::getABITypeAlignment(const Type *Ty) const {
return getAlignment(Ty, true); return getAlignment(Ty, true);
} }
/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
/// an integer type of the specified bitwidth. /// an integer type of the specified bitwidth.
unsigned char TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const { unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
} }
unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const { unsigned TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
for (unsigned i = 0, e = Alignments.size(); i != e; ++i) for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
if (Alignments[i].AlignType == STACK_ALIGN) if (Alignments[i].AlignType == STACK_ALIGN)
return Alignments[i].ABIAlign; return Alignments[i].ABIAlign;
@ -574,12 +574,12 @@ unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
return getABITypeAlignment(Ty); return getABITypeAlignment(Ty);
} }
unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const { unsigned TargetData::getPrefTypeAlignment(const Type *Ty) const {
return getAlignment(Ty, false); return getAlignment(Ty, false);
} }
unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const { unsigned TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
unsigned Align = (unsigned) getPrefTypeAlignment(Ty); unsigned Align = getPrefTypeAlignment(Ty);
assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
return Log2_32(Align); return Log2_32(Align);
} }