1 //===- CodeGen/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the set of machine-level target independent types which
11 // legal values in the code generator use.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CODEGEN_MACHINEVALUETYPE_H
16 #define LLVM_CODEGEN_MACHINEVALUETYPE_H
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/MathExtras.h"
26 /// MVT - Machine Value Type. Every type that is supported natively by some
27 /// processor targeted by LLVM occurs here. This means that any legal value
28 /// type can be represented by an MVT.
31 enum SimpleValueType
{
32 // INVALID_SIMPLE_VALUE_TYPE - Simple value types less than zero are
33 // considered extended value types.
34 INVALID_SIMPLE_VALUE_TYPE
= -1,
36 // If you change this numbering, you must change the values in
37 // ValueTypes.td as well!
38 Other
= 0, // This is a non-standard value
39 i1
= 1, // This is a 1 bit integer value
40 i8
= 2, // This is an 8 bit integer value
41 i16
= 3, // This is a 16 bit integer value
42 i32
= 4, // This is a 32 bit integer value
43 i64
= 5, // This is a 64 bit integer value
44 i128
= 6, // This is a 128 bit integer value
46 FIRST_INTEGER_VALUETYPE
= i1
,
47 LAST_INTEGER_VALUETYPE
= i128
,
49 f16
= 7, // This is a 16 bit floating point value
50 f32
= 8, // This is a 32 bit floating point value
51 f64
= 9, // This is a 64 bit floating point value
52 f80
= 10, // This is a 80 bit floating point value
53 f128
= 11, // This is a 128 bit floating point value
54 ppcf128
= 12, // This is a PPC 128-bit floating point value
56 FIRST_FP_VALUETYPE
= f16
,
57 LAST_FP_VALUETYPE
= ppcf128
,
62 v16i1
= 16, // 16 x i1
63 v32i1
= 17, // 32 x i1
64 v64i1
= 18, // 64 x i1
70 v16i8
= 23, // 16 x i8
71 v32i8
= 24, // 32 x i8
72 v64i8
= 25, // 64 x i8
73 v1i16
= 26, // 1 x i16
74 v2i16
= 27, // 2 x i16
75 v4i16
= 28, // 4 x i16
76 v8i16
= 29, // 8 x i16
77 v16i16
= 30, // 16 x i16
78 v32i16
= 31, // 32 x i16
79 v1i32
= 32, // 1 x i32
80 v2i32
= 33, // 2 x i32
81 v4i32
= 34, // 4 x i32
82 v8i32
= 35, // 8 x i32
83 v16i32
= 36, // 16 x i32
84 v1i64
= 37, // 1 x i64
85 v2i64
= 38, // 2 x i64
86 v4i64
= 39, // 4 x i64
87 v8i64
= 40, // 8 x i64
88 v16i64
= 41, // 16 x i64
90 FIRST_INTEGER_VECTOR_VALUETYPE
= v2i1
,
91 LAST_INTEGER_VECTOR_VALUETYPE
= v16i64
,
93 v2f16
= 42, // 2 x f16
94 v4f16
= 43, // 4 x f16
95 v8f16
= 44, // 8 x f16
96 v1f32
= 45, // 1 x f32
97 v2f32
= 46, // 2 x f32
98 v4f32
= 47, // 4 x f32
99 v8f32
= 48, // 8 x f32
100 v16f32
= 49, // 16 x f32
101 v1f64
= 50, // 1 x f64
102 v2f64
= 51, // 2 x f64
103 v4f64
= 52, // 4 x f64
104 v8f64
= 53, // 8 x f64
106 FIRST_FP_VECTOR_VALUETYPE
= v2f16
,
107 LAST_FP_VECTOR_VALUETYPE
= v8f64
,
109 FIRST_VECTOR_VALUETYPE
= v2i1
,
110 LAST_VECTOR_VALUETYPE
= v8f64
,
112 x86mmx
= 54, // This is an X86 MMX value
114 Glue
= 55, // This glues nodes together during pre-RA sched
116 isVoid
= 56, // This has no value
118 Untyped
= 57, // This value takes a register, but has
119 // unspecified type. The register class
120 // will be determined by the opcode.
122 FIRST_VALUETYPE
= 0, // This is always the beginning of the list.
123 LAST_VALUETYPE
= 58, // This always remains at the end of the list.
125 // This is the current maximum for LAST_VALUETYPE.
126 // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
127 // This value must be a multiple of 32.
128 MAX_ALLOWED_VALUETYPE
= 64,
130 // Metadata - This is MDNode or MDString.
133 // iPTRAny - An int value the size of the pointer of the current
134 // target to any address space. This must only be used internal to
135 // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
138 // vAny - A vector with any length and element size. This is used
139 // for intrinsics that have overloadings based on vector types.
140 // This is only for tblgen's consumption!
143 // fAny - Any floating-point or vector floating-point value. This is used
144 // for intrinsics that have overloadings based on floating-point types.
145 // This is only for tblgen's consumption!
148 // iAny - An integer or vector integer value of any bit width. This is
149 // used for intrinsics that have overloadings based on integer bit widths.
150 // This is only for tblgen's consumption!
153 // iPTR - An int value the size of the pointer of the current
154 // target. This should only be used internal to tblgen!
158 SimpleValueType SimpleTy
;
160 MVT() : SimpleTy((SimpleValueType
)(INVALID_SIMPLE_VALUE_TYPE
)) {}
161 MVT(SimpleValueType SVT
) : SimpleTy(SVT
) { }
163 bool operator>(const MVT
& S
) const { return SimpleTy
> S
.SimpleTy
; }
164 bool operator<(const MVT
& S
) const { return SimpleTy
< S
.SimpleTy
; }
165 bool operator==(const MVT
& S
) const { return SimpleTy
== S
.SimpleTy
; }
166 bool operator!=(const MVT
& S
) const { return SimpleTy
!= S
.SimpleTy
; }
167 bool operator>=(const MVT
& S
) const { return SimpleTy
>= S
.SimpleTy
; }
168 bool operator<=(const MVT
& S
) const { return SimpleTy
<= S
.SimpleTy
; }
170 /// isValid - Return true if this is a valid simple valuetype.
171 bool isValid() const {
172 return (SimpleTy
>= MVT::FIRST_VALUETYPE
&&
173 SimpleTy
< MVT::LAST_VALUETYPE
);
176 /// isFloatingPoint - Return true if this is a FP, or a vector FP type.
177 bool isFloatingPoint() const {
178 return ((SimpleTy
>= MVT::FIRST_FP_VALUETYPE
&&
179 SimpleTy
<= MVT::LAST_FP_VALUETYPE
) ||
180 (SimpleTy
>= MVT::FIRST_FP_VECTOR_VALUETYPE
&&
181 SimpleTy
<= MVT::LAST_FP_VECTOR_VALUETYPE
));
184 /// isInteger - Return true if this is an integer, or a vector integer type.
185 bool isInteger() const {
186 return ((SimpleTy
>= MVT::FIRST_INTEGER_VALUETYPE
&&
187 SimpleTy
<= MVT::LAST_INTEGER_VALUETYPE
) ||
188 (SimpleTy
>= MVT::FIRST_INTEGER_VECTOR_VALUETYPE
&&
189 SimpleTy
<= MVT::LAST_INTEGER_VECTOR_VALUETYPE
));
192 /// isVector - Return true if this is a vector value type.
193 bool isVector() const {
194 return (SimpleTy
>= MVT::FIRST_VECTOR_VALUETYPE
&&
195 SimpleTy
<= MVT::LAST_VECTOR_VALUETYPE
);
198 /// is16BitVector - Return true if this is a 16-bit vector type.
199 bool is16BitVector() const {
200 return (SimpleTy
== MVT::v2i8
|| SimpleTy
== MVT::v1i16
||
201 SimpleTy
== MVT::v16i1
);
204 /// is32BitVector - Return true if this is a 32-bit vector type.
205 bool is32BitVector() const {
206 return (SimpleTy
== MVT::v4i8
|| SimpleTy
== MVT::v2i16
||
207 SimpleTy
== MVT::v1i32
|| SimpleTy
== MVT::v2f16
||
208 SimpleTy
== MVT::v1f32
);
211 /// is64BitVector - Return true if this is a 64-bit vector type.
212 bool is64BitVector() const {
213 return (SimpleTy
== MVT::v8i8
|| SimpleTy
== MVT::v4i16
||
214 SimpleTy
== MVT::v2i32
|| SimpleTy
== MVT::v1i64
||
215 SimpleTy
== MVT::v4f16
|| SimpleTy
== MVT::v2f32
||
216 SimpleTy
== MVT::v1f64
);
219 /// is128BitVector - Return true if this is a 128-bit vector type.
220 bool is128BitVector() const {
221 return (SimpleTy
== MVT::v16i8
|| SimpleTy
== MVT::v8i16
||
222 SimpleTy
== MVT::v4i32
|| SimpleTy
== MVT::v2i64
||
223 SimpleTy
== MVT::v8f16
|| SimpleTy
== MVT::v4f32
||
224 SimpleTy
== MVT::v2f64
);
227 /// is256BitVector - Return true if this is a 256-bit vector type.
228 bool is256BitVector() const {
229 return (SimpleTy
== MVT::v8f32
|| SimpleTy
== MVT::v4f64
||
230 SimpleTy
== MVT::v32i8
|| SimpleTy
== MVT::v16i16
||
231 SimpleTy
== MVT::v8i32
|| SimpleTy
== MVT::v4i64
);
234 /// is512BitVector - Return true if this is a 512-bit vector type.
235 bool is512BitVector() const {
236 return (SimpleTy
== MVT::v8f64
|| SimpleTy
== MVT::v16f32
||
237 SimpleTy
== MVT::v64i8
|| SimpleTy
== MVT::v32i16
||
238 SimpleTy
== MVT::v8i64
|| SimpleTy
== MVT::v16i32
);
241 /// is1024BitVector - Return true if this is a 1024-bit vector type.
242 bool is1024BitVector() const {
243 return (SimpleTy
== MVT::v16i64
);
246 /// isOverloaded - Return true if this is an overloaded type for TableGen.
247 bool isOverloaded() const {
248 return (SimpleTy
==MVT::iAny
|| SimpleTy
==MVT::fAny
||
249 SimpleTy
==MVT::vAny
|| SimpleTy
==MVT::iPTRAny
);
252 /// isPow2VectorType - Returns true if the given vector is a power of 2.
253 bool isPow2VectorType() const {
254 unsigned NElts
= getVectorNumElements();
255 return !(NElts
& (NElts
- 1));
258 /// getPow2VectorType - Widens the length of the given vector MVT up to
259 /// the nearest power of 2 and returns that type.
260 MVT
getPow2VectorType() const {
261 if (isPow2VectorType())
264 unsigned NElts
= getVectorNumElements();
265 unsigned Pow2NElts
= 1 << Log2_32_Ceil(NElts
);
266 return MVT::getVectorVT(getVectorElementType(), Pow2NElts
);
269 /// getScalarType - If this is a vector type, return the element type,
270 /// otherwise return this.
271 MVT
getScalarType() const {
272 return isVector() ? getVectorElementType() : *this;
275 MVT
getVectorElementType() const {
278 llvm_unreachable("Not a vector MVT!");
284 case v64i1
: return i1
;
291 case v64i8
: return i8
;
297 case v32i16
: return i16
;
302 case v16i32
: return i32
;
307 case v16i64
: return i64
;
310 case v8f16
: return f16
;
315 case v16f32
: return f32
;
319 case v8f64
: return f64
;
323 unsigned getVectorNumElements() const {
326 llvm_unreachable("Not a vector MVT!");
329 case v32i16
: return 32;
331 case v64i8
: return 64;
337 case v16f32
: return 16;
345 case v8f64
: return 8;
353 case v4f64
: return 4;
361 case v2f64
: return 2;
367 case v1f64
: return 1;
371 unsigned getSizeInBits() const {
374 llvm_unreachable("getSizeInBits called on extended MVT.");
376 llvm_unreachable("Value type is non-standard value, Other.");
378 llvm_unreachable("Value type size is target-dependent. Ask TLI.");
383 llvm_unreachable("Value type is overloaded.");
385 llvm_unreachable("Value type is metadata.");
396 case v1i16
: return 16;
404 case v1i32
: return 32;
415 case v1f64
: return 64;
416 case f80
: return 80;
426 case v2f64
: return 128;
432 case v4f64
: return 256;
438 case v8f64
: return 512;
439 case v16i64
:return 1024;
443 unsigned getScalarSizeInBits() const {
444 return getScalarType().getSizeInBits();
447 /// getStoreSize - Return the number of bytes overwritten by a store
448 /// of the specified value type.
449 unsigned getStoreSize() const {
450 return (getSizeInBits() + 7) / 8;
453 /// getStoreSizeInBits - Return the number of bits overwritten by a store
454 /// of the specified value type.
455 unsigned getStoreSizeInBits() const {
456 return getStoreSize() * 8;
459 /// Return true if this has more bits than VT.
460 bool bitsGT(MVT VT
) const {
461 return getSizeInBits() > VT
.getSizeInBits();
464 /// Return true if this has no less bits than VT.
465 bool bitsGE(MVT VT
) const {
466 return getSizeInBits() >= VT
.getSizeInBits();
469 /// Return true if this has less bits than VT.
470 bool bitsLT(MVT VT
) const {
471 return getSizeInBits() < VT
.getSizeInBits();
474 /// Return true if this has no more bits than VT.
475 bool bitsLE(MVT VT
) const {
476 return getSizeInBits() <= VT
.getSizeInBits();
480 static MVT
getFloatingPointVT(unsigned BitWidth
) {
483 llvm_unreachable("Bad bit width!");
497 static MVT
getIntegerVT(unsigned BitWidth
) {
500 return (MVT::SimpleValueType
)(MVT::INVALID_SIMPLE_VALUE_TYPE
);
516 static MVT
getVectorVT(MVT VT
, unsigned NumElements
) {
517 switch (VT
.SimpleTy
) {
521 if (NumElements
== 2) return MVT::v2i1
;
522 if (NumElements
== 4) return MVT::v4i1
;
523 if (NumElements
== 8) return MVT::v8i1
;
524 if (NumElements
== 16) return MVT::v16i1
;
525 if (NumElements
== 32) return MVT::v32i1
;
526 if (NumElements
== 64) return MVT::v64i1
;
529 if (NumElements
== 1) return MVT::v1i8
;
530 if (NumElements
== 2) return MVT::v2i8
;
531 if (NumElements
== 4) return MVT::v4i8
;
532 if (NumElements
== 8) return MVT::v8i8
;
533 if (NumElements
== 16) return MVT::v16i8
;
534 if (NumElements
== 32) return MVT::v32i8
;
535 if (NumElements
== 64) return MVT::v64i8
;
538 if (NumElements
== 1) return MVT::v1i16
;
539 if (NumElements
== 2) return MVT::v2i16
;
540 if (NumElements
== 4) return MVT::v4i16
;
541 if (NumElements
== 8) return MVT::v8i16
;
542 if (NumElements
== 16) return MVT::v16i16
;
543 if (NumElements
== 32) return MVT::v32i16
;
546 if (NumElements
== 1) return MVT::v1i32
;
547 if (NumElements
== 2) return MVT::v2i32
;
548 if (NumElements
== 4) return MVT::v4i32
;
549 if (NumElements
== 8) return MVT::v8i32
;
550 if (NumElements
== 16) return MVT::v16i32
;
553 if (NumElements
== 1) return MVT::v1i64
;
554 if (NumElements
== 2) return MVT::v2i64
;
555 if (NumElements
== 4) return MVT::v4i64
;
556 if (NumElements
== 8) return MVT::v8i64
;
557 if (NumElements
== 16) return MVT::v16i64
;
560 if (NumElements
== 2) return MVT::v2f16
;
561 if (NumElements
== 4) return MVT::v4f16
;
562 if (NumElements
== 8) return MVT::v8f16
;
565 if (NumElements
== 1) return MVT::v1f32
;
566 if (NumElements
== 2) return MVT::v2f32
;
567 if (NumElements
== 4) return MVT::v4f32
;
568 if (NumElements
== 8) return MVT::v8f32
;
569 if (NumElements
== 16) return MVT::v16f32
;
572 if (NumElements
== 1) return MVT::v1f64
;
573 if (NumElements
== 2) return MVT::v2f64
;
574 if (NumElements
== 4) return MVT::v4f64
;
575 if (NumElements
== 8) return MVT::v8f64
;
578 return (MVT::SimpleValueType
)(MVT::INVALID_SIMPLE_VALUE_TYPE
);
581 /// Return the value type corresponding to the specified type. This returns
582 /// all pointers as iPTR. If HandleUnknown is true, unknown types are
583 /// returned as Other, otherwise they are invalid.
584 static MVT
getVT(Type
*Ty
, bool HandleUnknown
= false);
587 /// A simple iterator over the MVT::SimpleValueType enum.
588 struct mvt_iterator
{
590 mvt_iterator(SimpleValueType VT
) : VT(VT
) {}
591 MVT
operator*() const { return VT
; }
592 bool operator!=(const mvt_iterator
&LHS
) const { return VT
!= LHS
.VT
; }
593 mvt_iterator
& operator++() {
594 VT
= (MVT::SimpleValueType
)((int)VT
+ 1);
595 assert((int)VT
<= MVT::MAX_ALLOWED_VALUETYPE
&&
596 "MVT iterator overflowed.");
600 /// A range of the MVT::SimpleValueType enum.
601 typedef iterator_range
<mvt_iterator
> mvt_range
;
604 /// SimpleValueType Iteration
606 static mvt_range
all_valuetypes() {
607 return mvt_range(MVT::FIRST_VALUETYPE
, MVT::LAST_VALUETYPE
);
609 static mvt_range
integer_valuetypes() {
610 return mvt_range(MVT::FIRST_INTEGER_VALUETYPE
,
611 (MVT::SimpleValueType
)(MVT::LAST_INTEGER_VALUETYPE
+ 1));
613 static mvt_range
fp_valuetypes() {
614 return mvt_range(MVT::FIRST_FP_VALUETYPE
,
615 (MVT::SimpleValueType
)(MVT::LAST_FP_VALUETYPE
+ 1));
617 static mvt_range
vector_valuetypes() {
618 return mvt_range(MVT::FIRST_VECTOR_VALUETYPE
,
619 (MVT::SimpleValueType
)(MVT::LAST_VECTOR_VALUETYPE
+ 1));
621 static mvt_range
integer_vector_valuetypes() {
623 MVT::FIRST_INTEGER_VECTOR_VALUETYPE
,
624 (MVT::SimpleValueType
)(MVT::LAST_INTEGER_VECTOR_VALUETYPE
+ 1));
626 static mvt_range
fp_vector_valuetypes() {
628 MVT::FIRST_FP_VECTOR_VALUETYPE
,
629 (MVT::SimpleValueType
)(MVT::LAST_FP_VECTOR_VALUETYPE
+ 1));
634 } // End llvm namespace