X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=include%2Fllvm%2FTarget%2FTargetData.h;h=f8ea64b4ea66b43b53544d01acb100c67770aa9d;hp=fdb21c5ea1e0f4c3d228466eb4b5e42dbc22872d;hb=9085750d3126618ab1b3a4104c34bc504f8b09f4;hpb=0a3ba71a0576fbde5b8ce1ff276f63f3f3d16229 diff --git a/include/llvm/Target/TargetData.h b/include/llvm/Target/TargetData.h index fdb21c5ea1e..f8ea64b4ea6 100644 --- a/include/llvm/Target/TargetData.h +++ b/include/llvm/Target/TargetData.h @@ -22,6 +22,7 @@ #include "llvm/Pass.h" #include "llvm/Support/DataTypes.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/ADT/SmallVector.h" #include @@ -29,9 +30,11 @@ namespace llvm { class Value; class Type; +class IntegerType; class StructType; class StructLayout; class GlobalVariable; +class LLVMContext; /// Enum used to categorize the alignment types stored by TargetAlignElem enum AlignTypeEnum { @@ -88,6 +91,9 @@ private: */ static const TargetAlignElem InvalidAlignmentElem; + // Opaque pointer for the StructType -> StructLayout map. + mutable void* LayoutMap; + //! Set/initialize target alignments void setAlignment(AlignTypeEnum align_type, unsigned char abi_align, unsigned char pref_align, uint32_t bit_width); @@ -109,15 +115,14 @@ public: /// /// @note This has to exist, because this is a pass, but it should never be /// used. - TargetData() : ImmutablePass(intptr_t(&ID)) { - assert(0 && "ERROR: Bad TargetData ctor used. " - "Tool did not specify a TargetData to use?"); - abort(); + TargetData() : ImmutablePass(&ID) { + llvm_report_error("Bad TargetData ctor used. " + "Tool did not specify a TargetData to use?"); } /// Constructs a TargetData from a specification string. See init(). explicit TargetData(const std::string &TargetDescription) - : ImmutablePass(intptr_t(&ID)) { + : ImmutablePass(&ID) { init(TargetDescription); } @@ -125,12 +130,13 @@ public: explicit TargetData(const Module *M); TargetData(const TargetData &TD) : - ImmutablePass(intptr_t(&ID)), + ImmutablePass(&ID), LittleEndian(TD.isLittleEndian()), PointerMemSize(TD.PointerMemSize), PointerABIAlign(TD.PointerABIAlign), PointerPrefAlign(TD.PointerPrefAlign), - Alignments(TD.Alignments) + Alignments(TD.Alignments), + LayoutMap(0) { } ~TargetData(); // Not virtual, do not subclass this class @@ -155,6 +161,23 @@ public: /// Target pointer size, in bits unsigned char getPointerSizeInBits() const { return 8*PointerMemSize; } + /// Size examples: + /// + /// Type SizeInBits StoreSizeInBits AllocSizeInBits[*] + /// ---- ---------- --------------- --------------- + /// i1 1 8 8 + /// i8 8 8 8 + /// i19 19 24 32 + /// i32 32 32 32 + /// i100 100 104 128 + /// i128 128 128 128 + /// Float 32 32 32 + /// Double 64 64 64 + /// X86_FP80 80 80 96 + /// + /// [*] The alloc size depends on the alignment, and thus on the target. + /// These values are for x86-32 linux. + /// getTypeSizeInBits - Return the number of bits necessary to hold the /// specified type. For example, returns 36 for i36 and 80 for x86_fp80. uint64_t getTypeSizeInBits(const Type* Ty) const; @@ -173,25 +196,21 @@ public: return 8*getTypeStoreSize(Ty); } - /// getABITypeSize - Return the offset in bytes between successive objects + /// getTypeAllocSize - Return the offset in bytes between successive objects /// of the specified type, including alignment padding. This is the amount /// that alloca reserves for this type. For example, returns 12 or 16 for /// x86_fp80, depending on alignment. - uint64_t getABITypeSize(const Type* Ty) const { - // The alignment of a type is always a power of two. - unsigned char AlignMinusOne = getABITypeAlignment(Ty)-1; - + uint64_t getTypeAllocSize(const Type* Ty) const { // Round up to the next alignment boundary. - uint64_t RoundUp = getTypeStoreSize(Ty) + AlignMinusOne; - return RoundUp &= ~uint64_t(AlignMinusOne); + return RoundUpAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); } - /// getABITypeSizeInBits - Return the offset in bits between successive + /// getTypeAllocSizeInBits - Return the offset in bits between successive /// objects of the specified type, including alignment padding; always a /// multiple of 8. This is the amount that alloca reserves for this type. /// For example, returns 96 or 128 for x86_fp80, depending on alignment. - uint64_t getABITypeSizeInBits(const Type* Ty) const { - return 8*getABITypeSize(Ty); + uint64_t getTypeAllocSizeInBits(const Type* Ty) const { + return 8*getTypeAllocSize(Ty); } /// getABITypeAlignment - Return the minimum ABI-required alignment for the @@ -215,10 +234,10 @@ public: /// getIntPtrType - Return an unsigned integer type that is the same size or /// greater to the host pointer size. /// - const Type *getIntPtrType() const; + const IntegerType *getIntPtrType(LLVMContext &C) const; - /// getIndexedOffset - return the offset from the beginning of the type for the - /// specified indices. This is used to implement getelementptr. + /// getIndexedOffset - return the offset from the beginning of the type for + /// the specified indices. This is used to implement getelementptr. /// uint64_t getIndexedOffset(const Type *Ty, Value* const* Indices, unsigned NumIndices) const; @@ -244,6 +263,16 @@ public: /// requested alignment (if the global has one). unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const; + /// RoundUpAlignment - Round the specified value up to the next alignment + /// boundary specified by Alignment. For example, 7 rounded up to an + /// alignment boundary of 4 is 8. 8 rounded up to the alignment boundary of 4 + /// is 8 because it is already aligned. + template + static UIntTy RoundUpAlignment(UIntTy Val, unsigned Alignment) { + assert((Alignment & (Alignment-1)) == 0 && "Alignment must be power of 2!"); + return (Val + (Alignment-1)) & ~UIntTy(Alignment-1); + } + static char ID; // Pass identification, replacement for typeid }; @@ -269,7 +298,7 @@ public: return StructAlignment; } - /// getElementContainingOffset - Given a valid offset into the structure, + /// getElementContainingOffset - Given a valid byte offset into the structure, /// return the structure index that contains it. /// unsigned getElementContainingOffset(uint64_t Offset) const;