//===-- TargetData.cpp - Data size & alignment routines --------------------==//
-//
+//
// 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 defines target properties related to datatype size/offset/alignment
#include "llvm/DerivedTypes.h"
#include "llvm/Constants.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/MathExtras.h"
+#include <algorithm>
using namespace llvm;
// Handle the Pass registration stuff necessary to use TargetData's.
}
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
StructSize = 0;
// 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) {
+ for (StructType::element_iterator TI = ST->element_begin(),
+ TE = ST->element_end(); TI != TE; ++TI) {
const Type *Ty = *TI;
unsigned char A;
unsigned TyAlign;
StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
}
+
+/// getElementContainingOffset - Given a valid offset into the structure,
+/// return the structure index that contains it.
+unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
+ std::vector<uint64_t>::const_iterator SI =
+ std::upper_bound(MemberOffsets.begin(), MemberOffsets.end(),
+ Offset);
+ assert(SI != MemberOffsets.begin() && "Offset not in structure type!");
+ --SI;
+ assert(*SI <= Offset && "upper_bound didn't work");
+ assert((SI == MemberOffsets.begin() || *(SI-1) < Offset) &&
+ (SI+1 == MemberOffsets.end() || *(SI+1) > Offset) &&
+ "Upper bound didn't work!");
+ return SI-MemberOffsets.begin();
+}
+
//===----------------------------------------------------------------------===//
// TargetData Class Implementation
//===----------------------------------------------------------------------===//
TargetData::TargetData(const std::string &TargetName,
bool isLittleEndian, unsigned char PtrSize,
unsigned char PtrAl, unsigned char DoubleAl,
- unsigned char FloatAl, unsigned char LongAl,
+ 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 one for it. We do not want to default
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) {
PointerAlignment = PointerSize;
DoubleAlignment = PointerSize;
FloatAlignment = 4;
- LongAlignment = 8;
+ LongAlignment = PointerSize;
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->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::PackedTyID: {
+ const PackedType *PTy = cast<PackedType>(Ty);
+ getTypeInfo(PTy->getElementType(), TD, Size, Alignment);
+ unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
+ Size = AlignedSize*PTy->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;
return Align;
}
+unsigned char TargetData::getTypeAlignmentShift(const Type *Ty) const {
+ unsigned Align = getTypeAlignment(Ty);
+ assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
+ return Log2_32(Align);
+}
+
/// getIntPtrType - Return an unsigned integer type that is the same size or
/// greater to the host pointer size.
const Type *TargetData::getIntPtrType() const {
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;