X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FTargetData.cpp;h=20e7522e5036f8fef6c6798ae06108d82d6e7a99;hb=d3e0faca06397b652640de09d65b9c6cbd41da56;hp=e1415c73e87348fd50f692ab3b9699402ffab6f8;hpb=0799fc479ab1eb7261f125e2312c5e192cacdb98;p=oota-llvm.git diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp index e1415c73e87..20e7522e503 100644 --- a/lib/Target/TargetData.cpp +++ b/lib/Target/TargetData.cpp @@ -12,10 +12,17 @@ #include "llvm/Target/TargetData.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 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 @@ -32,18 +39,20 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) 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 @@ -61,8 +70,8 @@ Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T, 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 Value *)T); + assert(isa(Ty) && "Can only create StructLayout annotation on structs!"); return new StructLayout((const StructType *)Ty, TD); } @@ -71,14 +80,19 @@ Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T, // 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 SubWordSize, + unsigned char IntRegSize, 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); + LittleEndian = isLittleEndian; + SubWordDataSize = SubWordSize; + IntegerRegSize = IntRegSize; PointerSize = PtrSize; PointerAlignment = PtrAl; DoubleAlignment = DoubleAl; @@ -94,7 +108,8 @@ TargetData::~TargetData() { } 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: @@ -114,7 +129,6 @@ static inline void getTypeInfo(const Type *Ty, const TargetData *TD, 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; @@ -133,42 +147,52 @@ static inline void getTypeInfo(const Type *Ty, const TargetData *TD, } } -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 &Idx) const { - const PointerType *PtrTy = ptrTy->castPointerType(); - unsigned Result = 0; +uint64_t TargetData::getIndexedOffset(const Type *ptrTy, + const std::vector &Idx) const { + const Type *Ty = ptrTy; + assert(isa(Ty) && "Illegal argument for getIndexedOffset()"); + uint64_t Result = 0; - // Get the type pointed to... - const Type *Ty = PtrTy->getValueType(); + for (unsigned CurIDX = 0; CurIDX != Idx.size(); ++CurIDX) { + if (Idx[CurIDX]->getType() == Type::LongTy) { + // Update Ty to refer to current element + Ty = cast(Ty)->getElementType(); + + // 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(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(Ty)) { assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx"); - unsigned FieldNo = ((ConstPoolUInt*)Idx[CurIDX++])->getValue(); + unsigned FieldNo = cast(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()) { + } else if (isa(Ty)) { assert(0 && "Loading from arrays not implemented yet!"); } else { assert(0 && "Indexing type that is not struct or array?");