aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/llvm/Bytecode/BytecodeHandler.h6
-rw-r--r--include/llvm/Constants.h28
-rw-r--r--include/llvm/DerivedTypes.h34
-rw-r--r--include/llvm/Instructions.h14
-rw-r--r--include/llvm/Intrinsics.td18
-rw-r--r--include/llvm/Target/TargetLowering.h8
-rw-r--r--include/llvm/Transforms/Scalar.h2
-rw-r--r--include/llvm/Type.h6
-rw-r--r--include/llvm/Value.h2
9 files changed, 59 insertions, 59 deletions
diff --git a/include/llvm/Bytecode/BytecodeHandler.h b/include/llvm/Bytecode/BytecodeHandler.h
index 4084efa14c..eeae2a58d6 100644
--- a/include/llvm/Bytecode/BytecodeHandler.h
+++ b/include/llvm/Bytecode/BytecodeHandler.h
@@ -23,7 +23,7 @@ namespace llvm {
class ArrayType;
class StructType;
class PointerType;
-class PackedType;
+class VectorType;
class ConstantArray;
class Module;
@@ -242,8 +242,8 @@ public:
) {}
/// @brief Handle a constant packed
- virtual void handleConstantPacked(
- const PackedType* PT, ///< Type of the array
+ virtual void handleConstantVector(
+ const VectorType* PT, ///< Type of the array
Constant**ElementSlots, unsigned NumElts,///< Slot nums for packed values
unsigned TypeSlot, ///< Slot # of type
Constant* Val ///< The constant value
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 3d4ff90fcc..e01e2a2823 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -28,7 +28,7 @@ namespace llvm {
class ArrayType;
class StructType;
class PointerType;
-class PackedType;
+class VectorType;
template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator;
@@ -334,31 +334,31 @@ public:
};
//===----------------------------------------------------------------------===//
-/// 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 @@ public:
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;
}
};
diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index 06f3a98807..2426e7b289 100644
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -28,7 +28,7 @@ class FunctionValType;
class ArrayValType;
class StructValType;
class PointerValType;
-class PackedValType;
+class VectorValType;
class IntegerValType;
class DerivedType : public Type {
@@ -214,7 +214,7 @@ public:
/// 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 @@ public:
return T->getTypeID() == ArrayTyID ||
T->getTypeID() == StructTyID ||
T->getTypeID() == PointerTyID ||
- T->getTypeID() == PackedTyID;
+ T->getTypeID() == VectorTyID;
}
};
@@ -317,7 +317,7 @@ public:
static inline bool classof(const Type *T) {
return T->getTypeID() == ArrayTyID ||
T->getTypeID() == PointerTyID ||
- T->getTypeID() == PackedTyID;
+ T->getTypeID() == VectorTyID;
}
};
@@ -350,25 +350,25 @@ public:
}
};
-/// 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 @@ public:
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;
}
};
diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 3d22ef202a..a5f0b0bd01 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -23,7 +23,7 @@ namespace llvm {
class BasicBlock;
class ConstantInt;
class PointerType;
-class PackedType;
+class VectorType;
//===----------------------------------------------------------------------===//
// AllocationInst Class
@@ -862,7 +862,7 @@ public:
//===----------------------------------------------------------------------===//
/// 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 @@ public:
//===----------------------------------------------------------------------===//
/// 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 @@ public:
/// 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 @@ public:
/// 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.
diff --git a/include/llvm/Intrinsics.td b/include/llvm/Intrinsics.td
index f3cd4f6d01..05a5a68edc 100644
--- a/include/llvm/Intrinsics.td
+++ b/include/llvm/Intrinsics.td
@@ -62,8 +62,8 @@ class LLVMIntegerType<ValueType VT, int width>
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_ptrptr_ty : LLVMPointerType<llvm_ptr_ty>; // i8**
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
diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h
index 7bdf01f9e4..7a1652900c 100644
--- a/include/llvm/Target/TargetLowering.h
+++ b/include/llvm/Target/TargetLowering.h
@@ -38,7 +38,7 @@ namespace llvm {
class SelectionDAG;
class MachineBasicBlock;
class MachineInstr;
- class PackedType;
+ class VectorType;
//===----------------------------------------------------------------------===//
/// TargetLowering - This class defines information used to lower LLVM code to
@@ -198,16 +198,16 @@ public:
return VT;
}
- /// getPackedTypeBreakdown - Packed types are broken down into some number of
+ /// getVectorTypeBreakdown - Packed types are broken down into some number of
/// legal first class types. For example, <8 x float> maps to 2 MVT::v4f32
/// with Altivec or SSE1, or 8 promoted MVT::f64 values with the X86 FP stack.
/// Similarly, <2 x long> turns into 4 MVT::i32 values with both PPC and X86.
///
/// This method returns the number of registers needed, and the VT for each
- /// register. It also returns the VT of the PackedType elements before they
+ /// register. It also returns the VT of the VectorType elements before they
/// are promoted/expanded.
///
- unsigned getPackedTypeBreakdown(const PackedType *PTy,
+ unsigned getVectorTypeBreakdown(const VectorType *PTy,
MVT::ValueType &PTyElementVT,
MVT::ValueType &PTyLegalElementVT) const;
diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h
index ff6fbf0b05..8c6e6ccb31 100644
--- a/include/llvm/Transforms/Scalar.h
+++ b/include/llvm/Transforms/Scalar.h
@@ -261,7 +261,7 @@ extern const PassInfo *LowerSwitchID;
//===----------------------------------------------------------------------===//
//
-// LowerPacked - This pass converts PackedType operations into low-level scalar
+// LowerPacked - This pass converts VectorType operations into low-level scalar
// operations.
//
FunctionPass *createLowerPackedPass();
diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index 7a2e432a3a..880daadfb1 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -81,7 +81,7 @@ public:
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 @@ public:
///
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 @@ public:
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
diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index fac596b415..1e2a8f6fb6 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -167,7 +167,7 @@ public:
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
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-19 03:33:22 +0000