Changes in directory llvm/include/llvm:
Constants.h updated: 1.119 -> 1.120 DerivedTypes.h updated: 1.80 -> 1.81 Type.h updated: 1.101 -> 1.102 --- Log message: For PR1043: http://llvm.org/PR1043 : This is the final patch for this PR. It implements some minor cleanup in the use of IntegerType, to wit: 1. Type::getIntegerTypeMask -> IntegerType::getBitMask 2. Type::Int*Ty changed to IntegerType* from Type* 3. ConstantInt::getType() returns IntegerType* now, not Type* This also fixes PR1120: http://llvm.org/PR1120 . Patch by Sheng Zhou. --- Diffs of the changes: (+20 -20) Constants.h | 13 ++++++++++--- DerivedTypes.h | 7 +++++++ Type.h | 20 +++----------------- 3 files changed, 20 insertions(+), 20 deletions(-) Index: llvm/include/llvm/Constants.h diff -u llvm/include/llvm/Constants.h:1.119 llvm/include/llvm/Constants.h:1.120 --- llvm/include/llvm/Constants.h:1.119 Fri Jan 12 17:39:50 2007 +++ llvm/include/llvm/Constants.h Fri Jan 19 15:13:56 2007 @@ -60,7 +60,7 @@ /// sign extended as appropriate for the type of this constant. /// @brief Return the sign extended value. inline int64_t getSExtValue() const { - unsigned Size = getType()->getPrimitiveSizeInBits(); + unsigned Size = Value::getType()->getPrimitiveSizeInBits(); return (int64_t(Val) << (64-Size)) >> (64-Size); } /// A helper method that can be used to determine if the constant contained @@ -92,6 +92,13 @@ /// @brief Get a ConstantInt for a specific value. static ConstantInt *get(const Type *Ty, int64_t V); + /// getType - Specialize the getType() method to always return an IntegerType, + /// which reduces the amount of casting needed in parts of the compiler. + /// + inline const IntegerType *getType() const { + return reinterpret_cast<const IntegerType*>(Value::getType()); + } + /// This static method returns true if the type Ty is big enough to /// represent the value V. This can be used to avoid having the get method /// assert when V is larger than Ty can represent. Note that there are two @@ -130,7 +137,7 @@ int64_t V = getSExtValue(); if (V < 0) return false; // Be careful about wrap-around on 'long's ++V; - return !isValueValidForType(getType(), V) || V < 0; + return !isValueValidForType(Value::getType(), V) || V < 0; } return isAllOnesValue(); } @@ -145,7 +152,7 @@ int64_t V = getSExtValue(); if (V > 0) return false; // Be careful about wrap-around on 'long's --V; - return !isValueValidForType(getType(), V) || V > 0; + return !isValueValidForType(Value::getType(), V) || V > 0; } return getZExtValue() == 0; } Index: llvm/include/llvm/DerivedTypes.h diff -u llvm/include/llvm/DerivedTypes.h:1.80 llvm/include/llvm/DerivedTypes.h:1.81 --- llvm/include/llvm/DerivedTypes.h:1.80 Wed Jan 17 20:59:54 2007 +++ llvm/include/llvm/DerivedTypes.h Fri Jan 19 15:13:56 2007 @@ -101,6 +101,13 @@ /// @brief Get the number of bits in this IntegerType unsigned getBitWidth() const { return getSubclassData(); } + /// getBitMask - Return a bitmask with ones set for all of the bits + /// that can be set by an unsigned version of this type. This is 0xFF for + /// sbyte/ubyte, 0xFFFF for shorts, etc. + uint64_t getBitMask() const { + return ~uint64_t(0UL) >> (64-getPrimitiveSizeInBits()); + } + /// This method determines if the width of this IntegerType is a power-of-2 /// in terms of 8 bit bytes. /// @returns true if this is a power-of-2 byte width. Index: llvm/include/llvm/Type.h diff -u llvm/include/llvm/Type.h:1.101 llvm/include/llvm/Type.h:1.102 --- llvm/include/llvm/Type.h:1.101 Tue Jan 16 19:49:59 2007 +++ llvm/include/llvm/Type.h Fri Jan 19 15:13:56 2007 @@ -24,6 +24,7 @@ class DerivedType; class PointerType; +class IntegerType; class TypeMapBase; /// This file contains the declaration of the Type class. For more "Type" type @@ -217,14 +218,6 @@ /// unsigned getPrimitiveSizeInBits() const; - /// getIntegerTypeMask - Return a bitmask with ones set for all of the bits - /// that can be set by an unsigned version of this type. This is 0xFF for - /// sbyte/ubyte, 0xFFFF for shorts, etc. - uint64_t getIntegerTypeMask() const { - assert(isInteger() && "This only works for integer types!"); - return ~uint64_t(0UL) >> (64-getPrimitiveSizeInBits()); - } - /// getForwaredType - Return the type that this type has been resolved to if /// it has been resolved to anything. This is used to implement the /// union-find algorithm for type resolution, and shouldn't be used by general @@ -237,14 +230,7 @@ /// getVAArgsPromotedType - Return the type an argument of this type /// will be promoted to if passed through a variable argument /// function. - const Type *getVAArgsPromotedType() const { - if (ID == IntegerTyID && getSubclassData() < 32) - return Type::Int32Ty; - else if (ID == FloatTyID) - return Type::DoubleTy; - else - return this; - } + const Type *getVAArgsPromotedType() const; //===--------------------------------------------------------------------===// // Type Iteration support @@ -279,7 +265,7 @@ // These are the builtin types that are always available... // static const Type *VoidTy, *LabelTy, *FloatTy, *DoubleTy; - static const Type *Int1Ty, *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty; + static const IntegerType *Int1Ty, *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty; /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const Type *T) { return true; } _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
