From 5e94bb00b3763a2a0bd03582b50a2c6eb5824941 Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Sat, 1 Apr 2017 15:53:12 +0000 Subject: [PATCH] fix formatting; NFC llvm-svn: 299305 --- llvm/include/llvm/CodeGen/MachineValueType.h | 67 +++++++------- llvm/include/llvm/CodeGen/ValueTypes.h | 131 +++++++++++++-------------- 2 files changed, 94 insertions(+), 104 deletions(-) diff --git a/llvm/include/llvm/CodeGen/MachineValueType.h b/llvm/include/llvm/CodeGen/MachineValueType.h index 00d65c3..e4744fd 100644 --- a/llvm/include/llvm/CodeGen/MachineValueType.h +++ b/llvm/include/llvm/CodeGen/MachineValueType.h @@ -23,14 +23,13 @@ namespace llvm { class Type; - /// MVT - Machine Value Type. Every type that is supported natively by some + /// Machine Value Type. Every type that is supported natively by some /// processor targeted by LLVM occurs here. This means that any legal value /// type can be represented by an MVT. class MVT { public: enum SimpleValueType : int8_t { - // INVALID_SIMPLE_VALUE_TYPE - Simple value types less than zero are - // considered extended value types. + // Simple value types less than zero are considered extended value types. INVALID_SIMPLE_VALUE_TYPE = -1, // If you change this numbering, you must change the values in @@ -141,37 +140,37 @@ class MVT { // This value must be a multiple of 32. MAX_ALLOWED_VALUETYPE = 96, - // Token - A value of type llvm::TokenTy + // A value of type llvm::TokenTy token = 120, - // Metadata - This is MDNode or MDString. + // This is MDNode or MDString. Metadata = 121, - // iPTRAny - An int value the size of the pointer of the current + // An int value the size of the pointer of the current // target to any address space. This must only be used internal to // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR. iPTRAny = 122, - // vAny - A vector with any length and element size. This is used + // A vector with any length and element size. This is used // for intrinsics that have overloadings based on vector types. // This is only for tblgen's consumption! vAny = 123, - // fAny - Any floating-point or vector floating-point value. This is used + // Any floating-point or vector floating-point value. This is used // for intrinsics that have overloadings based on floating-point types. // This is only for tblgen's consumption! fAny = 124, - // iAny - An integer or vector integer value of any bit width. This is + // An integer or vector integer value of any bit width. This is // used for intrinsics that have overloadings based on integer bit widths. // This is only for tblgen's consumption! iAny = 125, - // iPTR - An int value the size of the pointer of the current + // An int value the size of the pointer of the current // target. This should only be used internal to tblgen! iPTR = 126, - // Any - Any type. This is used for intrinsics that have overloadings. + // Any type. This is used for intrinsics that have overloadings. // This is only for tblgen's consumption! Any = 127 }; @@ -188,13 +187,13 @@ class MVT { bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; } bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; } - /// isValid - Return true if this is a valid simple valuetype. + /// Return true if this is a valid simple valuetype. bool isValid() const { return (SimpleTy >= MVT::FIRST_VALUETYPE && SimpleTy < MVT::LAST_VALUETYPE); } - /// isFloatingPoint - Return true if this is a FP, or a vector FP type. + /// Return true if this is a FP or a vector FP type. bool isFloatingPoint() const { return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE && SimpleTy <= MVT::LAST_FP_VALUETYPE) || @@ -202,7 +201,7 @@ class MVT { SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE)); } - /// isInteger - Return true if this is an integer, or a vector integer type. + /// Return true if this is an integer or a vector integer type. bool isInteger() const { return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) || @@ -210,33 +209,32 @@ class MVT { SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE)); } - /// isScalarInteger - Return true if this is an integer, not including - /// vectors. + /// Return true if this is an integer, not including vectors. bool isScalarInteger() const { return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && SimpleTy <= MVT::LAST_INTEGER_VALUETYPE); } - /// isVector - Return true if this is a vector value type. + /// Return true if this is a vector value type. bool isVector() const { return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE && SimpleTy <= MVT::LAST_VECTOR_VALUETYPE); } - /// is16BitVector - Return true if this is a 16-bit vector type. + /// Return true if this is a 16-bit vector type. bool is16BitVector() const { return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 || SimpleTy == MVT::v16i1); } - /// is32BitVector - Return true if this is a 32-bit vector type. + /// Return true if this is a 32-bit vector type. bool is32BitVector() const { return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8 || SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 || SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32); } - /// is64BitVector - Return true if this is a 64-bit vector type. + /// Return true if this is a 64-bit vector type. bool is64BitVector() const { return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8 || SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 || @@ -244,7 +242,7 @@ class MVT { SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64); } - /// is128BitVector - Return true if this is a 128-bit vector type. + /// Return true if this is a 128-bit vector type. bool is128BitVector() const { return (SimpleTy == MVT::v16i8 || SimpleTy == MVT::v8i16 || SimpleTy == MVT::v4i32 || SimpleTy == MVT::v2i64 || @@ -252,14 +250,14 @@ class MVT { SimpleTy == MVT::v4f32 || SimpleTy == MVT::v2f64); } - /// is256BitVector - Return true if this is a 256-bit vector type. + /// Return true if this is a 256-bit vector type. bool is256BitVector() const { return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 || SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 || SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64); } - /// is512BitVector - Return true if this is a 512-bit vector type. + /// Return true if this is a 512-bit vector type. bool is512BitVector() const { return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64 || SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8 || @@ -267,34 +265,34 @@ class MVT { SimpleTy == MVT::v8i64); } - /// is1024BitVector - Return true if this is a 1024-bit vector type. + /// Return true if this is a 1024-bit vector type. bool is1024BitVector() const { return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 || SimpleTy == MVT::v64i16 || SimpleTy == MVT::v32i32 || SimpleTy == MVT::v16i64); } - /// is2048BitVector - Return true if this is a 1024-bit vector type. + /// Return true if this is a 1024-bit vector type. bool is2048BitVector() const { return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 || SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64); } - /// isOverloaded - Return true if this is an overloaded type for TableGen. + /// Return true if this is an overloaded type for TableGen. bool isOverloaded() const { return (SimpleTy==MVT::Any || SimpleTy==MVT::iAny || SimpleTy==MVT::fAny || SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny); } - /// isPow2VectorType - Returns true if the given vector is a power of 2. + /// Returns true if the given vector is a power of 2. bool isPow2VectorType() const { unsigned NElts = getVectorNumElements(); return !(NElts & (NElts - 1)); } - /// getPow2VectorType - Widens the length of the given vector MVT up to - /// the nearest power of 2 and returns that type. + /// Widens the length of the given vector MVT up to the nearest power of 2 + /// and returns that type. MVT getPow2VectorType() const { if (isPow2VectorType()) return *this; @@ -304,8 +302,7 @@ class MVT { return MVT::getVectorVT(getVectorElementType(), Pow2NElts); } - /// getScalarType - If this is a vector type, return the element type, - /// otherwise return this. + /// If this is a vector, return the element type, otherwise return this. MVT getScalarType() const { return isVector() ? getVectorElementType() : *this; } @@ -516,14 +513,14 @@ class MVT { return getScalarType().getSizeInBits(); } - /// getStoreSize - Return the number of bytes overwritten by a store - /// of the specified value type. + /// Return the number of bytes overwritten by a store of the specified value + /// type. unsigned getStoreSize() const { return (getSizeInBits() + 7) / 8; } - /// getStoreSizeInBits - Return the number of bits overwritten by a store - /// of the specified value type. + /// Return the number of bits overwritten by a store of the specified value + /// type. unsigned getStoreSizeInBits() const { return getStoreSize() * 8; } diff --git a/llvm/include/llvm/CodeGen/ValueTypes.h b/llvm/include/llvm/CodeGen/ValueTypes.h index 2699fa28..0a30636 100644 --- a/llvm/include/llvm/CodeGen/ValueTypes.h +++ b/llvm/include/llvm/CodeGen/ValueTypes.h @@ -25,9 +25,9 @@ namespace llvm { class LLVMContext; class Type; - /// EVT - Extended Value Type. Capable of holding value types which are not - /// native for any processor (such as the i12345 type), as well as the types - /// a MVT can represent. + /// Extended Value Type. Capable of holding value types which are not native + /// for any processor (such as the i12345 type), as well as the types an MVT + /// can represent. struct EVT { private: MVT V; @@ -49,15 +49,15 @@ namespace llvm { return false; } - /// getFloatingPointVT - Returns the EVT that represents a floating point - /// type with the given number of bits. There are two floating point types - /// with 128 bits - this returns f128 rather than ppcf128. + /// Returns the EVT that represents a floating-point type with the given + /// number of bits. There are two floating-point types with 128 bits - this + /// returns f128 rather than ppcf128. static EVT getFloatingPointVT(unsigned BitWidth) { return MVT::getFloatingPointVT(BitWidth); } - /// getIntegerVT - Returns the EVT that represents an integer with the given - /// number of bits. + /// Returns the EVT that represents an integer with the given number of + /// bits. static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) { MVT M = MVT::getIntegerVT(BitWidth); if (M.SimpleTy >= 0) @@ -65,8 +65,8 @@ namespace llvm { return getExtendedIntegerVT(Context, BitWidth); } - /// getVectorVT - Returns the EVT that represents a vector NumElements in - /// length, where each element is of type VT. + /// Returns the EVT that represents a vector NumElements in length, where + /// each element is of type VT. static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements) { MVT M = MVT::getVectorVT(VT.V, NumElements); if (M.SimpleTy >= 0) @@ -74,9 +74,9 @@ namespace llvm { return getExtendedVectorVT(Context, VT, NumElements); } - /// changeVectorElementTypeToInteger - Return a vector with the same number - /// of elements as this vector, but with the element type converted to an - /// integer type with the same bitwidth. + /// Return a vector with the same number of elements as this vector, but + /// with the element type converted to an integer type with the same + /// bitwidth. EVT changeVectorElementTypeToInteger() const { if (!isSimple()) return changeExtendedVectorElementTypeToInteger(); @@ -102,140 +102,136 @@ namespace llvm { return changeExtendedTypeToInteger(); } - /// isSimple - Test if the given EVT is simple (as opposed to being - /// extended). + /// Test if the given EVT is simple (as opposed to being extended). bool isSimple() const { return V.SimpleTy >= 0; } - /// isExtended - Test if the given EVT is extended (as opposed to - /// being simple). + /// Test if the given EVT is extended (as opposed to being simple). bool isExtended() const { return !isSimple(); } - /// isFloatingPoint - Return true if this is a FP, or a vector FP type. + /// Return true if this is a FP or a vector FP type. bool isFloatingPoint() const { return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint(); } - /// isInteger - Return true if this is an integer, or a vector integer type. + /// Return true if this is an integer or a vector integer type. bool isInteger() const { return isSimple() ? V.isInteger() : isExtendedInteger(); } - /// isScalarInteger - Return true if this is an integer, but not a vector. + /// Return true if this is an integer, but not a vector. bool isScalarInteger() const { return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger(); } - /// isVector - Return true if this is a vector value type. + /// Return true if this is a vector value type. bool isVector() const { return isSimple() ? V.isVector() : isExtendedVector(); } - /// is16BitVector - Return true if this is a 16-bit vector type. + /// Return true if this is a 16-bit vector type. bool is16BitVector() const { return isSimple() ? V.is16BitVector() : isExtended16BitVector(); } - /// is32BitVector - Return true if this is a 32-bit vector type. + /// Return true if this is a 32-bit vector type. bool is32BitVector() const { return isSimple() ? V.is32BitVector() : isExtended32BitVector(); } - /// is64BitVector - Return true if this is a 64-bit vector type. + /// Return true if this is a 64-bit vector type. bool is64BitVector() const { return isSimple() ? V.is64BitVector() : isExtended64BitVector(); } - /// is128BitVector - Return true if this is a 128-bit vector type. + /// Return true if this is a 128-bit vector type. bool is128BitVector() const { return isSimple() ? V.is128BitVector() : isExtended128BitVector(); } - /// is256BitVector - Return true if this is a 256-bit vector type. + /// Return true if this is a 256-bit vector type. bool is256BitVector() const { return isSimple() ? V.is256BitVector() : isExtended256BitVector(); } - /// is512BitVector - Return true if this is a 512-bit vector type. + /// Return true if this is a 512-bit vector type. bool is512BitVector() const { return isSimple() ? V.is512BitVector() : isExtended512BitVector(); } - /// is1024BitVector - Return true if this is a 1024-bit vector type. + /// Return true if this is a 1024-bit vector type. bool is1024BitVector() const { return isSimple() ? V.is1024BitVector() : isExtended1024BitVector(); } - /// is2048BitVector - Return true if this is a 2048-bit vector type. + /// Return true if this is a 2048-bit vector type. bool is2048BitVector() const { return isSimple() ? V.is2048BitVector() : isExtended2048BitVector(); } - /// isOverloaded - Return true if this is an overloaded type for TableGen. + /// Return true if this is an overloaded type for TableGen. bool isOverloaded() const { return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny); } - /// isByteSized - Return true if the bit size is a multiple of 8. + /// Return true if the bit size is a multiple of 8. bool isByteSized() const { return (getSizeInBits() & 7) == 0; } - /// isRound - Return true if the size is a power-of-two number of bytes. + /// Return true if the size is a power-of-two number of bytes. bool isRound() const { unsigned BitSize = getSizeInBits(); return BitSize >= 8 && !(BitSize & (BitSize - 1)); } - /// bitsEq - Return true if this has the same number of bits as VT. + /// Return true if this has the same number of bits as VT. bool bitsEq(EVT VT) const { if (EVT::operator==(VT)) return true; return getSizeInBits() == VT.getSizeInBits(); } - /// bitsGT - Return true if this has more bits than VT. + /// Return true if this has more bits than VT. bool bitsGT(EVT VT) const { if (EVT::operator==(VT)) return false; return getSizeInBits() > VT.getSizeInBits(); } - /// bitsGE - Return true if this has no less bits than VT. + /// Return true if this has no less bits than VT. bool bitsGE(EVT VT) const { if (EVT::operator==(VT)) return true; return getSizeInBits() >= VT.getSizeInBits(); } - /// bitsLT - Return true if this has less bits than VT. + /// Return true if this has less bits than VT. bool bitsLT(EVT VT) const { if (EVT::operator==(VT)) return false; return getSizeInBits() < VT.getSizeInBits(); } - /// bitsLE - Return true if this has no more bits than VT. + /// Return true if this has no more bits than VT. bool bitsLE(EVT VT) const { if (EVT::operator==(VT)) return true; return getSizeInBits() <= VT.getSizeInBits(); } - /// getSimpleVT - Return the SimpleValueType held in the specified - /// simple EVT. + /// Return the SimpleValueType held in the specified simple EVT. MVT getSimpleVT() const { assert(isSimple() && "Expected a SimpleValueType!"); return V; } - /// getScalarType - If this is a vector type, return the element type, - /// otherwise return this. + /// If this is a vector type, return the element type, otherwise return + /// this. EVT getScalarType() const { return isVector() ? getVectorElementType() : *this; } - /// getVectorElementType - Given a vector type, return the type of - /// each element. + /// Given a vector type, return the type of each element. EVT getVectorElementType() const { assert(isVector() && "Invalid vector type!"); if (isSimple()) @@ -243,8 +239,7 @@ namespace llvm { return getExtendedVectorElementType(); } - /// getVectorNumElements - Given a vector type, return the number of - /// elements it contains. + /// Given a vector type, return the number of elements it contains. unsigned getVectorNumElements() const { assert(isVector() && "Invalid vector type!"); if (isSimple()) @@ -252,7 +247,7 @@ namespace llvm { return getExtendedVectorNumElements(); } - /// getSizeInBits - Return the size of the specified value type in bits. + /// Return the size of the specified value type in bits. unsigned getSizeInBits() const { if (isSimple()) return V.getSizeInBits(); @@ -263,21 +258,21 @@ namespace llvm { return getScalarType().getSizeInBits(); } - /// getStoreSize - Return the number of bytes overwritten by a store - /// of the specified value type. + /// Return the number of bytes overwritten by a store of the specified value + /// type. unsigned getStoreSize() const { return (getSizeInBits() + 7) / 8; } - /// getStoreSizeInBits - Return the number of bits overwritten by a store - /// of the specified value type. + /// Return the number of bits overwritten by a store of the specified value + /// type. unsigned getStoreSizeInBits() const { return getStoreSize() * 8; } - /// getRoundIntegerType - Rounds the bit-width of the given integer EVT up - /// to the nearest power of two (and at least to eight), and returns the - /// integer EVT with that number of bits. + /// Rounds the bit-width of the given integer EVT up to the nearest power of + /// two (and at least to eight), and returns the integer EVT with that + /// number of bits. EVT getRoundIntegerType(LLVMContext &Context) const { assert(isInteger() && !isVector() && "Invalid integer type!"); unsigned BitWidth = getSizeInBits(); @@ -286,10 +281,9 @@ namespace llvm { return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth)); } - /// getHalfSizedIntegerVT - Finds the smallest simple value type that is - /// greater than or equal to half the width of this EVT. If no simple - /// value type can be found, an extended integer value type of half the - /// size (rounded up) is returned. + /// Finds the smallest simple value type that is greater than or equal to + /// half the width of this EVT. If no simple value type can be found, an + /// extended integer value type of half the size (rounded up) is returned. EVT getHalfSizedIntegerVT(LLVMContext &Context) const { assert(isInteger() && !isVector() && "Invalid integer type!"); unsigned EVTSize = getSizeInBits(); @@ -302,7 +296,7 @@ namespace llvm { return getIntegerVT(Context, (EVTSize + 1) / 2); } - /// \brief Return a VT for an integer vector type with the size of the + /// Return a VT for an integer vector type with the size of the /// elements doubled. The typed returned may be an extended type. EVT widenIntegerVectorElementType(LLVMContext &Context) const { EVT EltVT = getVectorElementType(); @@ -310,14 +304,14 @@ namespace llvm { return EVT::getVectorVT(Context, EltVT, getVectorNumElements()); } - /// isPow2VectorType - Returns true if the given vector is a power of 2. + /// Returns true if the given vector is a power of 2. bool isPow2VectorType() const { unsigned NElts = getVectorNumElements(); return !(NElts & (NElts - 1)); } - /// getPow2VectorType - Widens the length of the given vector EVT up to - /// the nearest power of 2 and returns that type. + /// Widens the length of the given vector EVT up to the nearest power of 2 + /// and returns that type. EVT getPow2VectorType(LLVMContext &Context) const { if (!isPow2VectorType()) { unsigned NElts = getVectorNumElements(); @@ -329,16 +323,15 @@ namespace llvm { } } - /// getEVTString - This function returns value type as a string, - /// e.g. "i32". + /// This function returns value type as a string, e.g. "i32". std::string getEVTString() const; - /// getTypeForEVT - This method returns an LLVM type corresponding to the - /// specified EVT. For integer types, this returns an unsigned type. Note - /// that this will abort for types that cannot be represented. + /// This method returns an LLVM type corresponding to the specified EVT. + /// For integer types, this returns an unsigned type. Note that this will + /// abort for types that cannot be represented. Type *getTypeForEVT(LLVMContext &Context) const; - /// getEVT - Return the value type corresponding to the specified type. + /// Return the value type corresponding to the specified type. /// This returns all pointers as iPTR. If HandleUnknown is true, unknown /// types are returned as Other, otherwise they are invalid. static EVT getEVT(Type *Ty, bool HandleUnknown = false); @@ -350,8 +343,8 @@ namespace llvm { return (intptr_t)(LLVMTy); } - /// compareRawBits - A meaningless but well-behaved order, useful for - /// constructing containers. + /// A meaningless but well-behaved order, useful for constructing + /// containers. struct compareRawBits { bool operator()(EVT L, EVT R) const { if (L.V.SimpleTy == R.V.SimpleTy) -- 2.7.4