}
static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
- uint64_t &Size, unsigned char &Alignment);
+ uint64_t &Size, unsigned char &Alignment);
//===----------------------------------------------------------------------===//
// Support for StructLayout
// Loop over each of the elements, placing them in memory...
for (StructType::element_iterator TI = ST->element_begin(),
- TE = ST->element_end(); TI != TE; ++TI) {
+ TE = ST->element_end(); TI != TE; ++TI) {
const Type *Ty = *TI;
unsigned char A;
unsigned TyAlign;
unsigned char PtrAl, unsigned char DoubleAl,
unsigned char FloatAl, unsigned char LongAl,
unsigned char IntAl, unsigned char ShortAl,
- unsigned char ByteAl) {
+ unsigned char ByteAl, unsigned char BoolAl) {
// If this assert triggers, a pass "required" TargetData information, but the
- // top level tool did not provide once for it. We do not want to default
+ // top level tool did not provide one for it. We do not want to default
// construct, or else we might end up using a bad endianness or pointer size!
//
assert(!TargetName.empty() &&
PointerSize = PtrSize;
PointerAlignment = PtrAl;
DoubleAlignment = DoubleAl;
- assert(DoubleAlignment == PtrAl &&
- "Double alignment and pointer alignment agree for now!");
FloatAlignment = FloatAl;
LongAlignment = LongAl;
IntAlignment = IntAl;
ShortAlignment = ShortAl;
ByteAlignment = ByteAl;
+ BoolAlignment = BoolAl;
}
TargetData::TargetData(const std::string &ToolName, const Module *M) {
IntAlignment = 4;
ShortAlignment = 2;
ByteAlignment = 1;
+ BoolAlignment = 1;
}
static std::map<std::pair<const TargetData*,const StructType*>,
}
static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
- uint64_t &Size, unsigned char &Alignment) {
+ uint64_t &Size, unsigned char &Alignment) {
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
+ case Type::BoolTyID: Size = 1; Alignment = TD->getBoolAlignment(); return;
case Type::VoidTyID:
- case Type::BoolTyID:
case Type::UByteTyID:
case Type::SByteTyID: Size = 1; Alignment = TD->getByteAlignment(); return;
case Type::UShortTyID:
Size = TD->getPointerSize(); Alignment = TD->getPointerAlignment();
return;
case Type::ArrayTyID: {
- const ArrayType *ATy = (const ArrayType *)Ty;
+ const ArrayType *ATy = cast<ArrayType>(Ty);
getTypeInfo(ATy->getElementType(), TD, Size, Alignment);
- Size *= ATy->getNumElements();
+ unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
+ Size = AlignedSize*ATy->getNumElements();
return;
}
case Type::StructTyID: {
// Get the layout annotation... which is lazily created on demand.
- const StructLayout *Layout = TD->getStructLayout((const StructType*)Ty);
+ const StructLayout *Layout = TD->getStructLayout(cast<StructType>(Ty));
Size = Layout->StructSize; Alignment = Layout->StructAlignment;
return;
}
- case Type::TypeTyID:
default:
assert(0 && "Bad type for getTypeInfo!!!");
return;
uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
- const std::vector<Value*> &Idx) const {
+ const std::vector<Value*> &Idx) const {
const Type *Ty = ptrTy;
assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
uint64_t Result = 0;