Changes in directory llvm/include/llvm:
Constants.h updated: 1.123 -> 1.124 DerivedTypes.h updated: 1.82 -> 1.83 Instructions.h updated: 1.58 -> 1.59 Intrinsics.td updated: 1.45 -> 1.46 Type.h updated: 1.103 -> 1.104 Value.h updated: 1.95 -> 1.96 --- Log message: For PR1195: http://llvm.org/PR1195 : Rename PackedType -> VectorType, ConstantPacked -> ConstantVector, and PackedTyID -> VectorTyID. No functional changes. --- Diffs of the changes: (+51 -51) Constants.h | 28 ++++++++++++++-------------- DerivedTypes.h | 34 +++++++++++++++++----------------- Instructions.h | 14 +++++++------- Intrinsics.td | 18 +++++++++--------- Type.h | 6 +++--- Value.h | 2 +- 6 files changed, 51 insertions(+), 51 deletions(-) Index: llvm/include/llvm/Constants.h diff -u llvm/include/llvm/Constants.h:1.123 llvm/include/llvm/Constants.h:1.124 --- llvm/include/llvm/Constants.h:1.123 Thu Feb 1 20:16:21 2007 +++ llvm/include/llvm/Constants.h Wed Feb 14 20:26:09 2007 @@ -28,7 +28,7 @@ class ArrayType; class StructType; class PointerType; -class PackedType; +class VectorType; template<class ConstantClass, class TypeClass, class ValType> struct ConstantCreator; @@ -334,31 +334,31 @@ }; //===----------------------------------------------------------------------===// -/// ConstantPacked - Constant Packed Declarations +/// ConstantVector - Constant Vector Declarations /// -class ConstantPacked : public Constant { - friend struct ConstantCreator<ConstantPacked, PackedType, +class ConstantVector : public Constant { + friend struct ConstantCreator<ConstantVector, VectorType, std::vector<Constant*> >; - ConstantPacked(const ConstantPacked &); // DO NOT IMPLEMENT + ConstantVector(const ConstantVector &); // DO NOT IMPLEMENT protected: - ConstantPacked(const PackedType *T, const std::vector<Constant*> &Val); - ~ConstantPacked(); + ConstantVector(const VectorType *T, const std::vector<Constant*> &Val); + ~ConstantVector(); public: /// get() - Static factory methods - Return objects of the specified value - static Constant *get(const PackedType *T, const std::vector<Constant*> &); + static Constant *get(const VectorType *T, const std::vector<Constant*> &); static Constant *get(const std::vector<Constant*> &V); - /// getType - Specialize the getType() method to always return an PackedType, + /// getType - Specialize the getType() method to always return an VectorType, /// which reduces the amount of casting needed in parts of the compiler. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Value::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Value::getType()); } /// @returns the value for an packed integer constant of the given type that /// has all its bits set to true. /// @brief Get the all ones value - static ConstantPacked *getAllOnesValue(const PackedType *Ty); + static ConstantVector *getAllOnesValue(const VectorType *Ty); /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. This always returns false because zero arrays are always @@ -375,9 +375,9 @@ virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ConstantPacked *) { return true; } + static inline bool classof(const ConstantVector *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == ConstantPackedVal; + return V->getValueType() == ConstantVectorVal; } }; Index: llvm/include/llvm/DerivedTypes.h diff -u llvm/include/llvm/DerivedTypes.h:1.82 llvm/include/llvm/DerivedTypes.h:1.83 --- llvm/include/llvm/DerivedTypes.h:1.82 Sun Jan 28 07:31:35 2007 +++ llvm/include/llvm/DerivedTypes.h Wed Feb 14 20:26:09 2007 @@ -28,7 +28,7 @@ class ArrayValType; class StructValType; class PointerValType; -class PackedValType; +class VectorValType; class IntegerValType; class DerivedType : public Type { @@ -214,7 +214,7 @@ /// CompositeType - Common super class of ArrayType, StructType, PointerType -/// and PackedType +/// and VectorType class CompositeType : public DerivedType { protected: inline CompositeType(TypeID id) : DerivedType(id) { } @@ -232,7 +232,7 @@ return T->getTypeID() == ArrayTyID || T->getTypeID() == StructTyID || T->getTypeID() == PointerTyID || - T->getTypeID() == PackedTyID; + T->getTypeID() == VectorTyID; } }; @@ -317,7 +317,7 @@ static inline bool classof(const Type *T) { return T->getTypeID() == ArrayTyID || T->getTypeID() == PointerTyID || - T->getTypeID() == PackedTyID; + T->getTypeID() == VectorTyID; } }; @@ -350,25 +350,25 @@ } }; -/// PackedType - Class to represent packed types +/// VectorType - Class to represent packed types /// -class PackedType : public SequentialType { - friend class TypeMap<PackedValType, PackedType>; +class VectorType : public SequentialType { + friend class TypeMap<VectorValType, VectorType>; unsigned NumElements; - PackedType(const PackedType &); // Do not implement - const PackedType &operator=(const PackedType &); // Do not implement - PackedType(const Type *ElType, unsigned NumEl); + VectorType(const VectorType &); // Do not implement + const VectorType &operator=(const VectorType &); // Do not implement + VectorType(const Type *ElType, unsigned NumEl); public: - /// PackedType::get - This static method is the primary way to construct an - /// PackedType + /// VectorType::get - This static method is the primary way to construct an + /// VectorType /// - static PackedType *get(const Type *ElementType, unsigned NumElements); + static VectorType *get(const Type *ElementType, unsigned NumElements); - /// @brief Return the number of elements in the Packed type. + /// @brief Return the number of elements in the Vector type. inline unsigned getNumElements() const { return NumElements; } - /// @brief Return the number of bits in the Packed type. + /// @brief Return the number of bits in the Vector type. inline unsigned getBitWidth() const { return NumElements *getElementType()->getPrimitiveSizeInBits(); } @@ -378,9 +378,9 @@ virtual void typeBecameConcrete(const DerivedType *AbsTy); // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const PackedType *T) { return true; } + static inline bool classof(const VectorType *T) { return true; } static inline bool classof(const Type *T) { - return T->getTypeID() == PackedTyID; + return T->getTypeID() == VectorTyID; } }; Index: llvm/include/llvm/Instructions.h diff -u llvm/include/llvm/Instructions.h:1.58 llvm/include/llvm/Instructions.h:1.59 --- llvm/include/llvm/Instructions.h:1.58 Tue Feb 13 01:54:42 2007 +++ llvm/include/llvm/Instructions.h Wed Feb 14 20:26:09 2007 @@ -23,7 +23,7 @@ class BasicBlock; class ConstantInt; class PointerType; -class PackedType; +class VectorType; //===----------------------------------------------------------------------===// // AllocationInst Class @@ -862,7 +862,7 @@ //===----------------------------------------------------------------------===// /// ExtractElementInst - This instruction extracts a single (scalar) -/// element from a PackedType value +/// element from a VectorType value /// class ExtractElementInst : public Instruction { Use Ops[2]; @@ -916,7 +916,7 @@ //===----------------------------------------------------------------------===// /// InsertElementInst - This instruction inserts a single (scalar) -/// element into a PackedType value +/// element into a VectorType value /// class InsertElementInst : public Instruction { Use Ops[3]; @@ -942,8 +942,8 @@ /// getType - Overload to return most specific packed type. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Instruction::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Instruction::getType()); } /// Transparently provide more efficient getOperand methods. @@ -994,8 +994,8 @@ /// getType - Overload to return most specific packed type. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Instruction::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Instruction::getType()); } /// Transparently provide more efficient getOperand methods. Index: llvm/include/llvm/Intrinsics.td diff -u llvm/include/llvm/Intrinsics.td:1.45 llvm/include/llvm/Intrinsics.td:1.46 --- llvm/include/llvm/Intrinsics.td:1.45 Mon Feb 12 13:05:51 2007 +++ llvm/include/llvm/Intrinsics.td Wed Feb 14 20:26:09 2007 @@ -62,8 +62,8 @@ int Width = width; } -class LLVMPackedType<ValueType VT, int numelts, LLVMType elty> - : LLVMType<VT, "Type::PackedTyID">{ +class LLVMVectorType<ValueType VT, int numelts, LLVMType elty> + : LLVMType<VT, "Type::VectorTyID">{ int NumElts = numelts; LLVMType ElTy = elty; } @@ -90,13 +90,13 @@ def llvm_empty_ty : LLVMEmptyStructType; // { } def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>; // { }* -def llvm_v16i8_ty : LLVMPackedType<v16i8,16, llvm_i8_ty>; // 16 x i8 -def llvm_v8i16_ty : LLVMPackedType<v8i16, 8, llvm_i16_ty>; // 8 x i16 -def llvm_v2i64_ty : LLVMPackedType<v2i64, 2, llvm_i64_ty>; // 2 x i64 -def llvm_v2i32_ty : LLVMPackedType<v2i32, 2, llvm_i32_ty>; // 2 x i32 -def llvm_v4i32_ty : LLVMPackedType<v4i32, 4, llvm_i32_ty>; // 4 x i32 -def llvm_v4f32_ty : LLVMPackedType<v4f32, 4, llvm_float_ty>; // 4 x float -def llvm_v2f64_ty : LLVMPackedType<v2f64, 2, llvm_double_ty>;// 2 x double +def llvm_v16i8_ty : LLVMVectorType<v16i8,16, llvm_i8_ty>; // 16 x i8 +def llvm_v8i16_ty : LLVMVectorType<v8i16, 8, llvm_i16_ty>; // 8 x i16 +def llvm_v2i64_ty : LLVMVectorType<v2i64, 2, llvm_i64_ty>; // 2 x i64 +def llvm_v2i32_ty : LLVMVectorType<v2i32, 2, llvm_i32_ty>; // 2 x i32 +def llvm_v4i32_ty : LLVMVectorType<v4i32, 4, llvm_i32_ty>; // 4 x i32 +def llvm_v4f32_ty : LLVMVectorType<v4f32, 4, llvm_float_ty>; // 4 x float +def llvm_v2f64_ty : LLVMVectorType<v2f64, 2, llvm_double_ty>;// 2 x double def llvm_vararg_ty : LLVMType<isVoid, "...">; // vararg Index: llvm/include/llvm/Type.h diff -u llvm/include/llvm/Type.h:1.103 llvm/include/llvm/Type.h:1.104 --- llvm/include/llvm/Type.h:1.103 Sun Jan 28 18:09:00 2007 +++ llvm/include/llvm/Type.h Wed Feb 14 20:26:09 2007 @@ -81,7 +81,7 @@ ArrayTyID, ///< 8: Arrays PointerTyID, ///< 9: Pointers OpaqueTyID, ///< 10: Opaque: type with unknown structure - PackedTyID, ///< 11: SIMD 'packed' format, or other vector type + VectorTyID, ///< 11: SIMD 'packed' format, or other vector type NumTypeIDs, // Must remain as last defined ID LastPrimitiveTyID = LabelTyID, @@ -191,7 +191,7 @@ /// inline bool isFirstClassType() const { return (ID != VoidTyID && ID <= LastPrimitiveTyID) || - ID == IntegerTyID || ID == PointerTyID || ID == PackedTyID; + ID == IntegerTyID || ID == PointerTyID || ID == VectorTyID; } /// isSized - Return true if it makes sense to take the size of this type. To @@ -204,7 +204,7 @@ return true; // If it is not something that can have a size (e.g. a function or label), // it doesn't have a size. - if (ID != StructTyID && ID != ArrayTyID && ID != PackedTyID && + if (ID != StructTyID && ID != ArrayTyID && ID != VectorTyID && ID != PackedStructTyID) return false; // If it is something that can have a size and it's concrete, it definitely Index: llvm/include/llvm/Value.h diff -u llvm/include/llvm/Value.h:1.95 llvm/include/llvm/Value.h:1.96 --- llvm/include/llvm/Value.h:1.95 Tue Feb 13 01:53:34 2007 +++ llvm/include/llvm/Value.h Wed Feb 14 20:26:09 2007 @@ -167,7 +167,7 @@ ConstantFPVal, // This is an instance of ConstantFP ConstantArrayVal, // This is an instance of ConstantArray ConstantStructVal, // This is an instance of ConstantStruct - ConstantPackedVal, // This is an instance of ConstantPacked + ConstantVectorVal, // This is an instance of ConstantPacked ConstantPointerNullVal, // This is an instance of ConstantPointerNull InlineAsmVal, // This is an instance of InlineAsm InstructionVal, // This is an instance of Instruction _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits