X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FTargetData.cpp;h=40b762d8e7392285fdc4b9e90ee1ae613694e8cf;hb=b86bd2cee25c15862247b4641700d448fbd0fa24;hp=158f57e3accf2941e27022c9c5d7ada39d0eb432;hpb=10daaa141661d96843f3d8ece0e5a4c2da4b6e87;p=oota-llvm.git diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp index 158f57e3acc..40b762d8e73 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 @@ -14,30 +20,31 @@ #include "llvm/Module.h" #include "llvm/DerivedTypes.h" #include "llvm/Constants.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/MathExtras.h" +#include +using namespace llvm; -// Handle the Pass registration stuff neccesary to use TargetData's. +// 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, - uint64_t &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 TyAlign; @@ -45,7 +52,7 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) 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... @@ -56,25 +63,29 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) 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(isa(Ty) && - "Can only create StructLayout annotation on structs!"); - return new StructLayout((const StructType *)Ty, TD); + +/// getElementContainingOffset - Given a valid offset into the structure, +/// return the structure index that contains it. +unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { + std::vector::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(); } //===----------------------------------------------------------------------===// @@ -84,14 +95,12 @@ Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T, 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) - : AID(AnnotationManager::getID("TargetData::" + TargetName)) { - AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this); + unsigned char ByteAl, unsigned char BoolAl) { // 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 + // 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() && @@ -101,40 +110,85 @@ TargetData::TargetData(const std::string &TargetName, 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) - : AID(AnnotationManager::getID("TargetData::" + ToolName)) { - AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this); - - LittleEndian = M->isLittleEndian(); - PointerSize = M->has32BitPointers() ? 4 : 8; +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 = 8; + LongAlignment = PointerSize; IntAlignment = 4; ShortAlignment = 2; ByteAlignment = 1; + BoolAlignment = 1; } +/// Layouts - The lazy cache of structure layout information maintained by +/// TargetData. +/// +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; + } } +/// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout +/// objects. If a TargetData object is alive when types are being refined and +/// removed, this method must be called whenever a StructType is removed to +/// avoid a dangling pointer in this cache. +void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const { + if (!Layouts) return; // No cache. + + std::map, + StructLayout>::iterator I = Layouts->find(std::make_pair(this, Ty)); + if (I != Layouts->end()) + Layouts->erase(I); +} + + + 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->getPrimitiveID()) { + 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: @@ -150,19 +204,26 @@ 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; + 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; @@ -183,25 +244,35 @@ unsigned char TargetData::getTypeAlignment(const Type *Ty) const { 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 { + switch (getPointerSize()) { + default: assert(0 && "Unknown pointer size!"); + case 2: return Type::UShortTy; + case 4: return Type::UIntTy; + case 8: return Type::ULongTy; + } +} + + uint64_t TargetData::getIndexedOffset(const Type *ptrTy, - const std::vector &Idx) const { + const std::vector &Idx) const { const Type *Ty = ptrTy; assert(isa(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(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)); - - } else if (const StructType *STy = dyn_cast(Ty)) { - assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx"); + 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... @@ -212,12 +283,17 @@ uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Result += Layout->MemberOffsets[FieldNo]; // Update Ty to refer to current element - Ty = STy->getElementTypes()[FieldNo]; + 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; } +