From c653b442761c46b39e62d9a66f08bed6eb50bd2e Mon Sep 17 00:00:00 2001 From: Pete Cooper Date: Fri, 24 Jul 2015 18:29:09 +0000 Subject: [PATCH] Add const to a bunch of Type* in DataLayout. NFC. Almost all methods in DataLayout took mutable pointers but didn't need to. These were only accessing constant methods of the types, or using the Type* to key a map. Neither of these needs a mutable pointer. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@243135 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/DataLayout.h | 36 ++++++++++++++++++------------------ lib/IR/DataLayout.cpp | 26 +++++++++++++------------- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/include/llvm/IR/DataLayout.h b/include/llvm/IR/DataLayout.h index 892d6c9936c..b193517380b 100644 --- a/include/llvm/IR/DataLayout.h +++ b/include/llvm/IR/DataLayout.h @@ -150,12 +150,12 @@ private: void setAlignment(AlignTypeEnum align_type, unsigned abi_align, unsigned pref_align, uint32_t bit_width); unsigned getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width, - bool ABIAlign, Type *Ty) const; + bool ABIAlign, const Type *Ty) const; void setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign, unsigned PrefAlign, uint32_t TypeByteWidth); /// Internal helper method that returns requested alignment for type. - unsigned getAlignment(Type *Ty, bool abi_or_pref) const; + unsigned getAlignment(const Type *Ty, bool abi_or_pref) const; /// \brief Valid alignment predicate. /// @@ -335,9 +335,9 @@ public: /// If this function is called with a vector of pointers, then the type size /// of the pointer is returned. This should only be called with a pointer or /// vector of pointers. - unsigned getPointerTypeSizeInBits(Type *) const; + unsigned getPointerTypeSizeInBits(const Type *) const; - unsigned getPointerTypeSize(Type *Ty) const { + unsigned getPointerTypeSize(const Type *Ty) const { return getPointerTypeSizeInBits(Ty) / 8; } @@ -362,13 +362,13 @@ public: /// /// For example, returns 36 for i36 and 80 for x86_fp80. The type passed must /// have a size (Type::isSized() must return true). - uint64_t getTypeSizeInBits(Type *Ty) const; + uint64_t getTypeSizeInBits(const Type *Ty) const; /// \brief Returns the maximum number of bytes that may be overwritten by /// storing the specified type. /// /// For example, returns 5 for i36 and 10 for x86_fp80. - uint64_t getTypeStoreSize(Type *Ty) const { + uint64_t getTypeStoreSize(const Type *Ty) const { return (getTypeSizeInBits(Ty) + 7) / 8; } @@ -376,7 +376,7 @@ public: /// storing the specified type; always a multiple of 8. /// /// For example, returns 40 for i36 and 80 for x86_fp80. - uint64_t getTypeStoreSizeInBits(Type *Ty) const { + uint64_t getTypeStoreSizeInBits(const Type *Ty) const { return 8 * getTypeStoreSize(Ty); } @@ -385,7 +385,7 @@ public: /// /// This is the amount that alloca reserves for this type. For example, /// returns 12 or 16 for x86_fp80, depending on alignment. - uint64_t getTypeAllocSize(Type *Ty) const { + uint64_t getTypeAllocSize(const Type *Ty) const { // Round up to the next alignment boundary. return RoundUpToAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); } @@ -395,12 +395,12 @@ public: /// /// This is the amount that alloca reserves for this type. For example, /// returns 96 or 128 for x86_fp80, depending on alignment. - uint64_t getTypeAllocSizeInBits(Type *Ty) const { + uint64_t getTypeAllocSizeInBits(const Type *Ty) const { return 8 * getTypeAllocSize(Ty); } /// \brief Returns the minimum ABI-required alignment for the specified type. - unsigned getABITypeAlignment(Type *Ty) const; + unsigned getABITypeAlignment(const Type *Ty) const; /// \brief Returns the minimum ABI-required alignment for an integer type of /// the specified bitwidth. @@ -410,11 +410,11 @@ public: /// type. /// /// This is always at least as good as the ABI alignment. - unsigned getPrefTypeAlignment(Type *Ty) const; + unsigned getPrefTypeAlignment(const Type *Ty) const; /// \brief Returns the preferred alignment for the specified type, returned as /// log2 of the value (a shift amount). - unsigned getPreferredTypeAlignmentShift(Type *Ty) const; + unsigned getPreferredTypeAlignmentShift(const Type *Ty) const; /// \brief Returns an integer type with size at least as big as that of a /// pointer in the given address space. @@ -422,7 +422,7 @@ public: /// \brief Returns an integer (vector of integer) type with size at least as /// big as that of a pointer of the given pointer (vector of pointer) type. - Type *getIntPtrType(Type *) const; + Type *getIntPtrType(const Type *) const; /// \brief Returns the smallest integer type with size at least as big as /// Width bits. @@ -448,7 +448,7 @@ public: /// struct, its size, and the offsets of its fields. /// /// Note that this information is lazily cached. - const StructLayout *getStructLayout(StructType *Ty) const; + const StructLayout *getStructLayout(const StructType *Ty) const; /// \brief Returns the preferred alignment of the specified global. /// @@ -499,12 +499,12 @@ public: private: friend class DataLayout; // Only DataLayout can create this class - StructLayout(StructType *ST, const DataLayout &DL); + StructLayout(const StructType *ST, const DataLayout &DL); }; // The implementation of this method is provided inline as it is particularly // well suited to constant folding when called on a specific Type subclass. -inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const { +inline uint64_t DataLayout::getTypeSizeInBits(const Type *Ty) const { assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); switch (Ty->getTypeID()) { case Type::LabelTyID: @@ -512,7 +512,7 @@ inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const { case Type::PointerTyID: return getPointerSizeInBits(Ty->getPointerAddressSpace()); case Type::ArrayTyID: { - ArrayType *ATy = cast(Ty); + const ArrayType *ATy = cast(Ty); return ATy->getNumElements() * getTypeAllocSizeInBits(ATy->getElementType()); } @@ -536,7 +536,7 @@ inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const { case Type::X86_FP80TyID: return 80; case Type::VectorTyID: { - VectorType *VTy = cast(Ty); + const VectorType *VTy = cast(Ty); return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType()); } default: diff --git a/lib/IR/DataLayout.cpp b/lib/IR/DataLayout.cpp index 80a59e05bc5..c880bcec11e 100644 --- a/lib/IR/DataLayout.cpp +++ b/lib/IR/DataLayout.cpp @@ -37,7 +37,7 @@ using namespace llvm; // Support for StructLayout //===----------------------------------------------------------------------===// -StructLayout::StructLayout(StructType *ST, const DataLayout &DL) { +StructLayout::StructLayout(const StructType *ST, const DataLayout &DL) { assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); StructAlignment = 0; StructSize = 0; @@ -451,7 +451,7 @@ void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign, /// preferred if ABIInfo = false) the layout wants for the specified datatype. unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType, uint32_t BitWidth, bool ABIInfo, - Type *Ty) const { + const Type *Ty) const { // Check to see if we have an exact match and remember the best match we see. int BestMatchIdx = -1; int LargestInt = -1; @@ -516,7 +516,7 @@ unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType, namespace { class StructLayoutMap { - typedef DenseMap LayoutInfoTy; + typedef DenseMap LayoutInfoTy; LayoutInfoTy LayoutInfo; public: @@ -529,7 +529,7 @@ public: } } - StructLayout *&operator[](StructType *STy) { + StructLayout *&operator[](const StructType *STy) { return LayoutInfo[STy]; } }; @@ -548,7 +548,7 @@ DataLayout::~DataLayout() { clear(); } -const StructLayout *DataLayout::getStructLayout(StructType *Ty) const { +const StructLayout *DataLayout::getStructLayout(const StructType *Ty) const { if (!LayoutMap) LayoutMap = new StructLayoutMap(); @@ -599,7 +599,7 @@ unsigned DataLayout::getPointerSize(unsigned AS) const { return I->TypeByteWidth; } -unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const { +unsigned DataLayout::getPointerTypeSizeInBits(const Type *Ty) const { assert(Ty->isPtrOrPtrVectorTy() && "This should only be called with a pointer or pointer vector type"); @@ -617,7 +617,7 @@ unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const { Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref == false) for the requested type \a Ty. */ -unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { +unsigned DataLayout::getAlignment(const Type *Ty, bool abi_or_pref) const { int AlignType = -1; assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); @@ -671,7 +671,7 @@ unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { abi_or_pref, Ty); } -unsigned DataLayout::getABITypeAlignment(Type *Ty) const { +unsigned DataLayout::getABITypeAlignment(const Type *Ty) const { return getAlignment(Ty, true); } @@ -681,11 +681,11 @@ unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const { return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, nullptr); } -unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const { +unsigned DataLayout::getPrefTypeAlignment(const Type *Ty) const { return getAlignment(Ty, false); } -unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const { +unsigned DataLayout::getPreferredTypeAlignmentShift(const Type *Ty) const { unsigned Align = getPrefTypeAlignment(Ty); assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); return Log2_32(Align); @@ -696,12 +696,12 @@ IntegerType *DataLayout::getIntPtrType(LLVMContext &C, return IntegerType::get(C, getPointerSizeInBits(AddressSpace)); } -Type *DataLayout::getIntPtrType(Type *Ty) const { +Type *DataLayout::getIntPtrType(const Type *Ty) const { assert(Ty->isPtrOrPtrVectorTy() && "Expected a pointer or pointer vector type."); unsigned NumBits = getPointerTypeSizeInBits(Ty); IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits); - if (VectorType *VecTy = dyn_cast(Ty)) + if (const VectorType *VecTy = dyn_cast(Ty)) return VectorType::get(IntTy, VecTy->getNumElements()); return IntTy; } @@ -720,7 +720,7 @@ unsigned DataLayout::getLargestLegalIntTypeSize() const { uint64_t DataLayout::getIndexedOffset(Type *ptrTy, ArrayRef Indices) const { - Type *Ty = ptrTy; + const Type *Ty = ptrTy; assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); uint64_t Result = 0; -- 2.34.1