//===----------------------------------------------------------------------===//
#include "llvm/Target/TargetData.h"
+#include "llvm/Module.h"
#include "llvm/DerivedTypes.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/Constants.h"
+
+// Handle the Pass registration stuff neccesary to use TargetData's.
+namespace {
+ // Register the default SparcV9 implementation...
+ RegisterPass<TargetData> X("targetdata", "Target Data Layout");
+}
+
static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
- unsigned &Size, unsigned char &Alignment);
+ uint64_t &Size, unsigned char &Alignment);
//===----------------------------------------------------------------------===//
// Support for StructLayout Annotation
TE = ST->getElementTypes().end(); TI != TE; ++TI) {
const Type *Ty = *TI;
unsigned char A;
- unsigned TySize, TyAlign;
- getTypeInfo(Ty, &TD, TySize, A); TyAlign = A;
+ unsigned TyAlign;
+ uint64_t TySize;
+ getTypeInfo(Ty, &TD, TySize, A);
+ TyAlign = A;
// Add padding if neccesary to make the data element aligned properly...
if (StructSize % TyAlign != 0)
StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
// Keep track of maximum alignment constraint
- StructAlignment = max(TyAlign, StructAlignment);
+ StructAlignment = std::max(TyAlign, StructAlignment);
MemberOffsets.push_back(StructSize);
- StructSize += TySize; // Consume space for this data item...
+ StructSize += TySize; // Consume space for this data item
}
// Add padding to the end of the struct so that it could be put in an array
void *D) {
const TargetData &TD = *(const TargetData*)D;
assert(AID == TD.AID && "Target data annotation ID mismatch!");
- const Type *Ty = ((const Value *)T)->castTypeAsserting();
- assert(Ty->isStructType() &&
+ const Type *Ty = cast<const Type>((const Value *)T);
+ assert(isa<StructType>(Ty) &&
"Can only create StructLayout annotation on structs!");
return new StructLayout((const StructType *)Ty, TD);
}
// TargetData Class Implementation
//===----------------------------------------------------------------------===//
-TargetData::TargetData(const string &TargetName, unsigned char PtrSize = 8,
- unsigned char PtrAl = 8, unsigned char DoubleAl = 8,
- unsigned char FloatAl = 4, unsigned char LongAl = 8,
- unsigned char IntAl = 4, unsigned char ShortAl = 2,
- unsigned char ByteAl = 1)
+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 IntAl, unsigned char ShortAl,
+ unsigned char ByteAl)
: AID(AnnotationManager::getID("TargetData::" + TargetName)) {
AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
+ // 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
+ // construct, or else we might end up using a bad endianness or pointer size!
+ //
+ assert(!TargetName.empty() &&
+ "ERROR: Tool did not specify a target data to use!");
+
+ LittleEndian = isLittleEndian;
PointerSize = PtrSize;
PointerAlignment = PtrAl;
DoubleAlignment = DoubleAl;
+ assert(DoubleAlignment == PtrAl &&
+ "Double alignment and pointer alignment agree for now!");
FloatAlignment = FloatAl;
LongAlignment = LongAl;
IntAlignment = IntAl;
ByteAlignment = ByteAl;
}
+TargetData::TargetData(const std::string &ToolName, const Module *M)
+ : AID(AnnotationManager::getID("TargetData::" + ToolName)) {
+ AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
+
+ LittleEndian = M->isLittleEndian();
+ PointerSize = M->has32BitPointers() ? 4 : 8;
+ PointerAlignment = PointerSize;
+ DoubleAlignment = PointerSize;
+ FloatAlignment = 4;
+ LongAlignment = 8;
+ IntAlignment = 4;
+ ShortAlignment = 2;
+ ByteAlignment = 1;
+}
+
TargetData::~TargetData() {
AnnotationManager::registerAnnotationFactory(AID, 0); // Deregister factory
}
static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
- unsigned &Size, unsigned char &Alignment) {
+ uint64_t &Size, unsigned char &Alignment) {
+ assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
switch (Ty->getPrimitiveID()) {
case Type::VoidTyID:
case Type::BoolTyID:
return;
case Type::ArrayTyID: {
const ArrayType *ATy = (const ArrayType *)Ty;
- assert(ATy->isSized() && "Can't get TypeInfo of an unsized array!");
getTypeInfo(ATy->getElementType(), TD, Size, Alignment);
Size *= ATy->getNumElements();
return;
}
}
-unsigned TargetData::getTypeSize(const Type *Ty) const {
- unsigned Size; unsigned char Align;
+uint64_t TargetData::getTypeSize(const Type *Ty) const {
+ uint64_t Size;
+ unsigned char Align;
getTypeInfo(Ty, this, Size, Align);
return Size;
}
unsigned char TargetData::getTypeAlignment(const Type *Ty) const {
- unsigned Size; unsigned char Align;
+ uint64_t Size;
+ unsigned char Align;
getTypeInfo(Ty, this, Size, Align);
return Align;
}
-unsigned TargetData::getIndexedOffset(const Type *ptrTy,
- const vector<ConstPoolVal*> &Idx) const {
- const PointerType *PtrTy = ptrTy->castPointerType();
- unsigned Result = 0;
+uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
+ const std::vector<Value*> &Idx) const {
+ const Type *Ty = ptrTy;
+ assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
+ uint64_t Result = 0;
+
+ for (unsigned CurIDX = 0; CurIDX != Idx.size(); ++CurIDX) {
+ if (Idx[CurIDX]->getType() == Type::LongTy) {
+ // Update Ty to refer to current element
+ Ty = cast<SequentialType>(Ty)->getElementType();
- // Get the type pointed to...
- const Type *Ty = PtrTy->getValueType();
+ // Get the array index and the size of each array element.
+ // Both must be known constants, or the index shd be 0; else this fails.
+ int64_t arrayIdx = cast<ConstantSInt>(Idx[CurIDX])->getValue();
+ Result += arrayIdx == 0? 0
+ : (uint64_t) (arrayIdx * (int64_t) getTypeSize(Ty));
- for (unsigned CurIDX = 0; CurIDX < Idx.size(); ++CurIDX) {
- if (const StructType *STy = Ty->dyncastStructType()) {
+ } else if (const StructType *STy = dyn_cast<const StructType>(Ty)) {
assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx");
- unsigned FieldNo = ((ConstPoolUInt*)Idx[CurIDX++])->getValue();
+ unsigned FieldNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
// Get structure layout information...
const StructLayout *Layout = getStructLayout(STy);
// Add in the offset, as calculated by the structure layout info...
- assert(FieldNo < Layout->MemberOffsets.size() && "FieldNo out of range!");
+ assert(FieldNo < Layout->MemberOffsets.size() &&"FieldNo out of range!");
Result += Layout->MemberOffsets[FieldNo];
-
+
// Update Ty to refer to current element
Ty = STy->getElementTypes()[FieldNo];
-
- } else if (const ArrayType *ATy = Ty->dyncastArrayType()) {
- assert(0 && "Loading from arrays not implemented yet!");
} else {
assert(0 && "Indexing type that is not struct or array?");
return 0; // Load directly through ptr
projects / oota-llvm.git / blobdiff