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

diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index dd7aee353524153819acab24dcc8f082d21fd0d2..fd976f91e9c296e6e241b3a980b56cb375e81795 100644 (file)
--- a/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -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,
     

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index 2426e7b289dcab33dfdecf5fbbc85357df15c807..08a7aeffe3bf5768581a6e5c1ac0cf980d08821d 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -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>;

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index a5f0b0bd0133dd3f1deead1c6ef33746e16d5bf9..9fc76019aa6a6b5057fff91699afd582509f737b 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -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());

diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h
index 7a1652900c128f057bafe0807bde97a5c7da2ed6..b52b68c9dc6e0bfc2fed5c66a7b7a390a3dd813b 100644 (file)
--- a/include/llvm/Target/TargetLowering.h
+++ b/include/llvm/Target/TargetLowering.h
@@ -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.

diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index 1e2a8f6fb68e5c375ccca7ae0586b31d84d10c81..95d86ce7826f2447bae3d354c6a1ce584e643ef4 100644 (file)
--- 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
-    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

diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 3f7115842a8cca69f53d19d563de5303f723d8e7..3038a79fef328da01a00eed6e07c17ad2b745a15 100644 (file)
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -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);

diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp
index 75b3ca7aa827c38b5ad4bd1bec911e48155273c2..aef482a289fb85086b5d285b1a402daf6daeaea9 100644 (file)
--- a/lib/Bytecode/Reader/Analyzer.cpp
+++ b/lib/Bytecode/Reader/Analyzer.cpp
@@ -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";
     }
 

diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index bafe7d3250361f35fc6171b9286af3001ed430cf..200f0d7a2fe3fa1080ea0eec02b792e71510484a 100644 (file)
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -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!");

diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index 87dffdcc932a0f8b670a1285c431aec82cf0c856..eb44250cc0594e52fdcc9507ec86d009ed86d61b 100644 (file)
--- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -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.

diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
index d290d88615ea424c1b3d0ae9088ed4d84edaafe1..f6e9b2c88b45e4908393b4e20688d5102566575e 100644 (file)
--- a/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
@@ -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);
       }

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index a156bda97509e02c99839476eda16650ce722009..38d2300d709788f6f5c7258ddce3c4b832800fa7 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -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

diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index 460bf66fd0dac7ed798a70d72da62642019f7a7e..b434d31b90a8b6ad140e515d8a563992ba7f07b5 100644 (file)
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -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){

diff --git a/lib/Target/README.txt b/lib/Target/README.txt
index 8cead8e3f03dabf73615528552260cbfe6f14807..437e93c18c7089e7145cefe1a6154ff250e82d2d 100644 (file)
--- a/lib/Target/README.txt
+++ b/lib/Target/README.txt
@@ -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!

diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp
index d8416853d67854146c87db72ef34e3b041b698b7..4e1d280b1ec2bb93e27b7f0084555ae23dcdb73d 100644 (file)
--- a/lib/Transforms/Scalar/LowerPacked.cpp
+++ b/lib/Transforms/Scalar/LowerPacked.cpp
@@ -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);
 

diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index 480f2aae2ff3f21ab3c43dc26496c5b8a6274355..70bb6a687ae0c5950753c83bc2f35c50f35b1e4c 100644 (file)
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -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 {            

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 35a0eab2a281d021a9ce457f4b253bf926d09924..7cb4b7bfbe51d58a13937ad3a650b24134f36d26 100644 (file)
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -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) {

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 992159f867c6c45b9567013bd1a73dfc4b4d37ea..ab2d2732fd11ec3ec70729f683e0f690a678dd82 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -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 &&

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index e591845e40382ac3cf8890821f71db1c699ae629..39fbb3ab7e569f99b36374c685fde30696e34bff 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -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.

diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index b70b7c5ba3c64da8b607e61c9f2e78129cebf015..da5cdb7452c6469d069b6a6b7d0ce61b171b5e68 100644 (file)
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -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))

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 484dfd115f3c292ceebc91c5a2ce948ae0029fe1..bf9ebeaccf200117a5fccfae6566ffb26476502f 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -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;
   }
 

diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index df472cc21f1c276e80a09035357f8c613dd95d9f..e0dfdbdf684446d93bd087d4ba8fcd2e28fb5c0b 100644 (file)
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -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); 

diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 05a85cf8063e950c2c68a5837fc6d2448aa5d311..9dffb6389451bfbb2de45596a278ff3c7dbb2ac8 100644 (file)
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -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
   }
 

diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 214f3104905bdb8654e0914df4255303c423420e..faa750daee220c6c5eba140d63393615ce47322d 100644 (file)
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -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") << ", ";