[llvm] r203926 - Separate out MVT in a separate header file: MachineValueType.h
Patrik Hagglund
patrik.h.hagglund at ericsson.com
Fri Mar 14 06:41:10 PDT 2014
Author: patha
Date: Fri Mar 14 08:41:09 2014
New Revision: 203926
URL: http://llvm.org/viewvc/llvm-project?rev=203926&view=rev
Log:
Separate out MVT in a separate header file: MachineValueType.h
The idea behind this split of ValueTypes.h, is to make it easier to
ensure that stuff after type legalization only use MVT (rather than
EVT), by watching include dependencies.
Reviewed By: Tim Northover
Added:
llvm/trunk/include/llvm/CodeGen/MachineValueType.h
- copied, changed from r203921, llvm/trunk/include/llvm/CodeGen/ValueTypes.h
Modified:
llvm/trunk/include/llvm/CodeGen/ValueTypes.h
Copied: llvm/trunk/include/llvm/CodeGen/MachineValueType.h (from r203921, llvm/trunk/include/llvm/CodeGen/ValueTypes.h)
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineValueType.h?p2=llvm/trunk/include/llvm/CodeGen/MachineValueType.h&p1=llvm/trunk/include/llvm/CodeGen/ValueTypes.h&r1=203921&r2=203926&rev=203926&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/ValueTypes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineValueType.h Fri Mar 14 08:41:09 2014
@@ -1,4 +1,4 @@
-//===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- C++ -*-===//
+//===- CodeGen/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -7,25 +7,19 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines the set of low-level target independent types which various
-// values in the code generator are. This allows the target specific behavior
-// of instructions to be described to target independent passes.
+// This file defines the set of machine-level target independent types which
+// legal values in the code generator use.
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_CODEGEN_VALUETYPES_H
-#define LLVM_CODEGEN_VALUETYPES_H
+#ifndef LLVM_CODEGEN_MACHINEVALUETYPE_H
+#define LLVM_CODEGEN_MACHINEVALUETYPE_H
-#include "llvm/Support/DataTypes.h"
#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/MathExtras.h"
-#include <cassert>
-#include <string>
namespace llvm {
+
class Type;
- class LLVMContext;
- struct EVT;
/// MVT - Machine Value Type. Every type that is supported natively by some
/// processor targeted by LLVM occurs here. This means that any legal value
@@ -579,336 +573,6 @@ namespace llvm {
};
-
- /// 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.
- struct EVT {
- private:
- MVT V;
- Type *LLVMTy;
-
- public:
- EVT() : V((MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE)),
- LLVMTy(0) {}
- EVT(MVT::SimpleValueType SVT) : V(SVT), LLVMTy(0) { }
- EVT(MVT S) : V(S), LLVMTy(0) {}
-
- bool operator==(EVT VT) const {
- return !(*this != VT);
- }
- bool operator!=(EVT VT) const {
- if (V.SimpleTy != VT.V.SimpleTy)
- return true;
- if (V.SimpleTy < 0)
- return LLVMTy != VT.LLVMTy;
- 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.
- static EVT getFloatingPointVT(unsigned BitWidth) {
- return MVT::getFloatingPointVT(BitWidth);
- }
-
- /// getIntegerVT - 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)
- return M;
- return getExtendedIntegerVT(Context, BitWidth);
- }
-
- /// getVectorVT - 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)
- return M;
- 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.
- EVT changeVectorElementTypeToInteger() const {
- if (!isSimple())
- return changeExtendedVectorElementTypeToInteger();
- MVT EltTy = getSimpleVT().getVectorElementType();
- unsigned BitWidth = EltTy.getSizeInBits();
- MVT IntTy = MVT::getIntegerVT(BitWidth);
- MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements());
- assert(VecTy.SimpleTy >= 0 &&
- "Simple vector VT not representable by simple integer vector VT!");
- return VecTy;
- }
-
- /// isSimple - 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).
- bool isExtended() const {
- return !isSimple();
- }
-
- /// isFloatingPoint - 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.
- bool isInteger() const {
- return isSimple() ? V.isInteger() : isExtendedInteger();
- }
-
- /// isVector - 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.
- bool is16BitVector() const {
- return isSimple() ? V.is16BitVector() : isExtended16BitVector();
- }
-
- /// is32BitVector - 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.
- bool is64BitVector() const {
- return isSimple() ? V.is64BitVector() : isExtended64BitVector();
- }
-
- /// is128BitVector - 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.
- bool is256BitVector() const {
- return isSimple() ? V.is256BitVector() : isExtended256BitVector();
- }
-
- /// is512BitVector - 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.
- bool is1024BitVector() const {
- return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
- }
-
- /// isOverloaded - 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.
- bool isByteSized() const {
- return (getSizeInBits() & 7) == 0;
- }
-
- /// isRound - 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- MVT getSimpleVT() const {
- assert(isSimple() && "Expected a SimpleValueType!");
- return V;
- }
-
- /// getScalarType - 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.
- EVT getVectorElementType() const {
- assert(isVector() && "Invalid vector type!");
- if (isSimple())
- return V.getVectorElementType();
- return getExtendedVectorElementType();
- }
-
- /// getVectorNumElements - Given a vector type, return the number of
- /// elements it contains.
- unsigned getVectorNumElements() const {
- assert(isVector() && "Invalid vector type!");
- if (isSimple())
- return V.getVectorNumElements();
- return getExtendedVectorNumElements();
- }
-
- /// getSizeInBits - Return the size of the specified value type in bits.
- unsigned getSizeInBits() const {
- if (isSimple())
- return V.getSizeInBits();
- return getExtendedSizeInBits();
- }
-
- unsigned getScalarSizeInBits() const {
- return getScalarType().getSizeInBits();
- }
-
- /// getStoreSize - 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.
- 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.
- EVT getRoundIntegerType(LLVMContext &Context) const {
- assert(isInteger() && !isVector() && "Invalid integer type!");
- unsigned BitWidth = getSizeInBits();
- if (BitWidth <= 8)
- return EVT(MVT::i8);
- 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.
- EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
- assert(isInteger() && !isVector() && "Invalid integer type!");
- unsigned EVTSize = getSizeInBits();
- for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
- IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
- EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
- if (HalfVT.getSizeInBits() * 2 >= EVTSize)
- return HalfVT;
- }
- return getIntegerVT(Context, (EVTSize + 1) / 2);
- }
-
- /// isPow2VectorType - 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.
- EVT getPow2VectorType(LLVMContext &Context) const {
- if (!isPow2VectorType()) {
- unsigned NElts = getVectorNumElements();
- unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
- return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts);
- }
- else {
- return *this;
- }
- }
-
- /// getEVTString - 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.
- Type *getTypeForEVT(LLVMContext &Context) const;
-
- /// getEVT - 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);
-
- intptr_t getRawBits() const {
- if (isSimple())
- return V.SimpleTy;
- else
- return (intptr_t)(LLVMTy);
- }
-
- /// compareRawBits - 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)
- return L.LLVMTy < R.LLVMTy;
- else
- return L.V.SimpleTy < R.V.SimpleTy;
- }
- };
-
- private:
- // Methods for handling the Extended-type case in functions above.
- // These are all out-of-line to prevent users of this header file
- // from having a dependency on Type.h.
- EVT changeExtendedVectorElementTypeToInteger() const;
- static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
- static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
- unsigned NumElements);
- bool isExtendedFloatingPoint() const LLVM_READONLY;
- bool isExtendedInteger() const LLVM_READONLY;
- bool isExtendedVector() const LLVM_READONLY;
- bool isExtended16BitVector() const LLVM_READONLY;
- bool isExtended32BitVector() const LLVM_READONLY;
- bool isExtended64BitVector() const LLVM_READONLY;
- bool isExtended128BitVector() const LLVM_READONLY;
- bool isExtended256BitVector() const LLVM_READONLY;
- bool isExtended512BitVector() const LLVM_READONLY;
- bool isExtended1024BitVector() const LLVM_READONLY;
- EVT getExtendedVectorElementType() const;
- unsigned getExtendedVectorNumElements() const LLVM_READONLY;
- unsigned getExtendedSizeInBits() const;
- };
-
} // End llvm namespace
#endif
Modified: llvm/trunk/include/llvm/CodeGen/ValueTypes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/ValueTypes.h?rev=203926&r1=203925&r2=203926&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/ValueTypes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/ValueTypes.h Fri Mar 14 08:41:09 2014
@@ -16,569 +16,14 @@
#ifndef LLVM_CODEGEN_VALUETYPES_H
#define LLVM_CODEGEN_VALUETYPES_H
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/MathExtras.h"
+#include "llvm/CodeGen/MachineValueType.h"
#include <cassert>
#include <string>
namespace llvm {
- class Type;
- class LLVMContext;
- struct EVT;
-
- /// MVT - 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 {
- // INVALID_SIMPLE_VALUE_TYPE - 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
- // ValueTypes.td as well!
- Other = 0, // This is a non-standard value
- i1 = 1, // This is a 1 bit integer value
- i8 = 2, // This is an 8 bit integer value
- i16 = 3, // This is a 16 bit integer value
- i32 = 4, // This is a 32 bit integer value
- i64 = 5, // This is a 64 bit integer value
- i128 = 6, // This is a 128 bit integer value
-
- FIRST_INTEGER_VALUETYPE = i1,
- LAST_INTEGER_VALUETYPE = i128,
-
- f16 = 7, // This is a 16 bit floating point value
- f32 = 8, // This is a 32 bit floating point value
- f64 = 9, // This is a 64 bit floating point value
- f80 = 10, // This is a 80 bit floating point value
- f128 = 11, // This is a 128 bit floating point value
- ppcf128 = 12, // This is a PPC 128-bit floating point value
-
- FIRST_FP_VALUETYPE = f16,
- LAST_FP_VALUETYPE = ppcf128,
-
- v2i1 = 13, // 2 x i1
- v4i1 = 14, // 4 x i1
- v8i1 = 15, // 8 x i1
- v16i1 = 16, // 16 x i1
- v32i1 = 17, // 32 x i1
- v64i1 = 18, // 64 x i1
-
- v1i8 = 19, // 1 x i8
- v2i8 = 20, // 2 x i8
- v4i8 = 21, // 4 x i8
- v8i8 = 22, // 8 x i8
- v16i8 = 23, // 16 x i8
- v32i8 = 24, // 32 x i8
- v64i8 = 25, // 64 x i8
- v1i16 = 26, // 1 x i16
- v2i16 = 27, // 2 x i16
- v4i16 = 28, // 4 x i16
- v8i16 = 29, // 8 x i16
- v16i16 = 30, // 16 x i16
- v32i16 = 31, // 32 x i16
- v1i32 = 32, // 1 x i32
- v2i32 = 33, // 2 x i32
- v4i32 = 34, // 4 x i32
- v8i32 = 35, // 8 x i32
- v16i32 = 36, // 16 x i32
- v1i64 = 37, // 1 x i64
- v2i64 = 38, // 2 x i64
- v4i64 = 39, // 4 x i64
- v8i64 = 40, // 8 x i64
- v16i64 = 41, // 16 x i64
-
- FIRST_INTEGER_VECTOR_VALUETYPE = v2i1,
- LAST_INTEGER_VECTOR_VALUETYPE = v16i64,
-
- v2f16 = 42, // 2 x f16
- v4f16 = 43, // 4 x f16
- v8f16 = 44, // 8 x f16
- v1f32 = 45, // 1 x f32
- v2f32 = 46, // 2 x f32
- v4f32 = 47, // 4 x f32
- v8f32 = 48, // 8 x f32
- v16f32 = 49, // 16 x f32
- v1f64 = 50, // 1 x f64
- v2f64 = 51, // 2 x f64
- v4f64 = 52, // 4 x f64
- v8f64 = 53, // 8 x f64
-
- FIRST_FP_VECTOR_VALUETYPE = v2f16,
- LAST_FP_VECTOR_VALUETYPE = v8f64,
-
- FIRST_VECTOR_VALUETYPE = v2i1,
- LAST_VECTOR_VALUETYPE = v8f64,
-
- x86mmx = 54, // This is an X86 MMX value
-
- Glue = 55, // This glues nodes together during pre-RA sched
-
- isVoid = 56, // This has no value
-
- Untyped = 57, // This value takes a register, but has
- // unspecified type. The register class
- // will be determined by the opcode.
-
- LAST_VALUETYPE = 58, // This always remains at the end of the list.
-
- // This is the current maximum for LAST_VALUETYPE.
- // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
- // This value must be a multiple of 32.
- MAX_ALLOWED_VALUETYPE = 64,
-
- // Metadata - This is MDNode or MDString.
- Metadata = 250,
-
- // iPTRAny - 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 = 251,
-
- // vAny - 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 = 252,
-
- // fAny - 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 = 253,
-
- // iAny - 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 = 254,
-
- // iPTR - An int value the size of the pointer of the current
- // target. This should only be used internal to tblgen!
- iPTR = 255
- };
-
- SimpleValueType SimpleTy;
-
- MVT() : SimpleTy((SimpleValueType)(INVALID_SIMPLE_VALUE_TYPE)) {}
- MVT(SimpleValueType SVT) : SimpleTy(SVT) { }
-
- bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; }
- bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; }
- bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
- bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
- bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
- bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
-
- /// isFloatingPoint - 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) ||
- (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE &&
- SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE));
- }
-
- /// isInteger - 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) ||
- (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE &&
- SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE));
- }
-
- /// isVector - 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.
- bool is16BitVector() const {
- return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 ||
- SimpleTy == MVT::v16i1);
- }
-
- /// is32BitVector - Return true if this is a 32-bit vector type.
- bool is32BitVector() const {
- return (SimpleTy == MVT::v4i8 || SimpleTy == MVT::v2i16 ||
- SimpleTy == MVT::v1i32);
- }
-
- /// is64BitVector - Return true if this is a 64-bit vector type.
- bool is64BitVector() const {
- return (SimpleTy == MVT::v8i8 || SimpleTy == MVT::v4i16 ||
- SimpleTy == MVT::v2i32 || SimpleTy == MVT::v1i64 ||
- SimpleTy == MVT::v1f64 || SimpleTy == MVT::v2f32);
- }
-
- /// is128BitVector - 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 ||
- SimpleTy == MVT::v4f32 || SimpleTy == MVT::v2f64);
- }
-
- /// is256BitVector - 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.
- bool is512BitVector() const {
- return (SimpleTy == MVT::v8f64 || SimpleTy == MVT::v16f32 ||
- SimpleTy == MVT::v64i8 || SimpleTy == MVT::v32i16 ||
- SimpleTy == MVT::v8i64 || SimpleTy == MVT::v16i32);
- }
-
- /// is1024BitVector - Return true if this is a 1024-bit vector type.
- bool is1024BitVector() const {
- return (SimpleTy == MVT::v16i64);
- }
-
- /// isOverloaded - Return true if this is an overloaded type for TableGen.
- bool isOverloaded() const {
- return (SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
- SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
- }
-
- /// isPow2VectorType - 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.
- MVT getPow2VectorType() const {
- if (isPow2VectorType())
- return *this;
-
- unsigned NElts = getVectorNumElements();
- unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
- return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
- }
-
- /// getScalarType - If this is a vector type, return the element type,
- /// otherwise return this.
- MVT getScalarType() const {
- return isVector() ? getVectorElementType() : *this;
- }
-
- MVT getVectorElementType() const {
- switch (SimpleTy) {
- default:
- llvm_unreachable("Not a vector MVT!");
- case v2i1 :
- case v4i1 :
- case v8i1 :
- case v16i1 :
- case v32i1 :
- case v64i1: return i1;
- case v1i8 :
- case v2i8 :
- case v4i8 :
- case v8i8 :
- case v16i8:
- case v32i8:
- case v64i8: return i8;
- case v1i16:
- case v2i16:
- case v4i16:
- case v8i16:
- case v16i16:
- case v32i16: return i16;
- case v1i32:
- case v2i32:
- case v4i32:
- case v8i32:
- case v16i32: return i32;
- case v1i64:
- case v2i64:
- case v4i64:
- case v8i64:
- case v16i64: return i64;
- case v2f16:
- case v4f16:
- case v8f16: return f16;
- case v1f32:
- case v2f32:
- case v4f32:
- case v8f32:
- case v16f32: return f32;
- case v1f64:
- case v2f64:
- case v4f64:
- case v8f64: return f64;
- }
- }
-
- unsigned getVectorNumElements() const {
- switch (SimpleTy) {
- default:
- llvm_unreachable("Not a vector MVT!");
- case v32i1:
- case v32i8:
- case v32i16: return 32;
- case v64i1:
- case v64i8: return 64;
- case v16i1:
- case v16i8:
- case v16i16:
- case v16i32:
- case v16i64:
- case v16f32: return 16;
- case v8i1 :
- case v8i8 :
- case v8i16:
- case v8i32:
- case v8i64:
- case v8f16:
- case v8f32:
- case v8f64: return 8;
- case v4i1:
- case v4i8:
- case v4i16:
- case v4i32:
- case v4i64:
- case v4f16:
- case v4f32:
- case v4f64: return 4;
- case v2i1:
- case v2i8:
- case v2i16:
- case v2i32:
- case v2i64:
- case v2f16:
- case v2f32:
- case v2f64: return 2;
- case v1i8:
- case v1i16:
- case v1i32:
- case v1i64:
- case v1f32:
- case v1f64: return 1;
- }
- }
-
- unsigned getSizeInBits() const {
- switch (SimpleTy) {
- default:
- llvm_unreachable("getSizeInBits called on extended MVT.");
- case Other:
- llvm_unreachable("Value type is non-standard value, Other.");
- case iPTR:
- llvm_unreachable("Value type size is target-dependent. Ask TLI.");
- case iPTRAny:
- case iAny:
- case fAny:
- case vAny:
- llvm_unreachable("Value type is overloaded.");
- case Metadata:
- llvm_unreachable("Value type is metadata.");
- case i1 : return 1;
- case v2i1: return 2;
- case v4i1: return 4;
- case i8 :
- case v1i8:
- case v8i1: return 8;
- case i16 :
- case f16:
- case v16i1:
- case v2i8:
- case v1i16: return 16;
- case f32 :
- case i32 :
- case v32i1:
- case v4i8:
- case v2i16:
- case v2f16:
- case v1f32:
- case v1i32: return 32;
- case x86mmx:
- case f64 :
- case i64 :
- case v64i1:
- case v8i8:
- case v4i16:
- case v2i32:
- case v1i64:
- case v4f16:
- case v2f32:
- case v1f64: return 64;
- case f80 : return 80;
- case f128:
- case ppcf128:
- case i128:
- case v16i8:
- case v8i16:
- case v4i32:
- case v2i64:
- case v8f16:
- case v4f32:
- case v2f64: return 128;
- case v32i8:
- case v16i16:
- case v8i32:
- case v4i64:
- case v8f32:
- case v4f64: return 256;
- case v64i8:
- case v32i16:
- case v16i32:
- case v8i64:
- case v16f32:
- case v8f64: return 512;
- case v16i64:return 1024;
- }
- }
-
- unsigned getScalarSizeInBits() const {
- return getScalarType().getSizeInBits();
- }
-
- /// getStoreSize - 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.
- unsigned getStoreSizeInBits() const {
- return getStoreSize() * 8;
- }
-
- /// Return true if this has more bits than VT.
- bool bitsGT(MVT VT) const {
- return getSizeInBits() > VT.getSizeInBits();
- }
-
- /// Return true if this has no less bits than VT.
- bool bitsGE(MVT VT) const {
- return getSizeInBits() >= VT.getSizeInBits();
- }
-
- /// Return true if this has less bits than VT.
- bool bitsLT(MVT VT) const {
- return getSizeInBits() < VT.getSizeInBits();
- }
-
- /// Return true if this has no more bits than VT.
- bool bitsLE(MVT VT) const {
- return getSizeInBits() <= VT.getSizeInBits();
- }
-
-
- static MVT getFloatingPointVT(unsigned BitWidth) {
- switch (BitWidth) {
- default:
- llvm_unreachable("Bad bit width!");
- case 16:
- return MVT::f16;
- case 32:
- return MVT::f32;
- case 64:
- return MVT::f64;
- case 80:
- return MVT::f80;
- case 128:
- return MVT::f128;
- }
- }
-
- static MVT getIntegerVT(unsigned BitWidth) {
- switch (BitWidth) {
- default:
- return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
- case 1:
- return MVT::i1;
- case 8:
- return MVT::i8;
- case 16:
- return MVT::i16;
- case 32:
- return MVT::i32;
- case 64:
- return MVT::i64;
- case 128:
- return MVT::i128;
- }
- }
-
- static MVT getVectorVT(MVT VT, unsigned NumElements) {
- switch (VT.SimpleTy) {
- default:
- break;
- case MVT::i1:
- if (NumElements == 2) return MVT::v2i1;
- if (NumElements == 4) return MVT::v4i1;
- if (NumElements == 8) return MVT::v8i1;
- if (NumElements == 16) return MVT::v16i1;
- if (NumElements == 32) return MVT::v32i1;
- if (NumElements == 64) return MVT::v64i1;
- break;
- case MVT::i8:
- if (NumElements == 1) return MVT::v1i8;
- if (NumElements == 2) return MVT::v2i8;
- if (NumElements == 4) return MVT::v4i8;
- if (NumElements == 8) return MVT::v8i8;
- if (NumElements == 16) return MVT::v16i8;
- if (NumElements == 32) return MVT::v32i8;
- if (NumElements == 64) return MVT::v64i8;
- break;
- case MVT::i16:
- if (NumElements == 1) return MVT::v1i16;
- if (NumElements == 2) return MVT::v2i16;
- if (NumElements == 4) return MVT::v4i16;
- if (NumElements == 8) return MVT::v8i16;
- if (NumElements == 16) return MVT::v16i16;
- if (NumElements == 32) return MVT::v32i16;
- break;
- case MVT::i32:
- if (NumElements == 1) return MVT::v1i32;
- if (NumElements == 2) return MVT::v2i32;
- if (NumElements == 4) return MVT::v4i32;
- if (NumElements == 8) return MVT::v8i32;
- if (NumElements == 16) return MVT::v16i32;
- break;
- case MVT::i64:
- if (NumElements == 1) return MVT::v1i64;
- if (NumElements == 2) return MVT::v2i64;
- if (NumElements == 4) return MVT::v4i64;
- if (NumElements == 8) return MVT::v8i64;
- if (NumElements == 16) return MVT::v16i64;
- break;
- case MVT::f16:
- if (NumElements == 2) return MVT::v2f16;
- if (NumElements == 4) return MVT::v4f16;
- if (NumElements == 8) return MVT::v8f16;
- break;
- case MVT::f32:
- if (NumElements == 1) return MVT::v1f32;
- if (NumElements == 2) return MVT::v2f32;
- if (NumElements == 4) return MVT::v4f32;
- if (NumElements == 8) return MVT::v8f32;
- if (NumElements == 16) return MVT::v16f32;
- break;
- case MVT::f64:
- if (NumElements == 1) return MVT::v1f64;
- if (NumElements == 2) return MVT::v2f64;
- if (NumElements == 4) return MVT::v4f64;
- if (NumElements == 8) return MVT::v8f64;
- break;
- }
- return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_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 MVT getVT(Type *Ty, bool HandleUnknown = false);
-
- };
+ 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
More information about the llvm-commits
mailing list