RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-24 12:19:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix comments about vectors to use the current wording.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@39921 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2007-07-16 14:29:03 +00:00
parent 318f0dee83
commit 07a96765da
13 changed files with 27 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Constants.h
View File

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

2
include/llvm/DerivedTypes.h
View File

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

2
include/llvm/InstrTypes.h
View File

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

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

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

2
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -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<SequentialType>(BasePtr1Ty)) {
const Type *NextTy =

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

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

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

@ -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<SDOperand, 8> Ops;
if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) {
for (unsigned i = 0; i != NumElements; ++i)
Ops.push_back(getValue(CP->getOperand(i)));
} else {
assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!");
assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
SDOperand Op;
if (MVT::isFloatingPoint(PVT))
Op = DAG.getConstantFP(0, PVT);

2
lib/Target/TargetSelectionDAG.td
View File

@ -52,7 +52,7 @@ class SDTCisOpSmallerThanOp<int SmallOp, int BigOp> : SDTypeConstraint<SmallOp>{
}
/// 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<int ThisOp, int OtherOp>

10
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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<VectorType>(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<UndefValue>(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<ConstantAggregateZero>(EI.getOperand(0)))
return ReplaceInstUsesWith(EI, Constant::getNullValue(EI.getType()));
if (ConstantVector *C = dyn_cast<ConstantVector>(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)

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

@ -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<VectorType>(ValTy))
ValTy = VTy->getElementType();
@ -989,7 +989,7 @@ 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 *VectorTy = dyn_cast<VectorType>(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.

4
lib/Transforms/Utils/ValueMapper.cpp
View File

@ -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<Constant*> Values;
Values.reserve(CP->getNumOperands());

14
lib/VMCore/ConstantFold.cpp
View File

@ -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<Constant*>(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<VectorType>(DestTy)) {
if (const VectorType *SrcTy = dyn_cast<VectorType>(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<UndefValue>(Val)) {
// Insertion of scalar constant into packed undef
// Insertion of scalar constant into vector undef
// Optimize away insertion of undef
if (isa<UndefValue>(Elt))
return const_cast<Constant*>(Val);
@ -391,7 +391,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val,
return ConstantVector::get(Ops);
}
if (isa<ConstantAggregateZero>(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<Constant*>(Val);
@ -409,7 +409,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val,
return ConstantVector::get(Ops);
}
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
// Insertion of scalar constant into packed constant
// Insertion of scalar constant into vector constant
std::vector<Constant*> 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,

2
lib/VMCore/Verifier.cpp
View File

@ -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<VectorType>(Ty);
int ElemTy = va_arg(VA, int);
if (ElemTy != PTy->getElementType()->getTypeID()) {