Skip to content

Commit

Permalink
Revert "Add const to a bunch of Type* in DataLayout. NFC."
Browse files Browse the repository at this point in the history 
This reverts commit r243135.

Feedback from Craig Topper and David Blaikie was that we don't put const on Type as it has no mutable state.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@243283 91177308-0d34-0410-b5e6-96231b3b80d8
  • Loading branch information
@cooperp
cooperp committed Jul 27, 2015
1 parent 5253b18 commit 80ec0f8
Show file tree
Hide file tree
Showing 2 changed files with 31 additions and 31 deletions.
36 changes: 18 additions & 18 deletions include/llvm/IR/DataLayout.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -150,12 +150,12 @@ class DataLayout {
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, const Type *Ty) const;
bool ABIAlign, 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(const Type *Ty, bool abi_or_pref) const;
unsigned getAlignment(Type *Ty, bool abi_or_pref) const;

/// \brief Valid alignment predicate.
///
Expand Down Expand Up @@ -335,9 +335,9 @@ class DataLayout {
/// 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(const Type *) const;
unsigned getPointerTypeSizeInBits(Type *) const;

unsigned getPointerTypeSize(const Type *Ty) const {
unsigned getPointerTypeSize(Type *Ty) const {
return getPointerTypeSizeInBits(Ty) / 8;
}

Expand All @@ -362,21 +362,21 @@ class DataLayout {
///
/// 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(const Type *Ty) const;
uint64_t getTypeSizeInBits(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(const Type *Ty) const {
uint64_t getTypeStoreSize(Type *Ty) const {
return (getTypeSizeInBits(Ty) + 7) / 8;
}

/// \brief Returns the maximum number of bits that may be overwritten by
/// storing the specified type; always a multiple of 8.
///
/// For example, returns 40 for i36 and 80 for x86_fp80.
uint64_t getTypeStoreSizeInBits(const Type *Ty) const {
uint64_t getTypeStoreSizeInBits(Type *Ty) const {
return 8 * getTypeStoreSize(Ty);
}

Expand All @@ -385,7 +385,7 @@ class DataLayout {
///
/// 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(const Type *Ty) const {
uint64_t getTypeAllocSize(Type *Ty) const {
// Round up to the next alignment boundary.
return RoundUpToAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
}
Expand All @@ -395,12 +395,12 @@ class DataLayout {
///
/// 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(const Type *Ty) const {
uint64_t getTypeAllocSizeInBits(Type *Ty) const {
return 8 * getTypeAllocSize(Ty);
}

/// \brief Returns the minimum ABI-required alignment for the specified type.
unsigned getABITypeAlignment(const Type *Ty) const;
unsigned getABITypeAlignment(Type *Ty) const;

/// \brief Returns the minimum ABI-required alignment for an integer type of
/// the specified bitwidth.
Expand All @@ -410,19 +410,19 @@ class DataLayout {
/// type.
///
/// This is always at least as good as the ABI alignment.
unsigned getPrefTypeAlignment(const Type *Ty) const;
unsigned getPrefTypeAlignment(Type *Ty) const;

/// \brief Returns the preferred alignment for the specified type, returned as
/// log2 of the value (a shift amount).
unsigned getPreferredTypeAlignmentShift(const Type *Ty) const;
unsigned getPreferredTypeAlignmentShift(Type *Ty) const;

/// \brief Returns an integer type with size at least as big as that of a
/// pointer in the given address space.
IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace = 0) const;

/// \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(const Type *) const;
Type *getIntPtrType(Type *) const;

/// \brief Returns the smallest integer type with size at least as big as
/// Width bits.
Expand All @@ -448,7 +448,7 @@ class DataLayout {
/// struct, its size, and the offsets of its fields.
///
/// Note that this information is lazily cached.
const StructLayout *getStructLayout(const StructType *Ty) const;
const StructLayout *getStructLayout(StructType *Ty) const;

/// \brief Returns the preferred alignment of the specified global.
///
Expand Down Expand Up @@ -499,20 +499,20 @@ class StructLayout {

private:
friend class DataLayout; // Only DataLayout can create this class
StructLayout(const StructType *ST, const DataLayout &DL);
StructLayout(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(const Type *Ty) const {
inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
switch (Ty->getTypeID()) {
case Type::LabelTyID:
return getPointerSizeInBits(0);
case Type::PointerTyID:
return getPointerSizeInBits(Ty->getPointerAddressSpace());
case Type::ArrayTyID: {
const ArrayType *ATy = cast<ArrayType>(Ty);
ArrayType *ATy = cast<ArrayType>(Ty);
return ATy->getNumElements() *
getTypeAllocSizeInBits(ATy->getElementType());
}
Expand All @@ -536,7 +536,7 @@ inline uint64_t DataLayout::getTypeSizeInBits(const Type *Ty) const {
case Type::X86_FP80TyID:
return 80;
case Type::VectorTyID: {
const VectorType *VTy = cast<VectorType>(Ty);
VectorType *VTy = cast<VectorType>(Ty);
return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType());
}
default:
Expand Down
26 changes: 13 additions & 13 deletions lib/IR/DataLayout.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ using namespace llvm;
// Support for StructLayout
//===----------------------------------------------------------------------===//

StructLayout::StructLayout(const StructType *ST, const DataLayout &DL) {
StructLayout::StructLayout(StructType *ST, const DataLayout &DL) {
assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
StructAlignment = 0;
StructSize = 0;
Expand Down Expand Up @@ -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,
const Type *Ty) 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;
Expand Down Expand Up @@ -516,7 +516,7 @@ unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
namespace {

class StructLayoutMap {
typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
LayoutInfoTy LayoutInfo;

public:
Expand All @@ -529,7 +529,7 @@ class StructLayoutMap {
}
}

StructLayout *&operator[](const StructType *STy) {
StructLayout *&operator[](StructType *STy) {
return LayoutInfo[STy];
}
};
Expand All @@ -548,7 +548,7 @@ DataLayout::~DataLayout() {
clear();
}

const StructLayout *DataLayout::getStructLayout(const StructType *Ty) const {
const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
if (!LayoutMap)
LayoutMap = new StructLayoutMap();

Expand Down Expand Up @@ -599,7 +599,7 @@ unsigned DataLayout::getPointerSize(unsigned AS) const {
return I->TypeByteWidth;
}

unsigned DataLayout::getPointerTypeSizeInBits(const Type *Ty) const {
unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
assert(Ty->isPtrOrPtrVectorTy() &&
"This should only be called with a pointer or pointer vector type");

Expand All @@ -617,7 +617,7 @@ unsigned DataLayout::getPointerTypeSizeInBits(const 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(const Type *Ty, bool abi_or_pref) const {
unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
int AlignType = -1;

assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
Expand Down Expand Up @@ -671,7 +671,7 @@ unsigned DataLayout::getAlignment(const Type *Ty, bool abi_or_pref) const {
abi_or_pref, Ty);
}

unsigned DataLayout::getABITypeAlignment(const Type *Ty) const {
unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
return getAlignment(Ty, true);
}

Expand All @@ -681,11 +681,11 @@ unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, nullptr);
}

unsigned DataLayout::getPrefTypeAlignment(const Type *Ty) const {
unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
return getAlignment(Ty, false);
}

unsigned DataLayout::getPreferredTypeAlignmentShift(const Type *Ty) const {
unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
unsigned Align = getPrefTypeAlignment(Ty);
assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
return Log2_32(Align);
Expand All @@ -696,12 +696,12 @@ IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
}

Type *DataLayout::getIntPtrType(const Type *Ty) const {
Type *DataLayout::getIntPtrType(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 (const VectorType *VecTy = dyn_cast<VectorType>(Ty))
if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
return VectorType::get(IntTy, VecTy->getNumElements());
return IntTy;
}
Expand All @@ -720,7 +720,7 @@ unsigned DataLayout::getLargestLegalIntTypeSize() const {

uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
ArrayRef<Value *> Indices) const {
const Type *Ty = ptrTy;
Type *Ty = ptrTy;
assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
uint64_t Result = 0;

Expand Down

0 comments on commit 80ec0f8

Please sign in to comment.