From 07a96765daedf180a7102d39fe56c499878312b7 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Mon, 16 Jul 2007 14:29:03 +0000 Subject: [PATCH] Fix comments about vectors to use the current wording. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@39921 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Constants.h | 2 +- include/llvm/DerivedTypes.h | 2 +- include/llvm/InstrTypes.h | 2 +- include/llvm/Target/TargetData.h | 2 +- lib/Analysis/BasicAliasAnalysis.cpp | 2 +- lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 4 ++-- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 4 ++-- lib/Target/TargetSelectionDAG.td | 2 +- lib/Transforms/Scalar/InstructionCombining.cpp | 10 +++++----- lib/Transforms/Scalar/ScalarReplAggregates.cpp | 4 ++-- lib/Transforms/Utils/ValueMapper.cpp | 4 ++-- lib/VMCore/ConstantFold.cpp | 14 +++++++------- lib/VMCore/Verifier.cpp | 2 +- 13 files changed, 27 insertions(+), 27 deletions(-) diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index c14d25d6765..526f19c4239 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -412,7 +412,7 @@ public: 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 + /// getNullValue. This always returns false because zero vectors are always /// created as ConstantAggregateZero objects. virtual bool isNullValue() const { return false; } diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h index 5aaa76ede3e..ba35d783b8a 100644 --- a/include/llvm/DerivedTypes.h +++ b/include/llvm/DerivedTypes.h @@ -267,7 +267,7 @@ public: }; -/// SequentialType - This is the superclass of the array, pointer and packed +/// SequentialType - This is the superclass of the array, pointer and vector /// type classes. All of these represent "arrays" in memory. The array type /// represents a specifically sized array, pointer types are unsized/unknown /// size arrays, vector types represent specifically sized arrays that diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index 5439337224a..d96b20f76b4 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -400,7 +400,7 @@ public: /// A lossless cast is one that does not alter the basic value. It implies /// a no-op cast but is more stringent, preventing things like int->float, - /// long->double, int->ptr, or packed->anything. + /// long->double, int->ptr, or vector->anything. /// @returns true iff the cast is lossless. /// @brief Determine if this is a lossless cast. bool isLosslessCast() const; diff --git a/include/llvm/Target/TargetData.h b/include/llvm/Target/TargetData.h index 77657e2518c..5756079c40f 100644 --- a/include/llvm/Target/TargetData.h +++ b/include/llvm/Target/TargetData.h @@ -43,7 +43,7 @@ enum AlignTypeEnum { /// Target alignment element. /// /// Stores the alignment data associated with a given alignment type (pointer, -/// integer, packed/vector, float) and type bit width. +/// integer, vector, float) and type bit width. /// /// @note The unusual order of elements in the structure attempts to reduce /// padding and make the structure slightly more cache friendly. diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index b6072fdf876..580f7e5d9e4 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -574,7 +574,7 @@ BasicAliasAnalysis::CheckGEPInstructions( } if (G1OC != G2OC) { - // Handle the "be careful" case above: if this is an array/packed + // Handle the "be careful" case above: if this is an array/vector // subscript, scan for a subsequent variable array index. if (isa(BasePtr1Ty)) { const Type *NextTy = diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index 0f0ba071c0c..5bcee351ea7 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -2846,7 +2846,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { // type. If so, convert to the vector type. MVT::ValueType TVT = MVT::getVectorType(EVT, NumElems); if (TLI.isTypeLegal(TVT)) { - // Turn this into a bit convert of the packed input. + // Turn this into a bit convert of the vector input. Result = DAG.getNode(ISD::BIT_CONVERT, Node->getValueType(0), LegalizeOp(Node->getOperand(0))); break; @@ -3935,7 +3935,7 @@ SDOperand SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { /// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't -/// support the operation, but do support the resultant packed vector type. +/// support the operation, but do support the resultant vector type. SDOperand SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) { // If the only non-undef value is the low element, turn this into a diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 8a2f7b1f5fa..d4651fd6abc 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -840,13 +840,13 @@ SDOperand SelectionDAGLowering::getValue(const Value *V) { // Now that we know the number and type of the elements, push a // Constant or ConstantFP node onto the ops list for each element of - // the packed constant. + // the vector constant. SmallVector Ops; if (ConstantVector *CP = dyn_cast(C)) { for (unsigned i = 0; i != NumElements; ++i) Ops.push_back(getValue(CP->getOperand(i))); } else { - assert(isa(C) && "Unknown packed constant!"); + assert(isa(C) && "Unknown vector constant!"); SDOperand Op; if (MVT::isFloatingPoint(PVT)) Op = DAG.getConstantFP(0, PVT); diff --git a/lib/Target/TargetSelectionDAG.td b/lib/Target/TargetSelectionDAG.td index 3d728e9062c..491bb023fed 100644 --- a/lib/Target/TargetSelectionDAG.td +++ b/lib/Target/TargetSelectionDAG.td @@ -52,7 +52,7 @@ class SDTCisOpSmallerThanOp : SDTypeConstraint{ } /// SDTCisIntVectorOfSameSize - This indicates that ThisOp and OtherOp are -/// packed vector types, and that ThisOp is the result of +/// vector types, and that ThisOp is the result of /// MVT::getIntVectorWithNumElements with the number of elements that ThisOp /// has. class SDTCisIntVectorOfSameSize diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 77cb18584f9..816a1c626af 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -1506,7 +1506,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, uint64_t DemandedElts, break; } case Instruction::BitCast: { - // Packed->packed casts only. + // Vector->vector casts only. const VectorType *VTy = dyn_cast(I->getOperand(0)->getType()); if (!VTy) break; unsigned InVWidth = VTy->getNumElements(); @@ -1514,7 +1514,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, uint64_t DemandedElts, unsigned Ratio; if (VWidth == InVWidth) { - // If we are converting from <4x i32> -> <4 x f32>, we demand the same + // If we are converting from <4 x i32> -> <4 x f32>, we demand the same // elements as are demanded of us. Ratio = 1; InputDemandedElts = DemandedElts; @@ -9354,16 +9354,16 @@ static Value *FindScalarElement(Value *V, unsigned EltNo) { Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) { - // If packed val is undef, replace extract with scalar undef. + // If vector val is undef, replace extract with scalar undef. if (isa(EI.getOperand(0))) return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); - // If packed val is constant 0, replace extract with scalar 0. + // If vector val is constant 0, replace extract with scalar 0. if (isa(EI.getOperand(0))) return ReplaceInstUsesWith(EI, Constant::getNullValue(EI.getType())); if (ConstantVector *C = dyn_cast(EI.getOperand(0))) { - // If packed val is constant with uniform operands, replace EI + // If vector val is constant with uniform operands, replace EI // with that operand Constant *op0 = C->getOperand(0); for (unsigned i = 1; i < C->getNumOperands(); ++i) diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index 5e7dbc2ff8f..e303468ee57 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -652,7 +652,7 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI, if (CI->isZero()) { StoreVal = Constant::getNullValue(EltTy); // 0.0, null, 0, <0,0> } else { - // If EltTy is a packed type, get the element type. + // If EltTy is a vector type, get the element type. const Type *ValTy = EltTy; if (const VectorType *VTy = dyn_cast(ValTy)) ValTy = VTy->getElementType(); @@ -989,7 +989,7 @@ const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) { if (const ArrayType *ATy = dyn_cast(AggTy)) { if (Idx >= ATy->getNumElements()) return 0; // Out of range. } else if (const VectorType *VectorTy = dyn_cast(AggTy)) { - // Getting an element of the packed vector. + // Getting an element of the vector. if (Idx >= VectorTy->getNumElements()) return 0; // Out of range. // Merge in the vector type. diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp index bfba94a24f1..0b8c5c27960 100644 --- a/lib/Transforms/Utils/ValueMapper.cpp +++ b/lib/Transforms/Utils/ValueMapper.cpp @@ -82,8 +82,8 @@ Value *llvm::MapValue(const Value *V, ValueMapTy &VM) { for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) { Value *MV = MapValue(CP->getOperand(i), VM); if (MV != CP->getOperand(i)) { - // This packed value must contain a reference to a global, make a new - // packed constant and return it. + // This vector value must contain a reference to a global, make a new + // vector constant and return it. // std::vector Values; Values.reserve(CP->getNumOperands()); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index ed69814383d..53e5c691361 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -37,7 +37,7 @@ using namespace llvm; /// CastConstantVector - Convert the specified ConstantVector node to the /// specified vector type. At this point, we know that the elements of the -/// input packed constant are all simple integer or FP values. +/// input vector constant are all simple integer or FP values. static Constant *CastConstantVector(ConstantVector *CV, const VectorType *DstTy) { unsigned SrcNumElts = CV->getType()->getNumElements(); @@ -258,7 +258,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, const_cast(V), &IdxList[0], IdxList.size()); } - // Handle casts from one packed constant to another. We know that the src + // Handle casts from one vector constant to another. We know that the src // and dest type have the same size (otherwise its an illegal cast). if (const VectorType *DestPTy = dyn_cast(DestTy)) { if (const VectorType *SrcTy = dyn_cast(V->getType())) { @@ -308,7 +308,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, assert(DestTy == Type::DoubleTy && "Unknown FP type!"); return ConstantFP::get(DestTy, CI->getValue().bitsToDouble()); } - // Otherwise, can't fold this (packed?) + // Otherwise, can't fold this (vector?) return 0; } @@ -373,7 +373,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, if (!CIdx) return 0; APInt idxVal = CIdx->getValue(); if (isa(Val)) { - // Insertion of scalar constant into packed undef + // Insertion of scalar constant into vector undef // Optimize away insertion of undef if (isa(Elt)) return const_cast(Val); @@ -391,7 +391,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, return ConstantVector::get(Ops); } if (isa(Val)) { - // Insertion of scalar constant into packed aggregate zero + // Insertion of scalar constant into vector aggregate zero // Optimize away insertion of zero if (Elt->isNullValue()) return const_cast(Val); @@ -409,7 +409,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, return ConstantVector::get(Ops); } if (const ConstantVector *CVal = dyn_cast(Val)) { - // Insertion of scalar constant into packed constant + // Insertion of scalar constant into vector constant std::vector Ops; Ops.reserve(CVal->getNumOperands()); for (unsigned i = 0; i < CVal->getNumOperands(); ++i) { @@ -429,7 +429,7 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, return 0; } -/// EvalVectorOp - Given two packed constants and a function pointer, apply the +/// EvalVectorOp - Given two vector constants and a function pointer, apply the /// function pointer to each element pair, producing a new ConstantVector /// constant. static Constant *EvalVectorOp(const ConstantVector *V1, diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 4e3a16e8ee9..a40d197aa29 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -1109,7 +1109,7 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, ...) { break; } } else if (TypeID == Type::VectorTyID) { - // If this is a packed argument, verify the number and type of elements. + // If this is a vector argument, verify the number and type of elements. const VectorType *PTy = cast(Ty); int ElemTy = va_arg(VA, int); if (ElemTy != PTy->getElementType()->getTypeID()) {