6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 05:29:24 +00:00
Code Issues Projects Releases Wiki Activity

For PR1195:

Browse Source 
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:
Reid Spencer 2007-02-15 03:39:18 +00:00
parent a85210ac66
commit ac9dcb94dd
23 changed files with 72 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -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,

4
include/llvm/DerivedTypes.h
View File

@ -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>;

4
include/llvm/Instructions.h
View File

@ -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());

2
include/llvm/Target/TargetLowering.h
View File

@ -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.

2
include/llvm/Value.h
View File

@ -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

18
lib/AsmParser/llvmAsmParser.y
View File

@ -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);

4
lib/Bytecode/Reader/Analyzer.cpp
View File

@ -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";
}

12
lib/Bytecode/Reader/Reader.cpp
View File

@ -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!");

16
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -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.

2
lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
View File

@ -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);
}

16
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -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

2
lib/Target/CBackend/CBackend.cpp
View File

@ -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){

6
lib/Target/README.txt
View File

@ -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!

4
lib/Transforms/Scalar/LowerPacked.cpp
View File

@ -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);

16
lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -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 {

2
lib/VMCore/ConstantFold.cpp
View File

@ -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) {

12
lib/VMCore/Constants.cpp
View File

@ -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 &&

2
lib/VMCore/Instructions.cpp
View File

@ -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.

2
lib/VMCore/Type.cpp
View File

@ -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))

2
lib/VMCore/Verifier.cpp
View File

@ -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;
}

8
tools/llvm-upgrade/UpgradeParser.y
View File

@ -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);

2
tools/llvm2cpp/CppWriter.cpp
View File

@ -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
}

2
utils/TableGen/IntrinsicEmitter.cpp
View File

@ -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") << ", ";