X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FTargetData.cpp;h=fc58f577497143d12d2ae23afcac08fb3cf72f6d;hb=f311e8b901bbaa2d4749d257461866861501edf2;hp=24a5e852a219606b544d3b49f88ca063a7d5ce2d;hpb=cfe26c930ae691ff3012736555846c45087e1a9e;p=oota-llvm.git diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp index 24a5e852a21..fc58f577497 100644 --- a/lib/Target/TargetData.cpp +++ b/lib/Target/TargetData.cpp @@ -1,8 +1,14 @@ //===-- 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 -// information. It uses lazy annotations to cache information about how -// structure types are laid out and used. +// information. // // This structure should be created once, filled in if the defaults are not // correct and then passed around by const&. None of the members functions @@ -11,74 +17,79 @@ //===----------------------------------------------------------------------===// #include "llvm/Target/TargetData.h" +#include "llvm/Module.h" #include "llvm/DerivedTypes.h" -#include "llvm/ConstPoolVals.h" +#include "llvm/Constants.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/MathExtras.h" +using namespace llvm; + +// Handle the Pass registration stuff necessary 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 +// Support for StructLayout //===----------------------------------------------------------------------===// -StructLayout::StructLayout(const StructType *ST, const TargetData &TD) - : Annotation(TD.getStructLayoutAID()) { +StructLayout::StructLayout(const StructType *ST, const TargetData &TD) { StructAlignment = 0; StructSize = 0; // Loop over each of the elements, placing them in memory... - for (StructType::ElementTypes::const_iterator - TI = ST->getElementTypes().begin(), - TE = ST->getElementTypes().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 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... + // Add padding if necessary 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 } + // Empty structures have alignment of 1 byte. + if (StructAlignment == 0) StructAlignment = 1; + // Add padding to the end of the struct so that it could be put in an array // and all array elements would be aligned correctly. if (StructSize % StructAlignment != 0) StructSize = (StructSize/StructAlignment + 1) * StructAlignment; - - if (StructSize == 0) { - StructSize = 1; // Empty struct is 1 byte - StructAlignment = 1; - } -} - -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 = cast((const Value *)T); - assert(Ty->isStructType() && - "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) - : AID(AnnotationManager::getID("TargetData::" + TargetName)) { - AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this); +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, 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 + // 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; @@ -87,17 +98,62 @@ TargetData::TargetData(const string &TargetName, unsigned char PtrSize = 8, IntAlignment = IntAl; ShortAlignment = ShortAl; ByteAlignment = ByteAl; + BoolAlignment = BoolAl; +} + +TargetData::TargetData(const std::string &ToolName, const Module *M) { + LittleEndian = M->getEndianness() != Module::BigEndian; + PointerSize = M->getPointerSize() != Module::Pointer64 ? 4 : 8; + PointerAlignment = PointerSize; + DoubleAlignment = PointerSize; + FloatAlignment = 4; + LongAlignment = PointerSize; + IntAlignment = 4; + ShortAlignment = 2; + ByteAlignment = 1; + BoolAlignment = 1; } +static std::map, + StructLayout> *Layouts = 0; + + TargetData::~TargetData() { - AnnotationManager::registerAnnotationFactory(AID, 0); // Deregister factory + if (Layouts) { + // Remove any layouts for this TD. + std::map, StructLayout>::iterator + I = Layouts->lower_bound(std::make_pair(this, (const StructType*)0)); + while (I != Layouts->end() && I->first.first == this) + Layouts->erase(I++); + if (Layouts->empty()) { + delete Layouts; + Layouts = 0; + } + } +} + +const StructLayout *TargetData::getStructLayout(const StructType *Ty) const { + if (Layouts == 0) + Layouts = new std::map, + StructLayout>(); + std::map, + StructLayout>::iterator + I = Layouts->lower_bound(std::make_pair(this, Ty)); + if (I != Layouts->end() && I->first.first == this && I->first.second == Ty) + return &I->second; + else { + return &Layouts->insert(I, std::make_pair(std::make_pair(this, Ty), + StructLayout(Ty, *this)))->second; + } } static inline void getTypeInfo(const Type *Ty, const TargetData *TD, - unsigned &Size, unsigned char &Alignment) { - switch (Ty->getPrimitiveID()) { + 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: @@ -113,68 +169,96 @@ static inline void getTypeInfo(const Type *Ty, const TargetData *TD, Size = TD->getPointerSize(); Alignment = TD->getPointerAlignment(); return; case Type::ArrayTyID: { - const ArrayType *ATy = (const ArrayType *)Ty; - assert(ATy->isSized() && "Can't get TypeInfo of an unsized array!"); + const ArrayType *ATy = cast(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(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(Ty)); Size = Layout->StructSize; Alignment = Layout->StructAlignment; return; } - case Type::TypeTyID: default: assert(0 && "Bad type for getTypeInfo!!!"); 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 &Idx) const { - const PointerType *PtrTy = ptrTy->castPointerType(); - unsigned Result = 0; +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(Align); +} - // Get the type pointed to... - const Type *Ty = PtrTy->getValueType(); +/// getIntPtrType - Return an unsigned integer type that is the same size or +/// greater to the host pointer size. +const Type *TargetData::getIntPtrType() const { + switch (getPointerSize()) { + default: assert(0 && "Unknown pointer size!"); + case 2: return Type::UShortTy; + case 4: return Type::UIntTy; + case 8: return Type::ULongTy; + } +} - for (unsigned CurIDX = 0; CurIDX < Idx.size(); ++CurIDX) { - if (const StructType *STy = Ty->dyncastStructType()) { - assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx"); - unsigned FieldNo = ((ConstPoolUInt*)Idx[CurIDX++])->getValue(); + +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; + + generic_gep_type_iterator::const_iterator> + TI = gep_type_begin(ptrTy, Idx.begin(), Idx.end()); + for (unsigned CurIDX = 0; CurIDX != Idx.size(); ++CurIDX, ++TI) { + if (const StructType *STy = dyn_cast(*TI)) { + assert(Idx[CurIDX]->getType() == Type::UIntTy && "Illegal struct idx"); + 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()) { - assert(0 && "Loading from arrays not implemented yet!"); + // Update Ty to refer to current element + Ty = STy->getElementType(FieldNo); } else { - assert(0 && "Indexing type that is not struct or array?"); - return 0; // Load directly through ptr + // Update Ty to refer to current element + Ty = cast(Ty)->getElementType(); + + // Get the array index and the size of each array element. + int64_t arrayIdx = cast(Idx[CurIDX])->getRawValue(); + Result += arrayIdx * (int64_t)getTypeSize(Ty); } } return Result; } +