LLVM  8.0.0svn
MachineValueType.h
Go to the documentation of this file.
1 //===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the set of machine-level target independent types which
11 // legal values in the code generator use.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
16 #define LLVM_SUPPORT_MACHINEVALUETYPE_H
17 
21 #include <cassert>
22 
23 namespace llvm {
24 
25  class Type;
26 
27  /// Machine Value Type. Every type that is supported natively by some
28  /// processor targeted by LLVM occurs here. This means that any legal value
29  /// type can be represented by an MVT.
30  class MVT {
31  public:
32  enum SimpleValueType : uint8_t {
33  // Simple value types that aren't explicitly part of this enumeration
34  // are considered extended value types.
36 
37  // If you change this numbering, you must change the values in
38  // ValueTypes.td as well!
39  Other = 1, // This is a non-standard value
40  i1 = 2, // This is a 1 bit integer value
41  i8 = 3, // This is an 8 bit integer value
42  i16 = 4, // This is a 16 bit integer value
43  i32 = 5, // This is a 32 bit integer value
44  i64 = 6, // This is a 64 bit integer value
45  i128 = 7, // This is a 128 bit integer value
46 
49 
50  f16 = 8, // This is a 16 bit floating point value
51  f32 = 9, // This is a 32 bit floating point value
52  f64 = 10, // This is a 64 bit floating point value
53  f80 = 11, // This is a 80 bit floating point value
54  f128 = 12, // This is a 128 bit floating point value
55  ppcf128 = 13, // This is a PPC 128-bit floating point value
56 
59 
60  v1i1 = 14, // 1 x i1
61  v2i1 = 15, // 2 x i1
62  v4i1 = 16, // 4 x i1
63  v8i1 = 17, // 8 x i1
64  v16i1 = 18, // 16 x i1
65  v32i1 = 19, // 32 x i1
66  v64i1 = 20, // 64 x i1
67  v128i1 = 21, // 128 x i1
68  v512i1 = 22, // 512 x i1
69  v1024i1 = 23, // 1024 x i1
70 
71  v1i8 = 24, // 1 x i8
72  v2i8 = 25, // 2 x i8
73  v4i8 = 26, // 4 x i8
74  v8i8 = 27, // 8 x i8
75  v16i8 = 28, // 16 x i8
76  v32i8 = 29, // 32 x i8
77  v64i8 = 30, // 64 x i8
78  v128i8 = 31, //128 x i8
79  v256i8 = 32, //256 x i8
80 
81  v1i16 = 33, // 1 x i16
82  v2i16 = 34, // 2 x i16
83  v4i16 = 35, // 4 x i16
84  v8i16 = 36, // 8 x i16
85  v16i16 = 37, // 16 x i16
86  v32i16 = 38, // 32 x i16
87  v64i16 = 39, // 64 x i16
88  v128i16 = 40, //128 x i16
89 
90  v1i32 = 41, // 1 x i32
91  v2i32 = 42, // 2 x i32
92  v4i32 = 43, // 4 x i32
93  v8i32 = 44, // 8 x i32
94  v16i32 = 45, // 16 x i32
95  v32i32 = 46, // 32 x i32
96  v64i32 = 47, // 64 x i32
97 
98  v1i64 = 48, // 1 x i64
99  v2i64 = 49, // 2 x i64
100  v4i64 = 50, // 4 x i64
101  v8i64 = 51, // 8 x i64
102  v16i64 = 52, // 16 x i64
103  v32i64 = 53, // 32 x i64
104 
105  v1i128 = 54, // 1 x i128
106 
107  // Scalable integer types
108  nxv1i1 = 55, // n x 1 x i1
109  nxv2i1 = 56, // n x 2 x i1
110  nxv4i1 = 57, // n x 4 x i1
111  nxv8i1 = 58, // n x 8 x i1
112  nxv16i1 = 59, // n x 16 x i1
113  nxv32i1 = 60, // n x 32 x i1
114 
115  nxv1i8 = 61, // n x 1 x i8
116  nxv2i8 = 62, // n x 2 x i8
117  nxv4i8 = 63, // n x 4 x i8
118  nxv8i8 = 64, // n x 8 x i8
119  nxv16i8 = 65, // n x 16 x i8
120  nxv32i8 = 66, // n x 32 x i8
121 
122  nxv1i16 = 67, // n x 1 x i16
123  nxv2i16 = 68, // n x 2 x i16
124  nxv4i16 = 69, // n x 4 x i16
125  nxv8i16 = 70, // n x 8 x i16
126  nxv16i16 = 71, // n x 16 x i16
127  nxv32i16 = 72, // n x 32 x i16
128 
129  nxv1i32 = 73, // n x 1 x i32
130  nxv2i32 = 74, // n x 2 x i32
131  nxv4i32 = 75, // n x 4 x i32
132  nxv8i32 = 76, // n x 8 x i32
133  nxv16i32 = 77, // n x 16 x i32
134  nxv32i32 = 78, // n x 32 x i32
135 
136  nxv1i64 = 79, // n x 1 x i64
137  nxv2i64 = 80, // n x 2 x i64
138  nxv4i64 = 81, // n x 4 x i64
139  nxv8i64 = 82, // n x 8 x i64
140  nxv16i64 = 83, // n x 16 x i64
141  nxv32i64 = 84, // n x 32 x i64
142 
145 
148 
149  v2f16 = 85, // 2 x f16
150  v4f16 = 86, // 4 x f16
151  v8f16 = 87, // 8 x f16
152  v1f32 = 88, // 1 x f32
153  v2f32 = 89, // 2 x f32
154  v4f32 = 90, // 4 x f32
155  v8f32 = 91, // 8 x f32
156  v16f32 = 92, // 16 x f32
157  v1f64 = 93, // 1 x f64
158  v2f64 = 94, // 2 x f64
159  v4f64 = 95, // 4 x f64
160  v8f64 = 96, // 8 x f64
161 
162  nxv2f16 = 97, // n x 2 x f16
163  nxv4f16 = 98, // n x 4 x f16
164  nxv8f16 = 99, // n x 8 x f16
165  nxv1f32 = 100, // n x 1 x f32
166  nxv2f32 = 101, // n x 2 x f32
167  nxv4f32 = 102, // n x 4 x f32
168  nxv8f32 = 103, // n x 8 x f32
169  nxv16f32 = 104, // n x 16 x f32
170  nxv1f64 = 105, // n x 1 x f64
171  nxv2f64 = 106, // n x 2 x f64
172  nxv4f64 = 107, // n x 4 x f64
173  nxv8f64 = 108, // n x 8 x f64
174 
177 
180 
183 
184  x86mmx = 109, // This is an X86 MMX value
185 
186  Glue = 110, // This glues nodes together during pre-RA sched
187 
188  isVoid = 111, // This has no value
189 
190  Untyped = 112, // This value takes a register, but has
191  // unspecified type. The register class
192  // will be determined by the opcode.
193 
194  ExceptRef = 113, // WebAssembly's except_ref type
195 
196  FIRST_VALUETYPE = 1, // This is always the beginning of the list.
197  LAST_VALUETYPE = 114, // This always remains at the end of the list.
198 
199  // This is the current maximum for LAST_VALUETYPE.
200  // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
201  // This value must be a multiple of 32.
203 
204  // A value of type llvm::TokenTy
205  token = 248,
206 
207  // This is MDNode or MDString.
208  Metadata = 249,
209 
210  // An int value the size of the pointer of the current
211  // target to any address space. This must only be used internal to
212  // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
213  iPTRAny = 250,
214 
215  // A vector with any length and element size. This is used
216  // for intrinsics that have overloadings based on vector types.
217  // This is only for tblgen's consumption!
218  vAny = 251,
219 
220  // Any floating-point or vector floating-point value. This is used
221  // for intrinsics that have overloadings based on floating-point types.
222  // This is only for tblgen's consumption!
223  fAny = 252,
224 
225  // An integer or vector integer value of any bit width. This is
226  // used for intrinsics that have overloadings based on integer bit widths.
227  // This is only for tblgen's consumption!
228  iAny = 253,
229 
230  // An int value the size of the pointer of the current
231  // target. This should only be used internal to tblgen!
232  iPTR = 254,
233 
234  // Any type. This is used for intrinsics that have overloadings.
235  // This is only for tblgen's consumption!
236  Any = 255
237  };
238 
240 
241  // A class to represent the number of elements in a vector
242  //
243  // For fixed-length vectors, the total number of elements is equal to 'Min'
244  // For scalable vectors, the total number of elements is a multiple of 'Min'
245  class ElementCount {
246  public:
247  unsigned Min;
248  bool Scalable;
249 
250  ElementCount(unsigned Min, bool Scalable)
251  : Min(Min), Scalable(Scalable) {}
252 
253  ElementCount operator*(unsigned RHS) {
254  return { Min * RHS, Scalable };
255  }
256 
257  ElementCount& operator*=(unsigned RHS) {
258  Min *= RHS;
259  return *this;
260  }
261 
262  ElementCount operator/(unsigned RHS) {
263  return { Min / RHS, Scalable };
264  }
265 
266  ElementCount& operator/=(unsigned RHS) {
267  Min /= RHS;
268  return *this;
269  }
270 
271  bool operator==(const ElementCount& RHS) {
272  return Min == RHS.Min && Scalable == RHS.Scalable;
273  }
274  };
275 
276  constexpr MVT() = default;
277  constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
278 
279  bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; }
280  bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; }
281  bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
282  bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
283  bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
284  bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
285 
286  /// Return true if this is a valid simple valuetype.
287  bool isValid() const {
288  return (SimpleTy >= MVT::FIRST_VALUETYPE &&
289  SimpleTy < MVT::LAST_VALUETYPE);
290  }
291 
292  /// Return true if this is a FP or a vector FP type.
293  bool isFloatingPoint() const {
294  return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
295  SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
296  (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE &&
297  SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE));
298  }
299 
300  /// Return true if this is an integer or a vector integer type.
301  bool isInteger() const {
302  return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
303  SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
306  }
307 
308  /// Return true if this is an integer, not including vectors.
309  bool isScalarInteger() const {
310  return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
311  SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
312  }
313 
314  /// Return true if this is a vector value type.
315  bool isVector() const {
316  return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
317  SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
318  }
319 
320  /// Return true if this is a vector value type where the
321  /// runtime length is machine dependent
322  bool isScalableVector() const {
323  return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE &&
325  (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE &&
326  SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE));
327  }
328 
329  /// Return true if this is a 16-bit vector type.
330  bool is16BitVector() const {
331  return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 ||
332  SimpleTy == MVT::v16i1);
333  }
334 
335  /// Return true if this is a 32-bit vector type.
336  bool is32BitVector() const {
337  return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8 ||
338  SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 ||
339  SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32);
340  }
341 
342  /// Return true if this is a 64-bit vector type.
343  bool is64BitVector() const {
344  return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8 ||
345  SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 ||
346  SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 ||
347  SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64);
348  }
349 
350  /// Return true if this is a 128-bit vector type.
351  bool is128BitVector() const {
352  return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8 ||
353  SimpleTy == MVT::v8i16 || SimpleTy == MVT::v4i32 ||
354  SimpleTy == MVT::v2i64 || SimpleTy == MVT::v1i128 ||
355  SimpleTy == MVT::v8f16 || SimpleTy == MVT::v4f32 ||
356  SimpleTy == MVT::v2f64);
357  }
358 
359  /// Return true if this is a 256-bit vector type.
360  bool is256BitVector() const {
361  return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 ||
362  SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
363  SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64);
364  }
365 
366  /// Return true if this is a 512-bit vector type.
367  bool is512BitVector() const {
368  return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64 ||
369  SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8 ||
370  SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
371  SimpleTy == MVT::v8i64);
372  }
373 
374  /// Return true if this is a 1024-bit vector type.
375  bool is1024BitVector() const {
376  return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
377  SimpleTy == MVT::v64i16 || SimpleTy == MVT::v32i32 ||
378  SimpleTy == MVT::v16i64);
379  }
380 
381  /// Return true if this is a 2048-bit vector type.
382  bool is2048BitVector() const {
383  return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
384  SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64);
385  }
386 
387  /// Return true if this is an overloaded type for TableGen.
388  bool isOverloaded() const {
389  return (SimpleTy==MVT::Any ||
390  SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
391  SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
392  }
393 
394  /// Returns true if the given vector is a power of 2.
395  bool isPow2VectorType() const {
396  unsigned NElts = getVectorNumElements();
397  return !(NElts & (NElts - 1));
398  }
399 
400  /// Widens the length of the given vector MVT up to the nearest power of 2
401  /// and returns that type.
403  if (isPow2VectorType())
404  return *this;
405 
406  unsigned NElts = getVectorNumElements();
407  unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
408  return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
409  }
410 
411  /// If this is a vector, return the element type, otherwise return this.
412  MVT getScalarType() const {
413  return isVector() ? getVectorElementType() : *this;
414  }
415 
417  switch (SimpleTy) {
418  default:
419  llvm_unreachable("Not a vector MVT!");
420  case v1i1:
421  case v2i1:
422  case v4i1:
423  case v8i1:
424  case v16i1:
425  case v32i1:
426  case v64i1:
427  case v128i1:
428  case v512i1:
429  case v1024i1:
430  case nxv1i1:
431  case nxv2i1:
432  case nxv4i1:
433  case nxv8i1:
434  case nxv16i1:
435  case nxv32i1: return i1;
436  case v1i8:
437  case v2i8:
438  case v4i8:
439  case v8i8:
440  case v16i8:
441  case v32i8:
442  case v64i8:
443  case v128i8:
444  case v256i8:
445  case nxv1i8:
446  case nxv2i8:
447  case nxv4i8:
448  case nxv8i8:
449  case nxv16i8:
450  case nxv32i8: return i8;
451  case v1i16:
452  case v2i16:
453  case v4i16:
454  case v8i16:
455  case v16i16:
456  case v32i16:
457  case v64i16:
458  case v128i16:
459  case nxv1i16:
460  case nxv2i16:
461  case nxv4i16:
462  case nxv8i16:
463  case nxv16i16:
464  case nxv32i16: return i16;
465  case v1i32:
466  case v2i32:
467  case v4i32:
468  case v8i32:
469  case v16i32:
470  case v32i32:
471  case v64i32:
472  case nxv1i32:
473  case nxv2i32:
474  case nxv4i32:
475  case nxv8i32:
476  case nxv16i32:
477  case nxv32i32: return i32;
478  case v1i64:
479  case v2i64:
480  case v4i64:
481  case v8i64:
482  case v16i64:
483  case v32i64:
484  case nxv1i64:
485  case nxv2i64:
486  case nxv4i64:
487  case nxv8i64:
488  case nxv16i64:
489  case nxv32i64: return i64;
490  case v1i128: return i128;
491  case v2f16:
492  case v4f16:
493  case v8f16:
494  case nxv2f16:
495  case nxv4f16:
496  case nxv8f16: return f16;
497  case v1f32:
498  case v2f32:
499  case v4f32:
500  case v8f32:
501  case v16f32:
502  case nxv1f32:
503  case nxv2f32:
504  case nxv4f32:
505  case nxv8f32:
506  case nxv16f32: return f32;
507  case v1f64:
508  case v2f64:
509  case v4f64:
510  case v8f64:
511  case nxv1f64:
512  case nxv2f64:
513  case nxv4f64:
514  case nxv8f64: return f64;
515  }
516  }
517 
518  unsigned getVectorNumElements() const {
519  switch (SimpleTy) {
520  default:
521  llvm_unreachable("Not a vector MVT!");
522  case v1024i1: return 1024;
523  case v512i1: return 512;
524  case v256i8: return 256;
525  case v128i1:
526  case v128i8:
527  case v128i16: return 128;
528  case v64i1:
529  case v64i8:
530  case v64i16:
531  case v64i32: return 64;
532  case v32i1:
533  case v32i8:
534  case v32i16:
535  case v32i32:
536  case v32i64:
537  case nxv32i1:
538  case nxv32i8:
539  case nxv32i16:
540  case nxv32i32:
541  case nxv32i64: return 32;
542  case v16i1:
543  case v16i8:
544  case v16i16:
545  case v16i32:
546  case v16i64:
547  case v16f32:
548  case nxv16i1:
549  case nxv16i8:
550  case nxv16i16:
551  case nxv16i32:
552  case nxv16i64:
553  case nxv16f32: return 16;
554  case v8i1:
555  case v8i8:
556  case v8i16:
557  case v8i32:
558  case v8i64:
559  case v8f16:
560  case v8f32:
561  case v8f64:
562  case nxv8i1:
563  case nxv8i8:
564  case nxv8i16:
565  case nxv8i32:
566  case nxv8i64:
567  case nxv8f16:
568  case nxv8f32:
569  case nxv8f64: return 8;
570  case v4i1:
571  case v4i8:
572  case v4i16:
573  case v4i32:
574  case v4i64:
575  case v4f16:
576  case v4f32:
577  case v4f64:
578  case nxv4i1:
579  case nxv4i8:
580  case nxv4i16:
581  case nxv4i32:
582  case nxv4i64:
583  case nxv4f16:
584  case nxv4f32:
585  case nxv4f64: return 4;
586  case v2i1:
587  case v2i8:
588  case v2i16:
589  case v2i32:
590  case v2i64:
591  case v2f16:
592  case v2f32:
593  case v2f64:
594  case nxv2i1:
595  case nxv2i8:
596  case nxv2i16:
597  case nxv2i32:
598  case nxv2i64:
599  case nxv2f16:
600  case nxv2f32:
601  case nxv2f64: return 2;
602  case v1i1:
603  case v1i8:
604  case v1i16:
605  case v1i32:
606  case v1i64:
607  case v1i128:
608  case v1f32:
609  case v1f64:
610  case nxv1i1:
611  case nxv1i8:
612  case nxv1i16:
613  case nxv1i32:
614  case nxv1i64:
615  case nxv1f32:
616  case nxv1f64: return 1;
617  }
618  }
619 
621  return { getVectorNumElements(), isScalableVector() };
622  }
623 
624  unsigned getSizeInBits() const {
625  switch (SimpleTy) {
626  default:
627  llvm_unreachable("getSizeInBits called on extended MVT.");
628  case Other:
629  llvm_unreachable("Value type is non-standard value, Other.");
630  case iPTR:
631  llvm_unreachable("Value type size is target-dependent. Ask TLI.");
632  case iPTRAny:
633  case iAny:
634  case fAny:
635  case vAny:
636  case Any:
637  llvm_unreachable("Value type is overloaded.");
638  case token:
639  llvm_unreachable("Token type is a sentinel that cannot be used "
640  "in codegen and has no size");
641  case Metadata:
642  llvm_unreachable("Value type is metadata.");
643  case i1:
644  case v1i1:
645  case nxv1i1: return 1;
646  case v2i1:
647  case nxv2i1: return 2;
648  case v4i1:
649  case nxv4i1: return 4;
650  case i8 :
651  case v1i8:
652  case v8i1:
653  case nxv1i8:
654  case nxv8i1: return 8;
655  case i16 :
656  case f16:
657  case v16i1:
658  case v2i8:
659  case v1i16:
660  case nxv16i1:
661  case nxv2i8:
662  case nxv1i16: return 16;
663  case f32 :
664  case i32 :
665  case v32i1:
666  case v4i8:
667  case v2i16:
668  case v2f16:
669  case v1f32:
670  case v1i32:
671  case nxv32i1:
672  case nxv4i8:
673  case nxv2i16:
674  case nxv1i32:
675  case nxv2f16:
676  case nxv1f32: return 32;
677  case x86mmx:
678  case f64 :
679  case i64 :
680  case v64i1:
681  case v8i8:
682  case v4i16:
683  case v2i32:
684  case v1i64:
685  case v4f16:
686  case v2f32:
687  case v1f64:
688  case nxv8i8:
689  case nxv4i16:
690  case nxv2i32:
691  case nxv1i64:
692  case nxv4f16:
693  case nxv2f32:
694  case nxv1f64: return 64;
695  case f80 : return 80;
696  case f128:
697  case ppcf128:
698  case i128:
699  case v128i1:
700  case v16i8:
701  case v8i16:
702  case v4i32:
703  case v2i64:
704  case v1i128:
705  case v8f16:
706  case v4f32:
707  case v2f64:
708  case nxv16i8:
709  case nxv8i16:
710  case nxv4i32:
711  case nxv2i64:
712  case nxv8f16:
713  case nxv4f32:
714  case nxv2f64: return 128;
715  case v32i8:
716  case v16i16:
717  case v8i32:
718  case v4i64:
719  case v8f32:
720  case v4f64:
721  case nxv32i8:
722  case nxv16i16:
723  case nxv8i32:
724  case nxv4i64:
725  case nxv8f32:
726  case nxv4f64: return 256;
727  case v512i1:
728  case v64i8:
729  case v32i16:
730  case v16i32:
731  case v8i64:
732  case v16f32:
733  case v8f64:
734  case nxv32i16:
735  case nxv16i32:
736  case nxv8i64:
737  case nxv16f32:
738  case nxv8f64: return 512;
739  case v1024i1:
740  case v128i8:
741  case v64i16:
742  case v32i32:
743  case v16i64:
744  case nxv32i32:
745  case nxv16i64: return 1024;
746  case v256i8:
747  case v128i16:
748  case v64i32:
749  case v32i64:
750  case nxv32i64: return 2048;
751  case ExceptRef: return 0; // opaque type
752  }
753  }
754 
755  unsigned getScalarSizeInBits() const {
756  return getScalarType().getSizeInBits();
757  }
758 
759  /// Return the number of bytes overwritten by a store of the specified value
760  /// type.
761  unsigned getStoreSize() const {
762  return (getSizeInBits() + 7) / 8;
763  }
764 
765  /// Return the number of bits overwritten by a store of the specified value
766  /// type.
767  unsigned getStoreSizeInBits() const {
768  return getStoreSize() * 8;
769  }
770 
771  /// Return true if this has more bits than VT.
772  bool bitsGT(MVT VT) const {
773  return getSizeInBits() > VT.getSizeInBits();
774  }
775 
776  /// Return true if this has no less bits than VT.
777  bool bitsGE(MVT VT) const {
778  return getSizeInBits() >= VT.getSizeInBits();
779  }
780 
781  /// Return true if this has less bits than VT.
782  bool bitsLT(MVT VT) const {
783  return getSizeInBits() < VT.getSizeInBits();
784  }
785 
786  /// Return true if this has no more bits than VT.
787  bool bitsLE(MVT VT) const {
788  return getSizeInBits() <= VT.getSizeInBits();
789  }
790 
791  static MVT getFloatingPointVT(unsigned BitWidth) {
792  switch (BitWidth) {
793  default:
794  llvm_unreachable("Bad bit width!");
795  case 16:
796  return MVT::f16;
797  case 32:
798  return MVT::f32;
799  case 64:
800  return MVT::f64;
801  case 80:
802  return MVT::f80;
803  case 128:
804  return MVT::f128;
805  }
806  }
807 
808  static MVT getIntegerVT(unsigned BitWidth) {
809  switch (BitWidth) {
810  default:
812  case 1:
813  return MVT::i1;
814  case 8:
815  return MVT::i8;
816  case 16:
817  return MVT::i16;
818  case 32:
819  return MVT::i32;
820  case 64:
821  return MVT::i64;
822  case 128:
823  return MVT::i128;
824  }
825  }
826 
827  static MVT getVectorVT(MVT VT, unsigned NumElements) {
828  switch (VT.SimpleTy) {
829  default:
830  break;
831  case MVT::i1:
832  if (NumElements == 1) return MVT::v1i1;
833  if (NumElements == 2) return MVT::v2i1;
834  if (NumElements == 4) return MVT::v4i1;
835  if (NumElements == 8) return MVT::v8i1;
836  if (NumElements == 16) return MVT::v16i1;
837  if (NumElements == 32) return MVT::v32i1;
838  if (NumElements == 64) return MVT::v64i1;
839  if (NumElements == 128) return MVT::v128i1;
840  if (NumElements == 512) return MVT::v512i1;
841  if (NumElements == 1024) return MVT::v1024i1;
842  break;
843  case MVT::i8:
844  if (NumElements == 1) return MVT::v1i8;
845  if (NumElements == 2) return MVT::v2i8;
846  if (NumElements == 4) return MVT::v4i8;
847  if (NumElements == 8) return MVT::v8i8;
848  if (NumElements == 16) return MVT::v16i8;
849  if (NumElements == 32) return MVT::v32i8;
850  if (NumElements == 64) return MVT::v64i8;
851  if (NumElements == 128) return MVT::v128i8;
852  if (NumElements == 256) return MVT::v256i8;
853  break;
854  case MVT::i16:
855  if (NumElements == 1) return MVT::v1i16;
856  if (NumElements == 2) return MVT::v2i16;
857  if (NumElements == 4) return MVT::v4i16;
858  if (NumElements == 8) return MVT::v8i16;
859  if (NumElements == 16) return MVT::v16i16;
860  if (NumElements == 32) return MVT::v32i16;
861  if (NumElements == 64) return MVT::v64i16;
862  if (NumElements == 128) return MVT::v128i16;
863  break;
864  case MVT::i32:
865  if (NumElements == 1) return MVT::v1i32;
866  if (NumElements == 2) return MVT::v2i32;
867  if (NumElements == 4) return MVT::v4i32;
868  if (NumElements == 8) return MVT::v8i32;
869  if (NumElements == 16) return MVT::v16i32;
870  if (NumElements == 32) return MVT::v32i32;
871  if (NumElements == 64) return MVT::v64i32;
872  break;
873  case MVT::i64:
874  if (NumElements == 1) return MVT::v1i64;
875  if (NumElements == 2) return MVT::v2i64;
876  if (NumElements == 4) return MVT::v4i64;
877  if (NumElements == 8) return MVT::v8i64;
878  if (NumElements == 16) return MVT::v16i64;
879  if (NumElements == 32) return MVT::v32i64;
880  break;
881  case MVT::i128:
882  if (NumElements == 1) return MVT::v1i128;
883  break;
884  case MVT::f16:
885  if (NumElements == 2) return MVT::v2f16;
886  if (NumElements == 4) return MVT::v4f16;
887  if (NumElements == 8) return MVT::v8f16;
888  break;
889  case MVT::f32:
890  if (NumElements == 1) return MVT::v1f32;
891  if (NumElements == 2) return MVT::v2f32;
892  if (NumElements == 4) return MVT::v4f32;
893  if (NumElements == 8) return MVT::v8f32;
894  if (NumElements == 16) return MVT::v16f32;
895  break;
896  case MVT::f64:
897  if (NumElements == 1) return MVT::v1f64;
898  if (NumElements == 2) return MVT::v2f64;
899  if (NumElements == 4) return MVT::v4f64;
900  if (NumElements == 8) return MVT::v8f64;
901  break;
902  }
904  }
905 
906  static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
907  switch(VT.SimpleTy) {
908  default:
909  break;
910  case MVT::i1:
911  if (NumElements == 1) return MVT::nxv1i1;
912  if (NumElements == 2) return MVT::nxv2i1;
913  if (NumElements == 4) return MVT::nxv4i1;
914  if (NumElements == 8) return MVT::nxv8i1;
915  if (NumElements == 16) return MVT::nxv16i1;
916  if (NumElements == 32) return MVT::nxv32i1;
917  break;
918  case MVT::i8:
919  if (NumElements == 1) return MVT::nxv1i8;
920  if (NumElements == 2) return MVT::nxv2i8;
921  if (NumElements == 4) return MVT::nxv4i8;
922  if (NumElements == 8) return MVT::nxv8i8;
923  if (NumElements == 16) return MVT::nxv16i8;
924  if (NumElements == 32) return MVT::nxv32i8;
925  break;
926  case MVT::i16:
927  if (NumElements == 1) return MVT::nxv1i16;
928  if (NumElements == 2) return MVT::nxv2i16;
929  if (NumElements == 4) return MVT::nxv4i16;
930  if (NumElements == 8) return MVT::nxv8i16;
931  if (NumElements == 16) return MVT::nxv16i16;
932  if (NumElements == 32) return MVT::nxv32i16;
933  break;
934  case MVT::i32:
935  if (NumElements == 1) return MVT::nxv1i32;
936  if (NumElements == 2) return MVT::nxv2i32;
937  if (NumElements == 4) return MVT::nxv4i32;
938  if (NumElements == 8) return MVT::nxv8i32;
939  if (NumElements == 16) return MVT::nxv16i32;
940  if (NumElements == 32) return MVT::nxv32i32;
941  break;
942  case MVT::i64:
943  if (NumElements == 1) return MVT::nxv1i64;
944  if (NumElements == 2) return MVT::nxv2i64;
945  if (NumElements == 4) return MVT::nxv4i64;
946  if (NumElements == 8) return MVT::nxv8i64;
947  if (NumElements == 16) return MVT::nxv16i64;
948  if (NumElements == 32) return MVT::nxv32i64;
949  break;
950  case MVT::f16:
951  if (NumElements == 2) return MVT::nxv2f16;
952  if (NumElements == 4) return MVT::nxv4f16;
953  if (NumElements == 8) return MVT::nxv8f16;
954  break;
955  case MVT::f32:
956  if (NumElements == 1) return MVT::nxv1f32;
957  if (NumElements == 2) return MVT::nxv2f32;
958  if (NumElements == 4) return MVT::nxv4f32;
959  if (NumElements == 8) return MVT::nxv8f32;
960  if (NumElements == 16) return MVT::nxv16f32;
961  break;
962  case MVT::f64:
963  if (NumElements == 1) return MVT::nxv1f64;
964  if (NumElements == 2) return MVT::nxv2f64;
965  if (NumElements == 4) return MVT::nxv4f64;
966  if (NumElements == 8) return MVT::nxv8f64;
967  break;
968  }
970  }
971 
972  static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
973  if (IsScalable)
974  return getScalableVectorVT(VT, NumElements);
975  return getVectorVT(VT, NumElements);
976  }
977 
979  if (EC.Scalable)
980  return getScalableVectorVT(VT, EC.Min);
981  return getVectorVT(VT, EC.Min);
982  }
983 
984  /// Return the value type corresponding to the specified type. This returns
985  /// all pointers as iPTR. If HandleUnknown is true, unknown types are
986  /// returned as Other, otherwise they are invalid.
987  static MVT getVT(Type *Ty, bool HandleUnknown = false);
988 
989  private:
990  /// A simple iterator over the MVT::SimpleValueType enum.
991  struct mvt_iterator {
992  SimpleValueType VT;
993 
994  mvt_iterator(SimpleValueType VT) : VT(VT) {}
995 
996  MVT operator*() const { return VT; }
997  bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; }
998 
999  mvt_iterator& operator++() {
1000  VT = (MVT::SimpleValueType)((int)VT + 1);
1001  assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
1002  "MVT iterator overflowed.");
1003  return *this;
1004  }
1005  };
1006 
1007  /// A range of the MVT::SimpleValueType enum.
1009 
1010  public:
1011  /// SimpleValueType Iteration
1012  /// @{
1015  }
1016 
1020  }
1021 
1025  }
1026 
1030  }
1031 
1033  return mvt_range(
1036  }
1037 
1039  return mvt_range(
1042  }
1043 
1047  }
1048 
1052  }
1053  /// @}
1054  };
1055 
1056 } // end namespace llvm
1057 
1058 #endif // LLVM_CODEGEN_MACHINEVALUETYPE_H
static MVT getIntegerVT(unsigned BitWidth)
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:552
bool operator>=(const MVT &S) const
Definition: Any.h:27
bool isInteger() const
Return true if this is an integer or a vector integer type.
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:49
ElementCount & operator/=(unsigned RHS)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static MVT getVectorVT(MVT VT, unsigned NumElements)
bool isVector() const
Return true if this is a vector value type.
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
bool is256BitVector() const
Return true if this is a 256-bit vector type.
MVT getPow2VectorType() const
Widens the length of the given vector MVT up to the nearest power of 2 and returns that type...
static MVT getFloatingPointVT(unsigned BitWidth)
unsigned getVectorNumElements() const
unsigned getStoreSizeInBits() const
Return the number of bits overwritten by a store of the specified value type.
bool operator>(const MVT &S) const
bool isValid() const
Return true if this is a valid simple valuetype.
static MVT getScalableVectorVT(MVT VT, unsigned NumElements)
constexpr MVT(SimpleValueType SVT)
SimpleValueType SimpleTy
static MVT getVectorVT(MVT VT, MVT::ElementCount EC)
unsigned getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
bool is64BitVector() const
Return true if this is a 64-bit vector type.
unsigned getSizeInBits() const
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
bool operator<=(const MVT &S) const
bool is2048BitVector() const
Return true if this is a 2048-bit vector type.
bool is16BitVector() const
Return true if this is a 16-bit vector type.
bool bitsLT(MVT VT) const
Return true if this has less bits than VT.
static mvt_range integer_vector_valuetypes()
ElementCount(unsigned Min, bool Scalable)
bool bitsGT(MVT VT) const
Return true if this has more bits than VT.
MVT getVectorElementType() const
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
bool is128BitVector() const
Return true if this is a 128-bit vector type.
bool bitsGE(MVT VT) const
Return true if this has no less bits than VT.
static mvt_range fp_vector_valuetypes()
ElementCount operator*(unsigned RHS)
bool operator<(const MVT &S) const
Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
unsigned getScalarSizeInBits() const
bool isScalarInteger() const
Return true if this is an integer, not including vectors.
static mvt_range fp_valuetypes()
ElementCount & operator*=(unsigned RHS)
bool bitsLE(MVT VT) const
Return true if this has no more bits than VT.
static mvt_range vector_valuetypes()
static MVT getVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:281
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool operator==(const MVT &S) const
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
static mvt_range integer_scalable_vector_valuetypes()
static mvt_range fp_scalable_vector_valuetypes()
MVT getScalarType() const
If this is a vector, return the element type, otherwise return this.
static mvt_range integer_valuetypes()
A range adaptor for a pair of iterators.
bool operator!=(const MVT &S) const
bool isOverloaded() const
Return true if this is an overloaded type for TableGen.
constexpr MVT()=default
bool is32BitVector() const
Return true if this is a 32-bit vector type.
MVT::ElementCount getVectorElementCount() const
static mvt_range all_valuetypes()
SimpleValueType Iteration.
static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable)
bool is512BitVector() const
Return true if this is a 512-bit vector type.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Root of the metadata hierarchy.
Definition: Metadata.h:58
ElementCount operator/(unsigned RHS)
bool operator==(const ElementCount &RHS)