Add integer register size field.
Make all sizes and offsets uint64_t instead of uint.
Fixed GetIndexedOffset to handle mixed array and struct indices.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2641 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index 85c9e68..e306d4e 100644
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -15,7 +15,7 @@
#include "llvm/Constants.h"
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
@@ -32,8 +32,10 @@
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)
@@ -43,7 +45,7 @@
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
@@ -61,17 +63,18 @@
void *D) {
const TargetData &TD = *(const TargetData*)D;
assert(AID == TD.AID && "Target data annotation ID mismatch!");
- const Type *Ty = cast<Type>((const Value *)T);
+ const Type *Ty = cast<const Type>((const Value *)T);
assert(isa<StructType>(Ty) &&
"Can only create StructLayout annotation on structs!");
- return new StructLayout(cast<StructType>(Ty), TD);
+ return new StructLayout((const StructType *)Ty, TD);
}
//===----------------------------------------------------------------------===//
// TargetData Class Implementation
//===----------------------------------------------------------------------===//
-TargetData::TargetData(const std::string &TargetName, unsigned char PtrSize = 8,
+TargetData::TargetData(const std::string &TargetName,
+ unsigned char IntRegSize = 8, 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,
@@ -79,6 +82,7 @@
: AID(AnnotationManager::getID("TargetData::" + TargetName)) {
AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
+ IntegerRegSize = IntRegSize;
PointerSize = PtrSize;
PointerAlignment = PtrAl;
DoubleAlignment = DoubleAl;
@@ -94,7 +98,7 @@
}
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:
@@ -133,24 +137,37 @@
}
}
-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 *Ty,
+uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
const std::vector<Value*> &Idx) const {
- unsigned Result = 0;
+ const PointerType *PtrTy = cast<const PointerType>(ptrTy);
+ uint64_t Result = 0;
- for (unsigned CurIDX = 0, E = Idx.size(); CurIDX != E; ++CurIDX) {
- if (const StructType *STy = dyn_cast<StructType>(Ty)) {
+ // Get the type pointed to...
+ const Type *Ty = PtrTy->getElementType();
+
+ for (unsigned CurIDX = 0; CurIDX < Idx.size(); ++CurIDX) {
+ if (Idx[CurIDX]->getType() == Type::UIntTy) {
+ // Get the array index and the size of each array element.
+ // Both must be known constants, or this will fail.
+ unsigned arrayIdx = cast<ConstantUInt>(Idx[CurIDX])->getValue();
+ uint64_t elementSize = this->getTypeSize(Ty);
+ Result += arrayIdx * elementSize;
+
+ } else if (const StructType *STy = dyn_cast<const StructType>(Ty)) {
assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx");
unsigned FieldNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
@@ -158,23 +175,16 @@
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 SequentialType *STy = dyn_cast<SequentialType>(Ty)) {
- assert(Idx[CurIDX]->getType() == Type::UIntTy &&"Illegal sequential idx");
- assert(isa<ConstantUInt>(Idx[CurIDX]) &&
- "getIndexedOffset cannot compute offset of non-constant index!");
-
- unsigned IndexNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
- Ty = STy->getElementType();
-
- Result += IndexNo*getTypeSize(Ty);
+ } else if (isa<const ArrayType>(Ty)) {
+ assert(0 && "Loading from arrays not implemented yet!");
} else {
- assert(0 && "Indexing type that is not struct, array, or pointer?");
+ assert(0 && "Indexing type that is not struct or array?");
return 0; // Load directly through ptr
}
}