// Register the default SparcV9 implementation...
RegisterPass<TargetData> X("targetdata", "Target Data Layout");
}
+char TargetData::ID = 0;
//===----------------------------------------------------------------------===//
// Support for StructLayout
<i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
specifies a little-endian target data model.
<br><br>
- <i>p:<size>:<abi_align>:<pref_align></i>: Pointer size, ABI and preferred
- alignment.
+ <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
+ ABI and preferred alignment.
<br><br>
- <i><type><size>:<abi_align>:<pref_align></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
setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
-
+
while (!temp.empty()) {
std::string token = getToken(temp, "-");
std::string arg0 = getToken(token, ":");
case 'i':
case 'v':
case 'f':
- case 'a': {
- AlignTypeEnum align_type =
- (*p == 'i' ? INTEGER_ALIGN : (*p == 'f' ? FLOAT_ALIGN :
- (*p == 'v' ? VECTOR_ALIGN : AGGREGATE_ALIGN)));
+ case 'a':
+ case 's': {
+ AlignTypeEnum align_type;
+ switch(*p) {
+ case 'i': align_type = INTEGER_ALIGN; break;
+ case 'v': align_type = VECTOR_ALIGN; break;
+ case 'f': align_type = FLOAT_ALIGN; break;
+ case 'a': align_type = AGGREGATE_ALIGN; break;
+ case 's': align_type = STACK_ALIGN; break;
+ }
uint32_t size = (uint32_t) atoi(++p);
unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
}
}
-TargetData::TargetData(const Module *M) {
+TargetData::TargetData(const Module *M)
+ : ImmutablePass((intptr_t)&ID) {
init(M->getDataLayout());
}
return LayoutKey((TargetData*)(intptr_t)-1, 0);
}
static unsigned getHashValue(const LayoutKey &Val) {
- return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
- DenseMapKeyInfo<void*>::getHashValue(Val.second);
+ return DenseMapInfo<void*>::getHashValue(Val.first) ^
+ DenseMapInfo<void*>::getHashValue(Val.second);
+ }
+ static bool isEqual(const LayoutKey &LHS, const LayoutKey &RHS) {
+ return LHS == RHS;
}
+
static bool isPod() { return true; }
};
return 4;
case Type::DoubleTyID:
return 8;
+ case Type::PPC_FP128TyID:
+ case Type::FP128TyID:
+ return 16;
+ // In memory objects this is always aligned to a higher boundary, but
+ // only 10 bytes contain information.
+ case Type::X86_FP80TyID:
+ return 10;
case Type::VectorTyID: {
const VectorType *PTy = cast<VectorType>(Ty);
return PTy->getBitWidth() / 8;
return getTypeSize(Ty) * 8;
}
-
+uint64_t TargetData::getABITypeSizeInBits(const Type *Ty) const {
+ if (Ty->isInteger())
+ return cast<IntegerType>(Ty)->getBitWidth();
+ else
+ return getABITypeSize(Ty) * 8;
+}
/*!
\param abi_or_pref Flag that determines which alignment is returned. true
returns the ABI alignment, false returns the preferred alignment.
break;
case Type::FloatTyID:
case Type::DoubleTyID:
+ // PPC_FP128TyID and FP128TyID have different data contents, but the
+ // same size and alignment, so they look the same here.
+ case Type::PPC_FP128TyID:
+ case Type::FP128TyID:
+ case Type::X86_FP80TyID:
AlignType = FLOAT_ALIGN;
break;
case Type::VectorTyID: {
return getAlignment(Ty, true);
}
+unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
+ for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
+ if (Alignments[i].AlignType == STACK_ALIGN)
+ return Alignments[i].ABIAlign;
+
+ return getABITypeAlignment(Ty);
+}
+
unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
return getAlignment(Ty, false);
}
/// getIntPtrType - Return an unsigned integer type that is the same size or
/// greater to the host pointer size.
const Type *TargetData::getIntPtrType() const {
- switch (getPointerSize()) {
- default: assert(0 && "Unknown pointer size!");
- case 2: return Type::Int16Ty;
- case 4: return Type::Int32Ty;
- case 8: return Type::Int64Ty;
- }
+ return IntegerType::get(getPointerSizeInBits());
}