//
// 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.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/ADT/StringExtras.h"
#include <algorithm>
#include <cstdlib>
-#include <sstream>
using namespace llvm;
// Handle the Pass registration stuff necessary to use TargetData's.
-namespace {
- // Register the default SparcV9 implementation...
- RegisterPass<TargetData> X("targetdata", "Target Data Layout");
-}
+
+// Register the default SparcV9 implementation...
+static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
+ true);
char TargetData::ID = 0;
//===----------------------------------------------------------------------===//
StructSize = 0;
NumElements = ST->getNumElements();
- // Loop over each of the elements, placing them in memory...
+ // Loop over each of the elements, placing them in memory.
for (unsigned i = 0, e = NumElements; i != e; ++i) {
const Type *Ty = ST->getElementType(i);
- unsigned TyAlign = ST->isPacked() ?
- 1 : TD.getABITypeAlignment(Ty);
- uint64_t TySize = ST->isPacked() ?
- TD.getTypeStoreSize(Ty) : TD.getABITypeSize(Ty);
+ unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
- // Add padding if necessary to align the data element properly...
- StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
+ // Add padding if necessary to align the data element properly.
+ if ((StructSize & (TyAlign-1)) != 0)
+ StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
- // Keep track of maximum alignment constraint
+ // Keep track of maximum alignment constraint.
StructAlignment = std::max(TyAlign, StructAlignment);
MemberOffsets[i] = StructSize;
- StructSize += TySize; // Consume space for this data item
+ StructSize += TD.getTypePaddedSize(Ty); // Consume space for this data item
}
// Empty structures have alignment of 1 byte.
// Add padding to the end of the struct so that it could be put in an array
// and all array elements would be aligned correctly.
- if (StructSize % StructAlignment != 0)
- StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
+ if ((StructSize & (StructAlignment-1)) != 0)
+ StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
}
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;
<i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
ABI and preferred alignment.
<br><br>
- <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type alignment. Type is
+ <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
+ alignment. Type is
one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
\p
}
TargetData::TargetData(const Module *M)
- : ImmutablePass((intptr_t)&ID) {
+ : ImmutablePass(&ID) {
init(M->getDataLayout());
}
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) {
/// 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;
}
}
- // 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<VectorType>(Ty)->getElementType(), ABIInfo);
+ }
+ }
+
// Since we got a "best match" index, just return it.
return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
: Alignments[BestMatchIdx].PrefAlign;
}
+namespace {
+
/// LayoutInfo - The lazy cache of structure layout information maintained by
/// TargetData. Note that the struct types must have been free'd before
/// llvm_shutdown is called (and thus this is deallocated) because all the
};
typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
-static ManagedStatic<LayoutInfoTy> LayoutInfo;
+}
+
+static ManagedStatic<LayoutInfoTy> LayoutInfo;
TargetData::~TargetData() {
- if (LayoutInfo.isConstructed()) {
- // Remove any layouts for this TD.
- LayoutInfoTy &TheMap = *LayoutInfo;
- for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
- I != E; ) {
- if (I->first.first == this) {
- I->second->~StructLayout();
- free(I->second);
- TheMap.erase(I++);
- } else {
- ++I;
- }
+ if (!LayoutInfo.isConstructed())
+ return;
+
+ // Remove any layouts for this TD.
+ LayoutInfoTy &TheMap = *LayoutInfo;
+ for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
+ if (I->first.first == this) {
+ I->second->~StructLayout();
+ free(I->second);
+ TheMap.erase(I++);
+ } else {
+ ++I;
}
}
}
if (!LayoutInfo.isConstructed()) return; // No cache.
LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
- if (I != LayoutInfo->end()) {
- I->second->~StructLayout();
- free(I->second);
- LayoutInfo->erase(I);
- }
+ if (I == LayoutInfo->end()) return;
+
+ I->second->~StructLayout();
+ free(I->second);
+ LayoutInfo->erase(I);
}
return getPointerSizeInBits();
case Type::ArrayTyID: {
const ArrayType *ATy = cast<ArrayType>(Ty);
- return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
+ return getTypePaddedSizeInBits(ATy->getElementType())*ATy->getNumElements();
}
- case Type::StructTyID: {
+ case Type::StructTyID:
// Get the layout annotation... which is lazily created on demand.
- const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
- return Layout->getSizeInBits();
- }
+ return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
case Type::IntegerTyID:
return cast<IntegerType>(Ty)->getBitWidth();
case Type::VoidTyID:
// only 80 bits contain information.
case Type::X86_FP80TyID:
return 80;
- case Type::VectorTyID: {
- const VectorType *PTy = cast<VectorType>(Ty);
- return PTy->getBitWidth();
- }
+ case Type::VectorTyID:
+ return cast<VectorType>(Ty)->getBitWidth();
default:
assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type");
break;
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
switch (Ty->getTypeID()) {
- /* Early escape for the non-numeric types */
+ // Early escape for the non-numeric types.
case Type::LabelTyID:
case Type::PointerTyID:
return (abi_or_pref
// Get the layout annotation... which is lazily created on demand.
const StructLayout *Layout = getStructLayout(cast<StructType>(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:
case Type::X86_FP80TyID:
AlignType = FLOAT_ALIGN;
break;
- case Type::VectorTyID: {
- const VectorType *VTy = cast<VectorType>(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 {
// Get the array index and the size of each array element.
int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
- Result += arrayIdx * (int64_t)getABITypeSize(Ty);
+ Result += arrayIdx * (int64_t)getTypePaddedSize(Ty);
}
}
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));
+}
projects / oota-llvm.git / blobdiff