diff options
49 files changed, 9166 insertions, 6961 deletions
diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html index 5393d7fd7d..a96a676c60 100644 --- a/docs/ProgrammersManual.html +++ b/docs/ProgrammersManual.html @@ -2314,7 +2314,7 @@ the <tt>lib/VMCore</tt> directory.</p> </dd> <dt><tt>PointerType</tt></dt> <dd>Subclass of SequentialType for pointer types.</dd> - <dt><tt>PackedType</tt></dt> + <dt><tt>VectorType</tt></dt> <dd>Subclass of SequentialType for packed (vector) types. A packed type is similar to an ArrayType but is distinguished because it is a first class type wherease ArrayType is not. Packed types are used for diff --git a/include/llvm/Bytecode/BytecodeHandler.h b/include/llvm/Bytecode/BytecodeHandler.h index 4084efa14c..eeae2a58d6 100644 --- a/include/llvm/Bytecode/BytecodeHandler.h +++ b/include/llvm/Bytecode/BytecodeHandler.h @@ -23,7 +23,7 @@ namespace llvm { class ArrayType; class StructType; class PointerType; -class PackedType; +class VectorType; class ConstantArray; class Module; @@ -242,8 +242,8 @@ public: ) {} /// @brief Handle a constant packed - virtual void handleConstantPacked( - const PackedType* PT, ///< Type of the array + virtual void handleConstantVector( + const VectorType* PT, ///< Type of the array Constant**ElementSlots, unsigned NumElts,///< Slot nums for packed values unsigned TypeSlot, ///< Slot # of type Constant* Val ///< The constant value diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index 3d4ff90fcc..e01e2a2823 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -28,7 +28,7 @@ namespace llvm { class ArrayType; class StructType; class PointerType; -class PackedType; +class VectorType; template<class ConstantClass, class TypeClass, class ValType> struct ConstantCreator; @@ -334,31 +334,31 @@ public: }; //===----------------------------------------------------------------------===// -/// ConstantPacked - Constant Packed Declarations +/// ConstantVector - Constant Vector Declarations /// -class ConstantPacked : public Constant { - friend struct ConstantCreator<ConstantPacked, PackedType, +class ConstantVector : public Constant { + friend struct ConstantCreator<ConstantVector, VectorType, std::vector<Constant*> >; - ConstantPacked(const ConstantPacked &); // DO NOT IMPLEMENT + ConstantVector(const ConstantVector &); // DO NOT IMPLEMENT protected: - ConstantPacked(const PackedType *T, const std::vector<Constant*> &Val); - ~ConstantPacked(); + ConstantVector(const VectorType *T, const std::vector<Constant*> &Val); + ~ConstantVector(); public: /// get() - Static factory methods - Return objects of the specified value - static Constant *get(const PackedType *T, const std::vector<Constant*> &); + static Constant *get(const VectorType *T, const std::vector<Constant*> &); static Constant *get(const std::vector<Constant*> &V); - /// getType - Specialize the getType() method to always return an PackedType, + /// getType - Specialize the getType() method to always return an VectorType, /// which reduces the amount of casting needed in parts of the compiler. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Value::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Value::getType()); } /// @returns the value for an packed integer constant of the given type that /// has all its bits set to true. /// @brief Get the all ones value - static ConstantPacked *getAllOnesValue(const PackedType *Ty); + 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 @@ -375,9 +375,9 @@ public: virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ConstantPacked *) { return true; } + static inline bool classof(const ConstantVector *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == ConstantPackedVal; + return V->getValueType() == ConstantVectorVal; } }; diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h index 06f3a98807..2426e7b289 100644 --- a/include/llvm/DerivedTypes.h +++ b/include/llvm/DerivedTypes.h @@ -28,7 +28,7 @@ class FunctionValType; class ArrayValType; class StructValType; class PointerValType; -class PackedValType; +class VectorValType; class IntegerValType; class DerivedType : public Type { @@ -214,7 +214,7 @@ public: /// CompositeType - Common super class of ArrayType, StructType, PointerType -/// and PackedType +/// and VectorType class CompositeType : public DerivedType { protected: inline CompositeType(TypeID id) : DerivedType(id) { } @@ -232,7 +232,7 @@ public: return T->getTypeID() == ArrayTyID || T->getTypeID() == StructTyID || T->getTypeID() == PointerTyID || - T->getTypeID() == PackedTyID; + T->getTypeID() == VectorTyID; } }; @@ -317,7 +317,7 @@ public: static inline bool classof(const Type *T) { return T->getTypeID() == ArrayTyID || T->getTypeID() == PointerTyID || - T->getTypeID() == PackedTyID; + T->getTypeID() == VectorTyID; } }; @@ -350,25 +350,25 @@ public: } }; -/// PackedType - Class to represent packed types +/// VectorType - Class to represent packed types /// -class PackedType : public SequentialType { - friend class TypeMap<PackedValType, PackedType>; +class VectorType : public SequentialType { + friend class TypeMap<VectorValType, VectorType>; unsigned NumElements; - PackedType(const PackedType &); // Do not implement - const PackedType &operator=(const PackedType &); // Do not implement - PackedType(const Type *ElType, unsigned NumEl); + VectorType(const VectorType &); // Do not implement + const VectorType &operator=(const VectorType &); // Do not implement + VectorType(const Type *ElType, unsigned NumEl); public: - /// PackedType::get - This static method is the primary way to construct an - /// PackedType + /// VectorType::get - This static method is the primary way to construct an + /// VectorType /// - static PackedType *get(const Type *ElementType, unsigned NumElements); + static VectorType *get(const Type *ElementType, unsigned NumElements); - /// @brief Return the number of elements in the Packed type. + /// @brief Return the number of elements in the Vector type. inline unsigned getNumElements() const { return NumElements; } - /// @brief Return the number of bits in the Packed type. + /// @brief Return the number of bits in the Vector type. inline unsigned getBitWidth() const { return NumElements *getElementType()->getPrimitiveSizeInBits(); } @@ -378,9 +378,9 @@ public: virtual void typeBecameConcrete(const DerivedType *AbsTy); // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const PackedType *T) { return true; } + static inline bool classof(const VectorType *T) { return true; } static inline bool classof(const Type *T) { - return T->getTypeID() == PackedTyID; + return T->getTypeID() == VectorTyID; } }; diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 3d22ef202a..a5f0b0bd01 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -23,7 +23,7 @@ namespace llvm { class BasicBlock; class ConstantInt; class PointerType; -class PackedType; +class VectorType; //===----------------------------------------------------------------------===// // AllocationInst Class @@ -862,7 +862,7 @@ public: //===----------------------------------------------------------------------===// /// ExtractElementInst - This instruction extracts a single (scalar) -/// element from a PackedType value +/// element from a VectorType value /// class ExtractElementInst : public Instruction { Use Ops[2]; @@ -916,7 +916,7 @@ public: //===----------------------------------------------------------------------===// /// InsertElementInst - This instruction inserts a single (scalar) -/// element into a PackedType value +/// element into a VectorType value /// class InsertElementInst : public Instruction { Use Ops[3]; @@ -942,8 +942,8 @@ public: /// getType - Overload to return most specific packed type. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Instruction::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Instruction::getType()); } /// Transparently provide more efficient getOperand methods. @@ -994,8 +994,8 @@ public: /// getType - Overload to return most specific packed type. /// - inline const PackedType *getType() const { - return reinterpret_cast<const PackedType*>(Instruction::getType()); + inline const VectorType *getType() const { + return reinterpret_cast<const VectorType*>(Instruction::getType()); } /// Transparently provide more efficient getOperand methods. diff --git a/include/llvm/Intrinsics.td b/include/llvm/Intrinsics.td index f3cd4f6d01..05a5a68edc 100644 --- a/include/llvm/Intrinsics.td +++ b/include/llvm/Intrinsics.td @@ -62,8 +62,8 @@ class LLVMIntegerType<ValueType VT, int width> int Width = width; } -class LLVMPackedType<ValueType VT, int numelts, LLVMType elty> - : LLVMType<VT, "Type::PackedTyID">{ +class LLVMVectorType<ValueType VT, int numelts, LLVMType elty> + : LLVMType<VT, "Type::VectorTyID">{ int NumElts = numelts; LLVMType ElTy = elty; } @@ -90,13 +90,13 @@ def llvm_ptrptr_ty : LLVMPointerType<llvm_ptr_ty>; // i8** def llvm_empty_ty : LLVMEmptyStructType; // { } def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>; // { }* -def llvm_v16i8_ty : LLVMPackedType<v16i8,16, llvm_i8_ty>; // 16 x i8 -def llvm_v8i16_ty : LLVMPackedType<v8i16, 8, llvm_i16_ty>; // 8 x i16 -def llvm_v2i64_ty : LLVMPackedType<v2i64, 2, llvm_i64_ty>; // 2 x i64 -def llvm_v2i32_ty : LLVMPackedType<v2i32, 2, llvm_i32_ty>; // 2 x i32 -def llvm_v4i32_ty : LLVMPackedType<v4i32, 4, llvm_i32_ty>; // 4 x i32 -def llvm_v4f32_ty : LLVMPackedType<v4f32, 4, llvm_float_ty>; // 4 x float -def llvm_v2f64_ty : LLVMPackedType<v2f64, 2, llvm_double_ty>;// 2 x double +def llvm_v16i8_ty : LLVMVectorType<v16i8,16, llvm_i8_ty>; // 16 x i8 +def llvm_v8i16_ty : LLVMVectorType<v8i16, 8, llvm_i16_ty>; // 8 x i16 +def llvm_v2i64_ty : LLVMVectorType<v2i64, 2, llvm_i64_ty>; // 2 x i64 +def llvm_v2i32_ty : LLVMVectorType<v2i32, 2, llvm_i32_ty>; // 2 x i32 +def llvm_v4i32_ty : LLVMVectorType<v4i32, 4, llvm_i32_ty>; // 4 x i32 +def llvm_v4f32_ty : LLVMVectorType<v4f32, 4, llvm_float_ty>; // 4 x float +def llvm_v2f64_ty : LLVMVectorType<v2f64, 2, llvm_double_ty>;// 2 x double def llvm_vararg_ty : LLVMType<isVoid, "...">; // vararg diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h index 7bdf01f9e4..7a1652900c 100644 --- a/include/llvm/Target/TargetLowering.h +++ b/include/llvm/Target/TargetLowering.h @@ -38,7 +38,7 @@ namespace llvm { class SelectionDAG; class MachineBasicBlock; class MachineInstr; - class PackedType; + class VectorType; //===----------------------------------------------------------------------===// /// TargetLowering - This class defines information used to lower LLVM code to @@ -198,16 +198,16 @@ public: return VT; } - /// getPackedTypeBreakdown - Packed types are broken down into some number of + /// getVectorTypeBreakdown - Packed 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. /// /// This method returns the number of registers needed, and the VT for each - /// register. It also returns the VT of the PackedType elements before they + /// register. It also returns the VT of the VectorType elements before they /// are promoted/expanded. /// - unsigned getPackedTypeBreakdown(const PackedType *PTy, + unsigned getVectorTypeBreakdown(const VectorType *PTy, MVT::ValueType &PTyElementVT, MVT::ValueType &PTyLegalElementVT) const; diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index ff6fbf0b05..8c6e6ccb31 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -261,7 +261,7 @@ extern const PassInfo *LowerSwitchID; //===----------------------------------------------------------------------===// // -// LowerPacked - This pass converts PackedType operations into low-level scalar +// LowerPacked - This pass converts VectorType operations into low-level scalar // operations. // FunctionPass *createLowerPackedPass(); diff --git a/include/llvm/Type.h b/include/llvm/Type.h index 7a2e432a3a..880daadfb1 100644 --- a/include/llvm/Type.h +++ b/include/llvm/Type.h @@ -81,7 +81,7 @@ public: ArrayTyID, ///< 8: Arrays PointerTyID, ///< 9: Pointers OpaqueTyID, ///< 10: Opaque: type with unknown structure - PackedTyID, ///< 11: SIMD 'packed' format, or other vector type + VectorTyID, ///< 11: SIMD 'packed' format, or other vector type NumTypeIDs, // Must remain as last defined ID LastPrimitiveTyID = LabelTyID, @@ -191,7 +191,7 @@ public: /// inline bool isFirstClassType() const { return (ID != VoidTyID && ID <= LastPrimitiveTyID) || - ID == IntegerTyID || ID == PointerTyID || ID == PackedTyID; + ID == IntegerTyID || ID == PointerTyID || ID == VectorTyID; } /// isSized - Return true if it makes sense to take the size of this type. To @@ -204,7 +204,7 @@ public: return true; // If it is not something that can have a size (e.g. a function or label), // it doesn't have a size. - if (ID != StructTyID && ID != ArrayTyID && ID != PackedTyID && + if (ID != StructTyID && ID != ArrayTyID && ID != VectorTyID && ID != PackedStructTyID) return false; // If it is something that can have a size and it's concrete, it definitely diff --git a/include/llvm/Value.h b/include/llvm/Value.h index fac596b415..1e2a8f6fb6 100644 --- 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 - ConstantPackedVal, // This is an instance of ConstantPacked + ConstantVectorVal, // This is an instance of ConstantPacked 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/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index 939fa6de45..5785d09ff6 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -689,7 +689,7 @@ BasicAliasAnalysis::CheckGEPInstructions( if (const ArrayType *AT = dyn_cast<ArrayType>(BasePtr1Ty)) { if (Op1C->getZExtValue() >= AT->getNumElements()) return MayAlias; // Be conservative with out-of-range accesses - } else if (const PackedType *PT = dyn_cast<PackedType>(BasePtr1Ty)) { + } else if (const VectorType *PT = dyn_cast<VectorType>(BasePtr1Ty)) { if (Op1C->getZExtValue() >= PT->getNumElements()) return MayAlias; // Be conservative with out-of-range accesses } @@ -707,7 +707,7 @@ BasicAliasAnalysis::CheckGEPInstructions( // if (const ArrayType *AT = dyn_cast<ArrayType>(BasePtr1Ty)) GEP1Ops[i] = ConstantInt::get(Type::Int64Ty,AT->getNumElements()-1); - else if (const PackedType *PT = dyn_cast<PackedType>(BasePtr1Ty)) + else if (const VectorType *PT = dyn_cast<VectorType>(BasePtr1Ty)) GEP1Ops[i] = ConstantInt::get(Type::Int64Ty,PT->getNumElements()-1); } @@ -719,7 +719,7 @@ BasicAliasAnalysis::CheckGEPInstructions( if (const ArrayType *AT = dyn_cast<ArrayType>(BasePtr1Ty)) { if (Op2C->getZExtValue() >= AT->getNumElements()) return MayAlias; // Be conservative with out-of-range accesses - } else if (const PackedType *PT = dyn_cast<PackedType>(BasePtr1Ty)) { + } else if (const VectorType *PT = dyn_cast<VectorType>(BasePtr1Ty)) { if (Op2C->getZExtValue() >= PT->getNumElements()) return MayAlias; // Be conservative with out-of-range accesses } diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp index 6fd8ff8b56..01aedda635 100644 --- a/lib/Analysis/ConstantFolding.cpp +++ b/lib/Analysis/ConstantFolding.cpp @@ -283,10 +283,10 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, C = UndefValue::get(ATy->getElementType()); else return 0; - } else if (const PackedType *PTy = dyn_cast<PackedType>(*I)) { + } else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) { if (CI->getZExtValue() >= PTy->getNumElements()) return 0; - if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) + if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) C = CP->getOperand(CI->getZExtValue()); else if (isa<ConstantAggregateZero>(C)) C = Constant::getNullValue(PTy->getElementType()); diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs index 6267f3c50b..6c0011d023 100644 --- a/lib/AsmParser/llvmAsmParser.cpp.cvs +++ b/lib/AsmParser/llvmAsmParser.cpp.cvs @@ -1,147 +1,336 @@ +/* A Bison parser, made by GNU Bison 2.1. */ -/* A Bison parser, made from /Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y - by GNU Bison version 1.28 */ +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. -#define YYBISON 1 /* Identify Bison output. */ + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.1" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* Substitute the variable and function names. */ #define yyparse llvmAsmparse -#define yylex llvmAsmlex +#define yylex llvmAsmlex #define yyerror llvmAsmerror -#define yylval llvmAsmlval -#define yychar llvmAsmchar +#define yylval llvmAsmlval +#define yychar llvmAsmchar #define yydebug llvmAsmdebug #define yynerrs llvmAsmnerrs -#define ESINT64VAL 257 -#define EUINT64VAL 258 -#define LOCALVAL_ID 259 -#define GLOBALVAL_ID 260 -#define FPVAL 261 -#define VOID 262 -#define INTTYPE 263 -#define FLOAT 264 -#define DOUBLE 265 -#define LABEL 266 -#define TYPE 267 -#define LOCALVAR 268 -#define GLOBALVAR 269 -#define LABELSTR 270 -#define STRINGCONSTANT 271 -#define ATSTRINGCONSTANT 272 -#define IMPLEMENTATION 273 -#define ZEROINITIALIZER 274 -#define TRUETOK 275 -#define FALSETOK 276 -#define BEGINTOK 277 -#define ENDTOK 278 -#define DECLARE 279 -#define DEFINE 280 -#define GLOBAL 281 -#define CONSTANT 282 -#define SECTION 283 -#define VOLATILE 284 -#define TO 285 -#define |