X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FTargetData.cpp;h=64332a0df56e50f874f207dfa35b048d0868c6f7;hb=2b5fab67c1a2d3ec1184c065e0a6bdaaaec9253a;hp=5a189205ed9348af44a6cb09fa37334042b32c8e;hpb=514ab348fddcdffa8367685dc608b2f8d5de986d;p=oota-llvm.git
diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index 5a189205ed9..64332a0df56 100644
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -2,8 +2,8 @@
//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
@@ -101,6 +101,7 @@ unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
TargetAlignElem
TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
unsigned char pref_align, uint32_t bit_width) {
+ assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
TargetAlignElem retval;
retval.AlignType = align_type;
retval.ABIAlign = abi_align;
@@ -154,7 +155,8 @@ const TargetAlignElem TargetData::InvalidAlignmentElem =
p:@verbatim::@endverbatim: Pointer size,
ABI and preferred alignment.
- @verbatim::@endverbatim: Numeric type alignment. Type is
+ @verbatim::@endverbatim: Numeric type
+ alignment. Type is
one of i|f|v|a, corresponding to integer, floating point, vector (aka
packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
\p
@@ -211,7 +213,7 @@ void TargetData::init(const std::string &TargetDescription) {
case 'f':
case 'a':
case 's': {
- AlignTypeEnum align_type;
+ AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
switch(*p) {
case 'i': align_type = INTEGER_ALIGN; break;
case 'v': align_type = VECTOR_ALIGN; break;
@@ -241,6 +243,7 @@ TargetData::TargetData(const Module *M)
void
TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
unsigned char pref_align, uint32_t bit_width) {
+ assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
if (Alignments[i].AlignType == align_type &&
Alignments[i].TypeBitWidth == bit_width) {
@@ -258,7 +261,8 @@ TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
/// preferred if ABIInfo = false) the target wants for the specified datatype.
unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
- uint32_t BitWidth, bool ABIInfo) const {
+ uint32_t BitWidth, bool ABIInfo,
+ const Type *Ty) const {
// Check to see if we have an exact match and remember the best match we see.
int BestMatchIdx = -1;
int LargestInt = -1;
@@ -268,15 +272,14 @@ unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
// The best match so far depends on what we're looking for.
- if (AlignType == VECTOR_ALIGN) {
+ if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
// If this is a specification for a smaller vector type, we will fall back
// to it. This happens because <128 x double> can be implemented in terms
// of 64 <2 x double>.
- if (Alignments[i].AlignType == VECTOR_ALIGN &&
- Alignments[i].TypeBitWidth < BitWidth) {
+ if (Alignments[i].TypeBitWidth < BitWidth) {
// Verify that we pick the biggest of the fallbacks.
if (BestMatchIdx == -1 ||
- Alignments[BestMatchIdx].TypeBitWidth < BitWidth)
+ Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
BestMatchIdx = i;
}
} else if (AlignType == INTEGER_ALIGN &&
@@ -294,14 +297,22 @@ unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
}
}
- // For integers, if we didn't find a best match, use the largest one found.
- if (BestMatchIdx == -1)
- BestMatchIdx = LargestInt;
-
// Okay, we didn't find an exact solution. Fall back here depending on what
// is being looked for.
- assert(BestMatchIdx != -1 && "Didn't find alignment info for this datatype!");
-
+ if (BestMatchIdx == -1) {
+ // If we didn't find an integer alignment, fall back on most conservative.
+ if (AlignType == INTEGER_ALIGN) {
+ BestMatchIdx = LargestInt;
+ } else {
+ assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
+
+ // If we didn't find a vector size that is smaller or equal to this type,
+ // then we will end up scalarizing this to its element type. Just return
+ // the alignment of the element.
+ return getAlignment(cast(Ty)->getElementType(), ABIInfo);
+ }
+ }
+
// Since we got a "best match" index, just return it.
return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
: Alignments[BestMatchIdx].PrefAlign;
@@ -475,7 +486,7 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
// Get the layout annotation... which is lazily created on demand.
const StructLayout *Layout = getStructLayout(cast(Ty));
- unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
+ unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
return std::max(Align, (unsigned)Layout->getAlignment());
}
case Type::IntegerTyID:
@@ -491,22 +502,16 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
case Type::X86_FP80TyID:
AlignType = FLOAT_ALIGN;
break;
- case Type::VectorTyID: {
- const VectorType *VTy = cast(Ty);
- // Degenerate vectors are assumed to be scalar-ized
- if (VTy->getNumElements() == 1)
- return getAlignment(VTy->getElementType(), abi_or_pref);
- else
- AlignType = VECTOR_ALIGN;
+ case Type::VectorTyID:
+ AlignType = VECTOR_ALIGN;
break;
- }
default:
assert(0 && "Bad type for getAlignment!!!");
break;
}
return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
- abi_or_pref);
+ abi_or_pref, Ty);
}
unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
@@ -573,22 +578,29 @@ uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
return Result;
}
-/// getPreferredAlignmentLog - Return the preferred alignment of the
-/// specified global, returned in log form. This includes an explicitly
-/// requested alignment (if the global has one).
-unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
+/// getPreferredAlignment - Return the preferred alignment of the specified
+/// global. This includes an explicitly requested alignment (if the global
+/// has one).
+unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
const Type *ElemType = GV->getType()->getElementType();
- unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
- if (GV->getAlignment() > (1U << Alignment))
- Alignment = Log2_32(GV->getAlignment());
-
+ unsigned Alignment = getPrefTypeAlignment(ElemType);
+ if (GV->getAlignment() > Alignment)
+ Alignment = GV->getAlignment();
+
if (GV->hasInitializer()) {
- if (Alignment < 4) {
+ if (Alignment < 16) {
// If the global is not external, see if it is large. If so, give it a
// larger alignment.
if (getTypeSizeInBits(ElemType) > 128)
- Alignment = 4; // 16-byte alignment.
+ Alignment = 16; // 16-byte alignment.
}
}
return Alignment;
}
+
+/// getPreferredAlignmentLog - Return the preferred alignment of the
+/// specified global, returned in log form. This includes an explicitly
+/// requested alignment (if the global has one).
+unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
+ return Log2_32(getPreferredAlignment(GV));
+}