mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
For PR1195:
Change use of "packed" term to "vector" in comments, strings, variable names, etc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34300 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
a85210ac66
commit
ac9dcb94dd
@ -234,7 +234,7 @@ namespace ISD {
|
||||
VEXTRACT_VECTOR_ELT,
|
||||
|
||||
/// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
|
||||
/// (a legal packed type vector) identified by the (potentially variable)
|
||||
/// (a legal vector type vector) identified by the (potentially variable)
|
||||
/// element number IDX.
|
||||
EXTRACT_VECTOR_ELT,
|
||||
|
||||
|
@ -286,7 +286,7 @@ public:
|
||||
/// SequentialType - This is the superclass of the array, pointer and packed
|
||||
/// type classes. All of these represent "arrays" in memory. The array type
|
||||
/// represents a specifically sized array, pointer types are unsized/unknown
|
||||
/// size arrays, packed types represent specifically sized arrays that
|
||||
/// size arrays, vector types represent specifically sized arrays that
|
||||
/// allow for use of SIMD instructions. SequentialType holds the common
|
||||
/// features of all, which stem from the fact that all three lay their
|
||||
/// components out in memory identically.
|
||||
@ -350,7 +350,7 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
/// VectorType - Class to represent packed types
|
||||
/// VectorType - Class to represent vector types
|
||||
///
|
||||
class VectorType : public SequentialType {
|
||||
friend class TypeMap<VectorValType, VectorType>;
|
||||
|
@ -940,7 +940,7 @@ public:
|
||||
|
||||
virtual bool mayWriteToMemory() const { return false; }
|
||||
|
||||
/// getType - Overload to return most specific packed type.
|
||||
/// getType - Overload to return most specific vector type.
|
||||
///
|
||||
inline const VectorType *getType() const {
|
||||
return reinterpret_cast<const VectorType*>(Instruction::getType());
|
||||
@ -992,7 +992,7 @@ public:
|
||||
|
||||
virtual bool mayWriteToMemory() const { return false; }
|
||||
|
||||
/// getType - Overload to return most specific packed type.
|
||||
/// getType - Overload to return most specific vector type.
|
||||
///
|
||||
inline const VectorType *getType() const {
|
||||
return reinterpret_cast<const VectorType*>(Instruction::getType());
|
||||
|
@ -198,7 +198,7 @@ public:
|
||||
return VT;
|
||||
}
|
||||
|
||||
/// getVectorTypeBreakdown - Packed types are broken down into some number of
|
||||
/// getVectorTypeBreakdown - Vector 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.
|
||||
|
@ -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
|
||||
ConstantVectorVal, // This is an instance of ConstantPacked
|
||||
ConstantVectorVal, // This is an instance of ConstantVector
|
||||
ConstantPointerNullVal, // This is an instance of ConstantPointerNull
|
||||
InlineAsmVal, // This is an instance of InlineAsm
|
||||
InstructionVal, // This is an instance of Instruction
|
||||
|
@ -1292,7 +1292,7 @@ Types
|
||||
delete $4;
|
||||
CHECK_FOR_ERROR
|
||||
}
|
||||
| '<' EUINT64VAL 'x' Types '>' { // Packed array type?
|
||||
| '<' EUINT64VAL 'x' Types '>' { // Vector type?
|
||||
const llvm::Type* ElemTy = $4->get();
|
||||
if ((unsigned)$2 != $2)
|
||||
GEN_ERROR("Unsigned result not equal to signed result");
|
||||
@ -1525,7 +1525,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
||||
|
||||
// Check to ensure that Type is not packed
|
||||
if (STy->isPacked())
|
||||
GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
|
||||
GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
|
||||
|
||||
$$ = ConstantStruct::get(STy, *$3);
|
||||
delete $1; delete $3;
|
||||
@ -1544,7 +1544,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
||||
|
||||
// Check to ensure that Type is not packed
|
||||
if (STy->isPacked())
|
||||
GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
|
||||
GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
|
||||
|
||||
$$ = ConstantStruct::get(STy, std::vector<Constant*>());
|
||||
delete $1;
|
||||
@ -1569,7 +1569,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
||||
|
||||
// Check to ensure that Type is packed
|
||||
if (!STy->isPacked())
|
||||
GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
|
||||
GEN_ERROR("Vector initializer to non-vector type '" +
|
||||
STy->getDescription() + "'");
|
||||
|
||||
$$ = ConstantStruct::get(STy, *$4);
|
||||
delete $1; delete $4;
|
||||
@ -1588,7 +1589,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
||||
|
||||
// Check to ensure that Type is packed
|
||||
if (!STy->isPacked())
|
||||
GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
|
||||
GEN_ERROR("Vector initializer to non-vector type '" +
|
||||
STy->getDescription() + "'");
|
||||
|
||||
$$ = ConstantStruct::get(STy, std::vector<Constant*>());
|
||||
delete $1;
|
||||
@ -2592,7 +2594,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
|
||||
($1 == Instruction::URem ||
|
||||
$1 == Instruction::SRem ||
|
||||
$1 == Instruction::FRem))
|
||||
GEN_ERROR("Remainder not supported on packed types");
|
||||
GEN_ERROR("Remainder not supported on vector types");
|
||||
Value* val1 = getVal(*$2, $3);
|
||||
CHECK_FOR_ERROR
|
||||
Value* val2 = getVal(*$2, $5);
|
||||
@ -2623,7 +2625,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
|
||||
if (!UpRefs.empty())
|
||||
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
||||
if (isa<VectorType>((*$3).get()))
|
||||
GEN_ERROR("Packed types not supported by icmp instruction");
|
||||
GEN_ERROR("Vector types not supported by icmp instruction");
|
||||
Value* tmpVal1 = getVal(*$3, $4);
|
||||
CHECK_FOR_ERROR
|
||||
Value* tmpVal2 = getVal(*$3, $6);
|
||||
@ -2636,7 +2638,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
|
||||
if (!UpRefs.empty())
|
||||
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
||||
if (isa<VectorType>((*$3).get()))
|
||||
GEN_ERROR("Packed types not supported by fcmp instruction");
|
||||
GEN_ERROR("Vector types not supported by fcmp instruction");
|
||||
Value* tmpVal1 = getVal(*$3, $4);
|
||||
CHECK_FOR_ERROR
|
||||
Value* tmpVal2 = getVal(*$3, $6);
|
||||
|
@ -427,7 +427,7 @@ public:
|
||||
const VectorType* PT,
|
||||
Constant**Elements, unsigned NumElts,
|
||||
unsigned TypeSlot,
|
||||
Constant* PackedVal)
|
||||
Constant* VectorVal)
|
||||
{
|
||||
if (os) {
|
||||
*os << " PACKD: ";
|
||||
@ -439,7 +439,7 @@ public:
|
||||
*os << "\n";
|
||||
}
|
||||
*os << " Value=";
|
||||
PackedVal->print(*os);
|
||||
VectorVal->print(*os);
|
||||
*os << "\n";
|
||||
}
|
||||
|
||||
|
@ -482,12 +482,12 @@ void BytecodeReader::ParseInstruction(SmallVector<unsigned, 8> &Oprnds,
|
||||
break;
|
||||
}
|
||||
case Instruction::InsertElement: {
|
||||
const VectorType *PackedTy = dyn_cast<VectorType>(InstTy);
|
||||
if (!PackedTy || Oprnds.size() != 3)
|
||||
const VectorType *VectorTy = dyn_cast<VectorType>(InstTy);
|
||||
if (!VectorTy || Oprnds.size() != 3)
|
||||
error("Invalid insertelement instruction!");
|
||||
|
||||
Value *V1 = getValue(iType, Oprnds[0]);
|
||||
Value *V2 = getValue(getTypeSlot(PackedTy->getElementType()),Oprnds[1]);
|
||||
Value *V2 = getValue(getTypeSlot(VectorTy->getElementType()),Oprnds[1]);
|
||||
Value *V3 = getValue(Int32TySlot, Oprnds[2]);
|
||||
|
||||
if (!InsertElementInst::isValidOperands(V1, V2, V3))
|
||||
@ -496,13 +496,13 @@ void BytecodeReader::ParseInstruction(SmallVector<unsigned, 8> &Oprnds,
|
||||
break;
|
||||
}
|
||||
case Instruction::ShuffleVector: {
|
||||
const VectorType *PackedTy = dyn_cast<VectorType>(InstTy);
|
||||
if (!PackedTy || Oprnds.size() != 3)
|
||||
const VectorType *VectorTy = dyn_cast<VectorType>(InstTy);
|
||||
if (!VectorTy || Oprnds.size() != 3)
|
||||
error("Invalid shufflevector instruction!");
|
||||
Value *V1 = getValue(iType, Oprnds[0]);
|
||||
Value *V2 = getValue(iType, Oprnds[1]);
|
||||
const VectorType *EltTy =
|
||||
VectorType::get(Type::Int32Ty, PackedTy->getNumElements());
|
||||
VectorType::get(Type::Int32Ty, VectorTy->getNumElements());
|
||||
Value *V3 = getValue(getTypeSlot(EltTy), Oprnds[2]);
|
||||
if (!ShuffleVectorInst::isValidOperands(V1, V2, V3))
|
||||
error("Invalid shufflevector instruction!");
|
||||
|
@ -112,7 +112,7 @@ class VISIBILITY_HIDDEN SelectionDAGLegalize {
|
||||
std::map<SDOperand, std::pair<SDOperand, SDOperand> > SplitNodes;
|
||||
|
||||
/// PackedNodes - For nodes that need to be packed from MVT::Vector types to
|
||||
/// concrete packed types, this contains the mapping of ones we have already
|
||||
/// concrete vector types, this contains the mapping of ones we have already
|
||||
/// processed to the result.
|
||||
std::map<SDOperand, SDOperand> PackedNodes;
|
||||
|
||||
@ -1641,10 +1641,10 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
MVT::ValueType EVT = cast<VTSDNode>(*(InVal->op_end()-1))->getVT();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems);
|
||||
if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) {
|
||||
// Turn this into a return of the packed type.
|
||||
// Turn this into a return of the vector type.
|
||||
Tmp2 = PackVectorOp(Tmp2, TVT);
|
||||
Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3);
|
||||
} else if (NumElems == 1) {
|
||||
@ -1793,10 +1793,10 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
MVT::ValueType EVT = cast<VTSDNode>(*(InVal->op_end()-1))->getVT();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems);
|
||||
if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) {
|
||||
// Turn this into a normal store of the packed type.
|
||||
// Turn this into a normal store of the vector type.
|
||||
Tmp3 = PackVectorOp(Node->getOperand(1), TVT);
|
||||
Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(),
|
||||
ST->getSrcValueOffset());
|
||||
@ -2810,7 +2810,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
MVT::ValueType EVT = cast<VTSDNode>(*(InVal->op_end()-1))->getVT();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems);
|
||||
if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) {
|
||||
// Turn this into a bit convert of the packed input.
|
||||
@ -3508,7 +3508,7 @@ SDOperand SelectionDAGLegalize::LowerVEXTRACT_VECTOR_ELT(SDOperand Op) {
|
||||
MVT::ValueType EVT = cast<VTSDNode>(*(InVal->op_end()-1))->getVT();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems);
|
||||
if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) {
|
||||
// Turn this into a packed extract_vector_elt operation.
|
||||
@ -5553,7 +5553,7 @@ SDOperand SelectionDAGLegalize::PackVectorOp(SDOperand Op,
|
||||
MVT::ValueType EVT = cast<VTSDNode>(*(InVal->op_end()-1))->getVT();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems);
|
||||
if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) {
|
||||
// Turn this into a bit convert of the packed input.
|
||||
|
@ -332,7 +332,7 @@ void ScheduleDAG::AddOperand(MachineInstr *MI, SDOperand Op,
|
||||
if (Align == 0) {
|
||||
Align = TM.getTargetData()->getPreferredTypeAlignmentShift(Type);
|
||||
if (Align == 0) {
|
||||
// Alignment of packed types. FIXME!
|
||||
// Alignment of vector types. FIXME!
|
||||
Align = TM.getTargetData()->getTypeSize(Type);
|
||||
Align = Log2_64(Align);
|
||||
}
|
||||
|
@ -303,7 +303,7 @@ unsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) {
|
||||
// a <2 x int64> -> 4 x i32 registers.
|
||||
unsigned NumVectorRegs = 1;
|
||||
|
||||
// If this is a packed type, figure out what type it will decompose into
|
||||
// If this is a vector type, figure out what type it will decompose into
|
||||
// and how many of the elements it will use.
|
||||
if (VT == MVT::Vector) {
|
||||
const VectorType *PTy = cast<VectorType>(V->getType());
|
||||
@ -1861,7 +1861,7 @@ void SelectionDAGLowering::visitTargetIntrinsic(CallInst &I,
|
||||
for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
|
||||
SDOperand Op = getValue(I.getOperand(i));
|
||||
|
||||
// If this is a vector type, force it to the right packed type.
|
||||
// If this is a vector type, force it to the right vector type.
|
||||
if (Op.getValueType() == MVT::Vector) {
|
||||
const VectorType *OpTy = cast<VectorType>(I.getOperand(i)->getType());
|
||||
MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType());
|
||||
@ -2970,7 +2970,7 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
|
||||
const Type *EltTy = cast<VectorType>(I->getType())->getElementType();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems);
|
||||
if (TVT != MVT::Other && isTypeLegal(TVT)) {
|
||||
RetVals.push_back(TVT);
|
||||
@ -3036,7 +3036,7 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
|
||||
const Type *EltTy = PTy->getElementType();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems);
|
||||
if (TVT != MVT::Other && isTypeLegal(TVT)) {
|
||||
SDOperand N = SDOperand(Result, i++);
|
||||
@ -3159,10 +3159,10 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy,
|
||||
const Type *EltTy = PTy->getElementType();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems);
|
||||
if (TVT != MVT::Other && isTypeLegal(TVT)) {
|
||||
// Insert a VBIT_CONVERT of the MVT::Vector type to the packed type.
|
||||
// Insert a VBIT_CONVERT of the MVT::Vector type to the vector type.
|
||||
Op = DAG.getNode(ISD::VBIT_CONVERT, TVT, Op);
|
||||
Ops.push_back(Op);
|
||||
Ops.push_back(DAG.getConstant(Flags, MVT::i32));
|
||||
@ -3205,7 +3205,7 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy,
|
||||
const Type *EltTy = PTy->getElementType();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems);
|
||||
if (TVT != MVT::Other && isTypeLegal(TVT)) {
|
||||
RetTys.push_back(TVT);
|
||||
@ -3242,7 +3242,7 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy,
|
||||
const Type *EltTy = cast<VectorType>(RetTy)->getElementType();
|
||||
|
||||
// Figure out if there is a Packed type corresponding to this Vector
|
||||
// type. If so, convert to the packed type.
|
||||
// type. If so, convert to the vector type.
|
||||
MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy),NumElems);
|
||||
if (TVT != MVT::Other && isTypeLegal(TVT)) {
|
||||
// Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a
|
||||
|
@ -1727,7 +1727,7 @@ void CWriter::printModuleTypes(const TypeSymbolTable &TST) {
|
||||
// Push the struct onto the stack and recursively push all structs
|
||||
// this one depends on.
|
||||
//
|
||||
// TODO: Make this work properly with packed types
|
||||
// TODO: Make this work properly with vector types
|
||||
//
|
||||
void CWriter::printContainedStructs(const Type *Ty,
|
||||
std::set<const StructType*> &StructPrinted){
|
||||
|
@ -135,9 +135,9 @@ stuff too.
|
||||
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
For packed types, TargetData.cpp::getTypeInfo() returns alignment that is equal
|
||||
For vector types, TargetData.cpp::getTypeInfo() returns alignment that is equal
|
||||
to the type size. It works but can be overly conservative as the alignment of
|
||||
specific packed types are target dependent.
|
||||
specific vector types are target dependent.
|
||||
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
@ -150,7 +150,7 @@ v4sf example(float *P) {
|
||||
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
We should constant fold packed type casts at the LLVM level, regardless of the
|
||||
We should constant fold vector type casts at the LLVM level, regardless of the
|
||||
cast. Currently we cannot fold some casts because we don't have TargetData
|
||||
information in the constant folder, so we don't know the endianness of the
|
||||
target!
|
||||
|
@ -207,7 +207,7 @@ std::vector<Value*>& LowerPacked::getValues(Value* value)
|
||||
|
||||
void LowerPacked::visitLoadInst(LoadInst& LI)
|
||||
{
|
||||
// Make sure what we are dealing with is a packed type
|
||||
// Make sure what we are dealing with is a vector type
|
||||
if (const VectorType* PKT = dyn_cast<VectorType>(LI.getType())) {
|
||||
// Initialization, Idx is needed for getelementptr needed later
|
||||
std::vector<Value*> Idx(2);
|
||||
@ -217,7 +217,7 @@ void LowerPacked::visitLoadInst(LoadInst& LI)
|
||||
PKT->getNumElements());
|
||||
PointerType* APT = PointerType::get(AT);
|
||||
|
||||
// Cast the pointer to packed type to an equivalent array
|
||||
// Cast the pointer to vector type to an equivalent array
|
||||
Value* array = new BitCastInst(LI.getPointerOperand(), APT,
|
||||
LI.getName() + ".a", &LI);
|
||||
|
||||
|
@ -561,12 +561,12 @@ const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) {
|
||||
|
||||
if (const ArrayType *ATy = dyn_cast<ArrayType>(AggTy)) {
|
||||
if (Idx >= ATy->getNumElements()) return 0; // Out of range.
|
||||
} else if (const VectorType *PackedTy = dyn_cast<VectorType>(AggTy)) {
|
||||
} else if (const VectorType *VectorTy = dyn_cast<VectorType>(AggTy)) {
|
||||
// Getting an element of the packed vector.
|
||||
if (Idx >= PackedTy->getNumElements()) return 0; // Out of range.
|
||||
if (Idx >= VectorTy->getNumElements()) return 0; // Out of range.
|
||||
|
||||
// Merge in the packed type.
|
||||
if (MergeInType(PackedTy, UsedType, TD)) return 0;
|
||||
// Merge in the vector type.
|
||||
if (MergeInType(VectorTy, UsedType, TD)) return 0;
|
||||
|
||||
const Type *SubTy = CanConvertToScalar(GEP, IsNotTrivial);
|
||||
if (SubTy == 0) return 0;
|
||||
@ -640,8 +640,8 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) {
|
||||
Value *NV = new LoadInst(NewAI, LI->getName(), LI);
|
||||
if (NV->getType() != LI->getType()) {
|
||||
if (const VectorType *PTy = dyn_cast<VectorType>(NV->getType())) {
|
||||
// If the result alloca is a packed type, this is either an element
|
||||
// access or a bitcast to another packed type.
|
||||
// If the result alloca is a vector type, this is either an element
|
||||
// access or a bitcast to another vector type.
|
||||
if (isa<VectorType>(LI->getType())) {
|
||||
NV = new BitCastInst(NV, LI->getType(), LI->getName(), LI);
|
||||
} else {
|
||||
@ -703,8 +703,8 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) {
|
||||
Value *Old = new LoadInst(NewAI, NewAI->getName()+".in", SI);
|
||||
|
||||
if (const VectorType *PTy = dyn_cast<VectorType>(AllocaType)) {
|
||||
// If the result alloca is a packed type, this is either an element
|
||||
// access or a bitcast to another packed type.
|
||||
// If the result alloca is a vector type, this is either an element
|
||||
// access or a bitcast to another vector type.
|
||||
if (isa<VectorType>(SV->getType())) {
|
||||
SV = new BitCastInst(SV, AllocaType, SV->getName(), SI);
|
||||
} else {
|
||||
|
@ -36,7 +36,7 @@ using namespace llvm;
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// CastConstantVector - Convert the specified ConstantVector node to the
|
||||
/// specified packed type. At this point, we know that the elements of the
|
||||
/// specified vector type. At this point, we know that the elements of the
|
||||
/// input packed constant are all simple integer or FP values.
|
||||
static Constant *CastConstantVector(ConstantVector *CP,
|
||||
const VectorType *DstTy) {
|
||||
|
@ -1135,7 +1135,7 @@ static std::vector<Constant*> getValType(ConstantVector *CP) {
|
||||
}
|
||||
|
||||
static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType,
|
||||
ConstantVector> > PackedConstants;
|
||||
ConstantVector> > VectorConstants;
|
||||
|
||||
Constant *ConstantVector::get(const VectorType *Ty,
|
||||
const std::vector<Constant*> &V) {
|
||||
@ -1143,10 +1143,10 @@ Constant *ConstantVector::get(const VectorType *Ty,
|
||||
if (!V.empty()) {
|
||||
Constant *C = V[0];
|
||||
if (!C->isNullValue())
|
||||
return PackedConstants->getOrCreate(Ty, V);
|
||||
return VectorConstants->getOrCreate(Ty, V);
|
||||
for (unsigned i = 1, e = V.size(); i != e; ++i)
|
||||
if (V[i] != C)
|
||||
return PackedConstants->getOrCreate(Ty, V);
|
||||
return VectorConstants->getOrCreate(Ty, V);
|
||||
}
|
||||
return ConstantAggregateZero::get(Ty);
|
||||
}
|
||||
@ -1159,7 +1159,7 @@ Constant *ConstantVector::get(const std::vector<Constant*> &V) {
|
||||
// destroyConstant - Remove the constant from the constant table...
|
||||
//
|
||||
void ConstantVector::destroyConstant() {
|
||||
PackedConstants->remove(this);
|
||||
VectorConstants->remove(this);
|
||||
destroyConstantImpl();
|
||||
}
|
||||
|
||||
@ -1793,7 +1793,7 @@ Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
|
||||
|
||||
Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
|
||||
assert(isa<VectorType>(Val->getType()) &&
|
||||
"Tried to create extractelement operation on non-packed type!");
|
||||
"Tried to create extractelement operation on non-vector type!");
|
||||
assert(Idx->getType() == Type::Int32Ty &&
|
||||
"Extractelement index must be i32 type!");
|
||||
return getExtractElementTy(cast<VectorType>(Val->getType())->getElementType(),
|
||||
@ -1815,7 +1815,7 @@ Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val,
|
||||
Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
|
||||
Constant *Idx) {
|
||||
assert(isa<VectorType>(Val->getType()) &&
|
||||
"Tried to create insertelement operation on non-packed type!");
|
||||
"Tried to create insertelement operation on non-vector type!");
|
||||
assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
|
||||
&& "Insertelement types must match!");
|
||||
assert(Idx->getType() == Type::Int32Ty &&
|
||||
|
@ -1000,7 +1000,7 @@ InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, unsigned IndexV,
|
||||
bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
|
||||
const Value *Index) {
|
||||
if (!isa<VectorType>(Vec->getType()))
|
||||
return false; // First operand of insertelement must be packed type.
|
||||
return false; // First operand of insertelement must be vector type.
|
||||
|
||||
if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType())
|
||||
return false;// Second operand of insertelement must be packed element type.
|
||||
|
@ -110,7 +110,7 @@ bool Type::canLosslesslyBitCastTo(const Type *Ty) const {
|
||||
if (!this->isFirstClassType() || !Ty->isFirstClassType())
|
||||
return false;
|
||||
|
||||
// Packed -> Packed conversions are always lossless if the two packed types
|
||||
// Vector -> Vector conversions are always lossless if the two vector types
|
||||
// have the same size, otherwise not.
|
||||
if (const VectorType *thisPTy = dyn_cast<VectorType>(this))
|
||||
if (const VectorType *thatPTy = dyn_cast<VectorType>(Ty))
|
||||
|
@ -720,7 +720,7 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) {
|
||||
&B);
|
||||
Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() ||
|
||||
isa<VectorType>(B.getType()),
|
||||
"Arithmetic operators must have integer, fp, or packed type!", &B);
|
||||
"Arithmetic operators must have integer, fp, or vector type!", &B);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -999,7 +999,7 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
|
||||
// types of its operands.
|
||||
bool isFP = Ty->isFloatingPoint();
|
||||
if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
|
||||
// If its a packed type we want to use the element type
|
||||
// If its a vector type we want to use the element type
|
||||
isFP = PTy->getElementType()->isFloatingPoint();
|
||||
if (isFP)
|
||||
return Instruction::FDiv;
|
||||
@ -1015,7 +1015,7 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
|
||||
// types of its operands.
|
||||
bool isFP = Ty->isFloatingPoint();
|
||||
if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
|
||||
// If its a packed type we want to use the element type
|
||||
// If its a vector type we want to use the element type
|
||||
isFP = PTy->getElementType()->isFloatingPoint();
|
||||
// Select correct opcode
|
||||
if (isFP)
|
||||
@ -1841,7 +1841,7 @@ UpRTypes
|
||||
$$.S = $4.S;
|
||||
delete $4.PAT;
|
||||
}
|
||||
| '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type?
|
||||
| '<' EUINT64VAL 'x' UpRTypes '>' { // Vector type?
|
||||
const llvm::Type* ElemTy = $4.PAT->get();
|
||||
if ((unsigned)$2 != $2)
|
||||
error("Unsigned result not equal to signed result");
|
||||
@ -3112,7 +3112,7 @@ InstVal
|
||||
error("Arithmetic operator requires integer, FP, or packed operands");
|
||||
if (isa<VectorType>(Ty) &&
|
||||
($1 == URemOp || $1 == SRemOp || $1 == FRemOp || $1 == RemOp))
|
||||
error("Remainder not supported on packed types");
|
||||
error("Remainder not supported on vector types");
|
||||
// Upgrade the opcode from obsolete versions before we do anything with it.
|
||||
Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
|
||||
Value* val1 = getVal(Ty, $3);
|
||||
|
@ -338,7 +338,7 @@ CppWriter::getCppName(const Type* Ty)
|
||||
case Type::ArrayTyID: prefix = "ArrayTy_"; break;
|
||||
case Type::PointerTyID: prefix = "PointerTy_"; break;
|
||||
case Type::OpaqueTyID: prefix = "OpaqueTy_"; break;
|
||||
case Type::VectorTyID: prefix = "PackedTy_"; break;
|
||||
case Type::VectorTyID: prefix = "VectorTy_"; break;
|
||||
default: prefix = "OtherTy_"; break; // prevent breakage
|
||||
}
|
||||
|
||||
|
@ -119,7 +119,7 @@ static bool EmitTypeVerify(std::ostream &OS, Record *ArgType) {
|
||||
if (ArgType->isSubClassOf("LLVMIntegerType"))
|
||||
OS << ArgType->getValueAsInt("Width") << ", ";
|
||||
|
||||
// If this is a packed type, check that the subtype and size are correct.
|
||||
// If this is a vector type, check that the subtype and size are correct.
|
||||
else if (ArgType->isSubClassOf("LLVMVectorType")) {
|
||||
EmitTypeVerify(OS, ArgType->getValueAsDef("ElTy"));
|
||||
OS << ArgType->getValueAsInt("NumElts") << ", ";
|
||||
|
Loading…
Reference in New Issue
Block a user