LLVM  13.0.0git
MachineValueType.h
Go to the documentation of this file.
1 //===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the set of machine-level target independent types which
10 // legal values in the code generator use.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
15 #define LLVM_SUPPORT_MACHINEVALUETYPE_H
16 
20 #include "llvm/Support/TypeSize.h"
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  bf16 = 8, // This is a 16 bit brain floating point value
51  f16 = 9, // This is a 16 bit floating point value
52  f32 = 10, // This is a 32 bit floating point value
53  f64 = 11, // This is a 64 bit floating point value
54  f80 = 12, // This is a 80 bit floating point value
55  f128 = 13, // This is a 128 bit floating point value
56  ppcf128 = 14, // This is a PPC 128-bit floating point value
57 
60 
61  v1i1 = 15, // 1 x i1
62  v2i1 = 16, // 2 x i1
63  v4i1 = 17, // 4 x i1
64  v8i1 = 18, // 8 x i1
65  v16i1 = 19, // 16 x i1
66  v32i1 = 20, // 32 x i1
67  v64i1 = 21, // 64 x i1
68  v128i1 = 22, // 128 x i1
69  v256i1 = 23, // 256 x i1
70  v512i1 = 24, // 512 x i1
71  v1024i1 = 25, // 1024 x i1
72 
73  v1i8 = 26, // 1 x i8
74  v2i8 = 27, // 2 x i8
75  v4i8 = 28, // 4 x i8
76  v8i8 = 29, // 8 x i8
77  v16i8 = 30, // 16 x i8
78  v32i8 = 31, // 32 x i8
79  v64i8 = 32, // 64 x i8
80  v128i8 = 33, // 128 x i8
81  v256i8 = 34, // 256 x i8
82 
83  v1i16 = 35, // 1 x i16
84  v2i16 = 36, // 2 x i16
85  v3i16 = 37, // 3 x i16
86  v4i16 = 38, // 4 x i16
87  v8i16 = 39, // 8 x i16
88  v16i16 = 40, // 16 x i16
89  v32i16 = 41, // 32 x i16
90  v64i16 = 42, // 64 x i16
91  v128i16 = 43, // 128 x i16
92 
93  v1i32 = 44, // 1 x i32
94  v2i32 = 45, // 2 x i32
95  v3i32 = 46, // 3 x i32
96  v4i32 = 47, // 4 x i32
97  v5i32 = 48, // 5 x i32
98  v8i32 = 49, // 8 x i32
99  v16i32 = 50, // 16 x i32
100  v32i32 = 51, // 32 x i32
101  v64i32 = 52, // 64 x i32
102  v128i32 = 53, // 128 x i32
103  v256i32 = 54, // 256 x i32
104  v512i32 = 55, // 512 x i32
105  v1024i32 = 56, // 1024 x i32
106  v2048i32 = 57, // 2048 x i32
107 
108  v1i64 = 58, // 1 x i64
109  v2i64 = 59, // 2 x i64
110  v4i64 = 60, // 4 x i64
111  v8i64 = 61, // 8 x i64
112  v16i64 = 62, // 16 x i64
113  v32i64 = 63, // 32 x i64
114  v64i64 = 64, // 64 x i64
115  v128i64 = 65, // 128 x i64
116  v256i64 = 66, // 256 x i64
117 
118  v1i128 = 67, // 1 x i128
119 
122 
123  v1f16 = 68, // 1 x f16
124  v2f16 = 69, // 2 x f16
125  v3f16 = 70, // 3 x f16
126  v4f16 = 71, // 4 x f16
127  v8f16 = 72, // 8 x f16
128  v16f16 = 73, // 16 x f16
129  v32f16 = 74, // 32 x f16
130  v64f16 = 75, // 64 x f16
131  v128f16 = 76, // 128 x f16
132 
133  v2bf16 = 77, // 2 x bf16
134  v3bf16 = 78, // 3 x bf16
135  v4bf16 = 79, // 4 x bf16
136  v8bf16 = 80, // 8 x bf16
137  v16bf16 = 81, // 16 x bf16
138  v32bf16 = 82, // 32 x bf16
139  v64bf16 = 83, // 64 x bf16
140  v128bf16 = 84, // 128 x bf16
141 
142  v1f32 = 85, // 1 x f32
143  v2f32 = 86, // 2 x f32
144  v3f32 = 87, // 3 x f32
145  v4f32 = 88, // 4 x f32
146  v5f32 = 89, // 5 x f32
147  v8f32 = 90, // 8 x f32
148  v16f32 = 91, // 16 x f32
149  v32f32 = 92, // 32 x f32
150  v64f32 = 93, // 64 x f32
151  v128f32 = 94, // 128 x f32
152  v256f32 = 95, // 256 x f32
153  v512f32 = 96, // 512 x f32
154  v1024f32 = 97, // 1024 x f32
155  v2048f32 = 98, // 2048 x f32
156 
157  v1f64 = 99, // 1 x f64
158  v2f64 = 100, // 2 x f64
159  v4f64 = 101, // 4 x f64
160  v8f64 = 102, // 8 x f64
161  v16f64 = 103, // 16 x f64
162  v32f64 = 104, // 32 x f64
163  v64f64 = 105, // 64 x f64
164  v128f64 = 106, // 128 x f64
165  v256f64 = 107, // 256 x f64
166 
169 
172 
173  nxv1i1 = 108, // n x 1 x i1
174  nxv2i1 = 109, // n x 2 x i1
175  nxv4i1 = 110, // n x 4 x i1
176  nxv8i1 = 111, // n x 8 x i1
177  nxv16i1 = 112, // n x 16 x i1
178  nxv32i1 = 113, // n x 32 x i1
179  nxv64i1 = 114, // n x 64 x i1
180 
181  nxv1i8 = 115, // n x 1 x i8
182  nxv2i8 = 116, // n x 2 x i8
183  nxv4i8 = 117, // n x 4 x i8
184  nxv8i8 = 118, // n x 8 x i8
185  nxv16i8 = 119, // n x 16 x i8
186  nxv32i8 = 120, // n x 32 x i8
187  nxv64i8 = 121, // n x 64 x i8
188 
189  nxv1i16 = 122, // n x 1 x i16
190  nxv2i16 = 123, // n x 2 x i16
191  nxv4i16 = 124, // n x 4 x i16
192  nxv8i16 = 125, // n x 8 x i16
193  nxv16i16 = 126, // n x 16 x i16
194  nxv32i16 = 127, // n x 32 x i16
195 
196  nxv1i32 = 128, // n x 1 x i32
197  nxv2i32 = 129, // n x 2 x i32
198  nxv4i32 = 130, // n x 4 x i32
199  nxv8i32 = 131, // n x 8 x i32
200  nxv16i32 = 132, // n x 16 x i32
201  nxv32i32 = 133, // n x 32 x i32
202 
203  nxv1i64 = 134, // n x 1 x i64
204  nxv2i64 = 135, // n x 2 x i64
205  nxv4i64 = 136, // n x 4 x i64
206  nxv8i64 = 137, // n x 8 x i64
207  nxv16i64 = 138, // n x 16 x i64
208  nxv32i64 = 139, // n x 32 x i64
209 
212 
213  nxv1f16 = 140, // n x 1 x f16
214  nxv2f16 = 141, // n x 2 x f16
215  nxv4f16 = 142, // n x 4 x f16
216  nxv8f16 = 143, // n x 8 x f16
217  nxv16f16 = 144, // n x 16 x f16
218  nxv32f16 = 145, // n x 32 x f16
219 
220  nxv1bf16 = 146, // n x 1 x bf16
221  nxv2bf16 = 147, // n x 2 x bf16
222  nxv4bf16 = 148, // n x 4 x bf16
223  nxv8bf16 = 149, // n x 8 x bf16
224 
225  nxv1f32 = 150, // n x 1 x f32
226  nxv2f32 = 151, // n x 2 x f32
227  nxv4f32 = 152, // n x 4 x f32
228  nxv8f32 = 153, // n x 8 x f32
229  nxv16f32 = 154, // n x 16 x f32
230 
231  nxv1f64 = 155, // n x 1 x f64
232  nxv2f64 = 156, // n x 2 x f64
233  nxv4f64 = 157, // n x 4 x f64
234  nxv8f64 = 158, // n x 8 x f64
235 
238 
241 
244 
245  x86mmx = 159, // This is an X86 MMX value
246 
247  Glue = 160, // This glues nodes together during pre-RA sched
248 
249  isVoid = 161, // This has no value
250 
251  Untyped = 162, // This value takes a register, but has
252  // unspecified type. The register class
253  // will be determined by the opcode.
254 
255  funcref = 163, // WebAssembly's funcref type
256  externref = 164, // WebAssembly's externref type
257  x86amx = 165, // This is an X86 AMX value
258 
259  FIRST_VALUETYPE = 1, // This is always the beginning of the list.
260  LAST_VALUETYPE = 166, // This always remains at the end of the list.
261 
262  // This is the current maximum for LAST_VALUETYPE.
263  // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
264  // This value must be a multiple of 32.
266 
267  // A value of type llvm::TokenTy
268  token = 248,
269 
270  // This is MDNode or MDString.
271  Metadata = 249,
272 
273  // An int value the size of the pointer of the current
274  // target to any address space. This must only be used internal to
275  // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
276  iPTRAny = 250,
277 
278  // A vector with any length and element size. This is used
279  // for intrinsics that have overloadings based on vector types.
280  // This is only for tblgen's consumption!
281  vAny = 251,
282 
283  // Any floating-point or vector floating-point value. This is used
284  // for intrinsics that have overloadings based on floating-point types.
285  // This is only for tblgen's consumption!
286  fAny = 252,
287 
288  // An integer or vector integer value of any bit width. This is
289  // used for intrinsics that have overloadings based on integer bit widths.
290  // This is only for tblgen's consumption!
291  iAny = 253,
292 
293  // An int value the size of the pointer of the current
294  // target. This should only be used internal to tblgen!
295  iPTR = 254,
296 
297  // Any type. This is used for intrinsics that have overloadings.
298  // This is only for tblgen's consumption!
299  Any = 255
300  };
301 
303 
304  constexpr MVT() = default;
305  constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
306 
307  bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; }
308  bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; }
309  bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
310  bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
311  bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
312  bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
313 
314  /// Return true if this is a valid simple valuetype.
315  bool isValid() const {
316  return (SimpleTy >= MVT::FIRST_VALUETYPE &&
318  }
319 
320  /// Return true if this is a FP or a vector FP type.
321  bool isFloatingPoint() const {
322  return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
328  }
329 
330  /// Return true if this is an integer or a vector integer type.
331  bool isInteger() const {
338  }
339 
340  /// Return true if this is an integer, not including vectors.
341  bool isScalarInteger() const {
344  }
345 
346  /// Return true if this is a vector value type.
347  bool isVector() const {
350  }
351 
352  /// Return true if this is a vector value type where the
353  /// runtime length is machine dependent
354  bool isScalableVector() const {
357  }
358 
359  bool isFixedLengthVector() const {
362  }
363 
364  /// Return true if this is a 16-bit vector type.
365  bool is16BitVector() const {
366  return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 ||
368  }
369 
370  /// Return true if this is a 32-bit vector type.
371  bool is32BitVector() const {
372  return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8 ||
375  SimpleTy == MVT::v1f32);
376  }
377 
378  /// Return true if this is a 64-bit vector type.
379  bool is64BitVector() const {
380  return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8 ||
384  SimpleTy == MVT::v1f64);
385  }
386 
387  /// Return true if this is a 128-bit vector type.
388  bool is128BitVector() const {
389  return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8 ||
394  }
395 
396  /// Return true if this is a 256-bit vector type.
397  bool is256BitVector() const {
398  return (SimpleTy == MVT::v16f16 || SimpleTy == MVT::v16bf16 ||
402  SimpleTy == MVT::v256i1);
403  }
404 
405  /// Return true if this is a 512-bit vector type.
406  bool is512BitVector() const {
407  return (SimpleTy == MVT::v32f16 || SimpleTy == MVT::v32bf16 ||
411  SimpleTy == MVT::v8i64);
412  }
413 
414  /// Return true if this is a 1024-bit vector type.
415  bool is1024BitVector() const {
416  return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
421  }
422 
423  /// Return true if this is a 2048-bit vector type.
424  bool is2048BitVector() const {
425  return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
429  }
430 
431  /// Return true if this is an overloaded type for TableGen.
432  bool isOverloaded() const {
433  return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
436  }
437 
438  /// Return a vector with the same number of elements as this vector, but
439  /// with the element type converted to an integer type with the same
440  /// bitwidth.
442  MVT EltTy = getVectorElementType();
443  MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
444  MVT VecTy = MVT::getVectorVT(IntTy, getVectorElementCount());
446  "Simple vector VT not representable by simple integer vector VT!");
447  return VecTy;
448  }
449 
450  /// Return a VT for a vector type whose attributes match ourselves
451  /// with the exception of the element type that is chosen by the caller.
453  MVT VecTy = MVT::getVectorVT(EltVT, getVectorElementCount());
455  "Simple vector VT not representable by simple integer vector VT!");
456  return VecTy;
457  }
458 
459  /// Return the type converted to an equivalently sized integer or vector
460  /// with integer element type. Similar to changeVectorElementTypeToInteger,
461  /// but also handles scalars.
463  if (isVector())
466  }
467 
468  /// Return a VT for a vector type with the same element type but
469  /// half the number of elements.
471  MVT EltVT = getVectorElementType();
472  auto EltCnt = getVectorElementCount();
473  assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
474  return getVectorVT(EltVT, EltCnt.divideCoefficientBy(2));
475  }
476 
477  /// Returns true if the given vector is a power of 2.
478  bool isPow2VectorType() const {
479  unsigned NElts = getVectorNumElements();
480  return !(NElts & (NElts - 1));
481  }
482 
483  /// Widens the length of the given vector MVT up to the nearest power of 2
484  /// and returns that type.
486  if (isPow2VectorType())
487  return *this;
488 
489  unsigned NElts = getVectorNumElements();
490  unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
491  return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
492  }
493 
494  /// If this is a vector, return the element type, otherwise return this.
495  MVT getScalarType() const {
496  return isVector() ? getVectorElementType() : *this;
497  }
498 
500  switch (SimpleTy) {
501  default:
502  llvm_unreachable("Not a vector MVT!");
503  case v1i1:
504  case v2i1:
505  case v4i1:
506  case v8i1:
507  case v16i1:
508  case v32i1:
509  case v64i1:
510  case v128i1:
511  case v256i1:
512  case v512i1:
513  case v1024i1:
514  case nxv1i1:
515  case nxv2i1:
516  case nxv4i1:
517  case nxv8i1:
518  case nxv16i1:
519  case nxv32i1:
520  case nxv64i1: return i1;
521  case v1i8:
522  case v2i8:
523  case v4i8:
524  case v8i8:
525  case v16i8:
526  case v32i8:
527  case v64i8:
528  case v128i8:
529  case v256i8:
530  case nxv1i8:
531  case nxv2i8:
532  case nxv4i8:
533  case nxv8i8:
534  case nxv16i8:
535  case nxv32i8:
536  case nxv64i8: return i8;
537  case v1i16:
538  case v2i16:
539  case v3i16:
540  case v4i16:
541  case v8i16:
542  case v16i16:
543  case v32i16:
544  case v64i16:
545  case v128i16:
546  case nxv1i16:
547  case nxv2i16:
548  case nxv4i16:
549  case nxv8i16:
550  case nxv16i16:
551  case nxv32i16: return i16;
552  case v1i32:
553  case v2i32:
554  case v3i32:
555  case v4i32:
556  case v5i32:
557  case v8i32:
558  case v16i32:
559  case v32i32:
560  case v64i32:
561  case v128i32:
562  case v256i32:
563  case v512i32:
564  case v1024i32:
565  case v2048i32:
566  case nxv1i32:
567  case nxv2i32:
568  case nxv4i32:
569  case nxv8i32:
570  case nxv16i32:
571  case nxv32i32: return i32;
572  case v1i64:
573  case v2i64:
574  case v4i64:
575  case v8i64:
576  case v16i64:
577  case v32i64:
578  case v64i64:
579  case v128i64:
580  case v256i64:
581  case nxv1i64:
582  case nxv2i64:
583  case nxv4i64:
584  case nxv8i64:
585  case nxv16i64:
586  case nxv32i64: return i64;
587  case v1i128: return i128;
588  case v1f16:
589  case v2f16:
590  case v3f16:
591  case v4f16:
592  case v8f16:
593  case v16f16:
594  case v32f16:
595  case v64f16:
596  case v128f16:
597  case nxv1f16:
598  case nxv2f16:
599  case nxv4f16:
600  case nxv8f16:
601  case nxv16f16:
602  case nxv32f16: return f16;
603  case v2bf16:
604  case v3bf16:
605  case v4bf16:
606  case v8bf16:
607  case v16bf16:
608  case v32bf16:
609  case v64bf16:
610  case v128bf16:
611  case nxv1bf16:
612  case nxv2bf16:
613  case nxv4bf16:
614  case nxv8bf16: return bf16;
615  case v1f32:
616  case v2f32:
617  case v3f32:
618  case v4f32:
619  case v5f32:
620  case v8f32:
621  case v16f32:
622  case v32f32:
623  case v64f32:
624  case v128f32:
625  case v256f32:
626  case v512f32:
627  case v1024f32:
628  case v2048f32:
629  case nxv1f32:
630  case nxv2f32:
631  case nxv4f32:
632  case nxv8f32:
633  case nxv16f32: return f32;
634  case v1f64:
635  case v2f64:
636  case v4f64:
637  case v8f64:
638  case v16f64:
639  case v32f64:
640  case v64f64:
641  case v128f64:
642  case v256f64:
643  case nxv1f64:
644  case nxv2f64:
645  case nxv4f64:
646  case nxv8f64: return f64;
647  }
648  }
649 
650  unsigned getVectorNumElements() const {
651  switch (SimpleTy) {
652  default:
653  llvm_unreachable("Not a vector MVT!");
654  case v2048i32:
655  case v2048f32: return 2048;
656  case v1024i1:
657  case v1024i32:
658  case v1024f32: return 1024;
659  case v512i1:
660  case v512i32:
661  case v512f32: return 512;
662  case v256i1:
663  case v256i8:
664  case v256i32:
665  case v256i64:
666  case v256f32:
667  case v256f64: return 256;
668  case v128i1:
669  case v128i8:
670  case v128i16:
671  case v128i32:
672  case v128i64:
673  case v128f16:
674  case v128bf16:
675  case v128f32:
676  case v128f64: return 128;
677  case v64i1:
678  case v64i8:
679  case v64i16:
680  case v64i32:
681  case v64i64:
682  case v64f16:
683  case v64bf16:
684  case v64f32:
685  case v64f64:
686  case nxv64i1:
687  case nxv64i8: return 64;
688  case v32i1:
689  case v32i8:
690  case v32i16:
691  case v32i32:
692  case v32i64:
693  case v32f16:
694  case v32bf16:
695  case v32f32:
696  case v32f64:
697  case nxv32i1:
698  case nxv32i8:
699  case nxv32i16:
700  case nxv32i32:
701  case nxv32i64:
702  case nxv32f16: return 32;
703  case v16i1:
704  case v16i8:
705  case v16i16:
706  case v16i32:
707  case v16i64:
708  case v16f16:
709  case v16bf16:
710  case v16f32:
711  case v16f64:
712  case nxv16i1:
713  case nxv16i8:
714  case nxv16i16:
715  case nxv16i32:
716  case nxv16i64:
717  case nxv16f16:
718  case nxv16f32: return 16;
719  case v8i1:
720  case v8i8:
721  case v8i16:
722  case v8i32:
723  case v8i64:
724  case v8f16:
725  case v8bf16:
726  case v8f32:
727  case v8f64:
728  case nxv8i1:
729  case nxv8i8:
730  case nxv8i16:
731  case nxv8i32:
732  case nxv8i64:
733  case nxv8f16:
734  case nxv8bf16:
735  case nxv8f32:
736  case nxv8f64: return 8;
737  case v5i32:
738  case v5f32: return 5;
739  case v4i1:
740  case v4i8:
741  case v4i16:
742  case v4i32:
743  case v4i64:
744  case v4f16:
745  case v4bf16:
746  case v4f32:
747  case v4f64:
748  case nxv4i1:
749  case nxv4i8:
750  case nxv4i16:
751  case nxv4i32:
752  case nxv4i64:
753  case nxv4f16:
754  case nxv4bf16:
755  case nxv4f32:
756  case nxv4f64: return 4;
757  case v3i16:
758  case v3i32:
759  case v3f16:
760  case v3bf16:
761  case v3f32: return 3;
762  case v2i1:
763  case v2i8:
764  case v2i16:
765  case v2i32:
766  case v2i64:
767  case v2f16:
768  case v2bf16:
769  case v2f32:
770  case v2f64:
771  case nxv2i1:
772  case nxv2i8:
773  case nxv2i16:
774  case nxv2i32:
775  case nxv2i64:
776  case nxv2f16:
777  case nxv2bf16:
778  case nxv2f32:
779  case nxv2f64: return 2;
780  case v1i1:
781  case v1i8:
782  case v1i16:
783  case v1i32:
784  case v1i64:
785  case v1i128:
786  case v1f16:
787  case v1f32:
788  case v1f64:
789  case nxv1i1:
790  case nxv1i8:
791  case nxv1i16:
792  case nxv1i32:
793  case nxv1i64:
794  case nxv1f16:
795  case nxv1bf16:
796  case nxv1f32:
797  case nxv1f64: return 1;
798  }
799  }
800 
803  }
804 
805  /// Given a vector type, return the minimum number of elements it contains.
806  unsigned getVectorMinNumElements() const {
808  }
809 
810  /// Returns the size of the specified MVT in bits.
811  ///
812  /// If the value type is a scalable vector type, the scalable property will
813  /// be set and the runtime size will be a positive integer multiple of the
814  /// base size.
816  switch (SimpleTy) {
817  default:
818  llvm_unreachable("getSizeInBits called on extended MVT.");
819  case Other:
820  llvm_unreachable("Value type is non-standard value, Other.");
821  case iPTR:
822  llvm_unreachable("Value type size is target-dependent. Ask TLI.");
823  case iPTRAny:
824  case iAny:
825  case fAny:
826  case vAny:
827  case Any:
828  llvm_unreachable("Value type is overloaded.");
829  case token:
830  llvm_unreachable("Token type is a sentinel that cannot be used "
831  "in codegen and has no size");
832  case Metadata:
833  llvm_unreachable("Value type is metadata.");
834  case i1:
835  case v1i1: return TypeSize::Fixed(1);
836  case nxv1i1: return TypeSize::Scalable(1);
837  case v2i1: return TypeSize::Fixed(2);
838  case nxv2i1: return TypeSize::Scalable(2);
839  case v4i1: return TypeSize::Fixed(4);
840  case nxv4i1: return TypeSize::Scalable(4);
841  case i8 :
842  case v1i8:
843  case v8i1: return TypeSize::Fixed(8);
844  case nxv1i8:
845  case nxv8i1: return TypeSize::Scalable(8);
846  case i16 :
847  case f16:
848  case bf16:
849  case v16i1:
850  case v2i8:
851  case v1i16:
852  case v1f16: return TypeSize::Fixed(16);
853  case nxv16i1:
854  case nxv2i8:
855  case nxv1i16:
856  case nxv1bf16:
857  case nxv1f16: return TypeSize::Scalable(16);
858  case f32 :
859  case i32 :
860  case v32i1:
861  case v4i8:
862  case v2i16:
863  case v2f16:
864  case v2bf16:
865  case v1f32:
866  case v1i32: return TypeSize::Fixed(32);
867  case nxv32i1:
868  case nxv4i8:
869  case nxv2i16:
870  case nxv1i32:
871  case nxv2f16:
872  case nxv2bf16:
873  case nxv1f32: return TypeSize::Scalable(32);
874  case v3i16:
875  case v3f16:
876  case v3bf16: return TypeSize::Fixed(48);
877  case x86mmx:
878  case f64 :
879  case i64 :
880  case v64i1:
881  case v8i8:
882  case v4i16:
883  case v2i32:
884  case v1i64:
885  case v4f16:
886  case v4bf16:
887  case v2f32:
888  case v1f64: return TypeSize::Fixed(64);
889  case nxv64i1:
890  case nxv8i8:
891  case nxv4i16:
892  case nxv2i32:
893  case nxv1i64:
894  case nxv4f16:
895  case nxv4bf16:
896  case nxv2f32:
897  case nxv1f64: return TypeSize::Scalable(64);
898  case f80 : return TypeSize::Fixed(80);
899  case v3i32:
900  case v3f32: return TypeSize::Fixed(96);
901  case f128:
902  case ppcf128:
903  case i128:
904  case v128i1:
905  case v16i8:
906  case v8i16:
907  case v4i32:
908  case v2i64:
909  case v1i128:
910  case v8f16:
911  case v8bf16:
912  case v4f32:
913  case v2f64: return TypeSize::Fixed(128);
914  case nxv16i8:
915  case nxv8i16:
916  case nxv4i32:
917  case nxv2i64:
918  case nxv8f16:
919  case nxv8bf16:
920  case nxv4f32:
921  case nxv2f64: return TypeSize::Scalable(128);
922  case v5i32:
923  case v5f32: return TypeSize::Fixed(160);
924  case v256i1:
925  case v32i8:
926  case v16i16:
927  case v8i32:
928  case v4i64:
929  case v16f16:
930  case v16bf16:
931  case v8f32:
932  case v4f64: return TypeSize::Fixed(256);
933  case nxv32i8:
934  case nxv16i16:
935  case nxv8i32:
936  case nxv4i64:
937  case nxv16f16:
938  case nxv8f32:
939  case nxv4f64: return TypeSize::Scalable(256);
940  case v512i1:
941  case v64i8:
942  case v32i16:
943  case v16i32:
944  case v8i64:
945  case v32f16:
946  case v32bf16:
947  case v16f32:
948  case v8f64: return TypeSize::Fixed(512);
949  case nxv64i8:
950  case nxv32i16:
951  case nxv16i32:
952  case nxv8i64:
953  case nxv32f16:
954  case nxv16f32:
955  case nxv8f64: return TypeSize::Scalable(512);
956  case v1024i1:
957  case v128i8:
958  case v64i16:
959  case v32i32:
960  case v16i64:
961  case v64f16:
962  case v64bf16:
963  case v32f32:
964  case v16f64: return TypeSize::Fixed(1024);
965  case nxv32i32:
966  case nxv16i64: return TypeSize::Scalable(1024);
967  case v256i8:
968  case v128i16:
969  case v64i32:
970  case v32i64:
971  case v128f16:
972  case v128bf16:
973  case v64f32:
974  case v32f64: return TypeSize::Fixed(2048);
975  case nxv32i64: return TypeSize::Scalable(2048);
976  case v128i32:
977  case v64i64:
978  case v128f32:
979  case v64f64: return TypeSize::Fixed(4096);
980  case v256i32:
981  case v128i64:
982  case v256f32:
983  case x86amx:
984  case v128f64: return TypeSize::Fixed(8192);
985  case v512i32:
986  case v256i64:
987  case v512f32:
988  case v256f64: return TypeSize::Fixed(16384);
989  case v1024i32:
990  case v1024f32: return TypeSize::Fixed(32768);
991  case v2048i32:
992  case v2048f32: return TypeSize::Fixed(65536);
993  case funcref:
994  case externref: return TypeSize::Fixed(0); // opaque type
995  }
996  }
997 
998  /// Return the size of the specified fixed width value type in bits. The
999  /// function will assert if the type is scalable.
1000  uint64_t getFixedSizeInBits() const {
1001  return getSizeInBits().getFixedSize();
1002  }
1003 
1004  uint64_t getScalarSizeInBits() const {
1006  }
1007 
1008  /// Return the number of bytes overwritten by a store of the specified value
1009  /// type.
1010  ///
1011  /// If the value type is a scalable vector type, the scalable property will
1012  /// be set and the runtime size will be a positive integer multiple of the
1013  /// base size.
1015  TypeSize BaseSize = getSizeInBits();
1016  return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
1017  }
1018 
1019  /// Return the number of bits overwritten by a store of the specified value
1020  /// type.
1021  ///
1022  /// If the value type is a scalable vector type, the scalable property will
1023  /// be set and the runtime size will be a positive integer multiple of the
1024  /// base size.
1026  return getStoreSize() * 8;
1027  }
1028 
1029  /// Returns true if the number of bits for the type is a multiple of an
1030  /// 8-bit byte.
1031  bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
1032 
1033  /// Return true if we know at compile time this has more bits than VT.
1034  bool knownBitsGT(MVT VT) const {
1036  }
1037 
1038  /// Return true if we know at compile time this has more than or the same
1039  /// bits as VT.
1040  bool knownBitsGE(MVT VT) const {
1042  }
1043 
1044  /// Return true if we know at compile time this has fewer bits than VT.
1045  bool knownBitsLT(MVT VT) const {
1047  }
1048 
1049  /// Return true if we know at compile time this has fewer than or the same
1050  /// bits as VT.
1051  bool knownBitsLE(MVT VT) const {
1053  }
1054 
1055  /// Return true if this has more bits than VT.
1056  bool bitsGT(MVT VT) const {
1058  "Comparison between scalable and fixed types");
1059  return knownBitsGT(VT);
1060  }
1061 
1062  /// Return true if this has no less bits than VT.
1063  bool bitsGE(MVT VT) const {
1065  "Comparison between scalable and fixed types");
1066  return knownBitsGE(VT);
1067  }
1068 
1069  /// Return true if this has less bits than VT.
1070  bool bitsLT(MVT VT) const {
1072  "Comparison between scalable and fixed types");
1073  return knownBitsLT(VT);
1074  }
1075 
1076  /// Return true if this has no more bits than VT.
1077  bool bitsLE(MVT VT) const {
1079  "Comparison between scalable and fixed types");
1080  return knownBitsLE(VT);
1081  }
1082 
1083  static MVT getFloatingPointVT(unsigned BitWidth) {
1084  switch (BitWidth) {
1085  default:
1086  llvm_unreachable("Bad bit width!");
1087  case 16:
1088  return MVT::f16;
1089  case 32:
1090  return MVT::f32;
1091  case 64:
1092  return MVT::f64;
1093  case 80:
1094  return MVT::f80;
1095  case 128:
1096  return MVT::f128;
1097  }
1098  }
1099 
1100  static MVT getIntegerVT(unsigned BitWidth) {
1101  switch (BitWidth) {
1102  default:
1104  case 1:
1105  return MVT::i1;
1106  case 8:
1107  return MVT::i8;
1108  case 16:
1109  return MVT::i16;
1110  case 32:
1111  return MVT::i32;
1112  case 64:
1113  return MVT::i64;
1114  case 128:
1115  return MVT::i128;
1116  }
1117  }
1118 
1119  static MVT getVectorVT(MVT VT, unsigned NumElements) {
1120  switch (VT.SimpleTy) {
1121  default:
1122  break;
1123  case MVT::i1:
1124  if (NumElements == 1) return MVT::v1i1;
1125  if (NumElements == 2) return MVT::v2i1;
1126  if (NumElements == 4) return MVT::v4i1;
1127  if (NumElements == 8) return MVT::v8i1;
1128  if (NumElements == 16) return MVT::v16i1;
1129  if (NumElements == 32) return MVT::v32i1;
1130  if (NumElements == 64) return MVT::v64i1;
1131  if (NumElements == 128) return MVT::v128i1;
1132  if (NumElements == 256) return MVT::v256i1;
1133  if (NumElements == 512) return MVT::v512i1;
1134  if (NumElements == 1024) return MVT::v1024i1;
1135  break;
1136  case MVT::i8:
1137  if (NumElements == 1) return MVT::v1i8;
1138  if (NumElements == 2) return MVT::v2i8;
1139  if (NumElements == 4) return MVT::v4i8;
1140  if (NumElements == 8) return MVT::v8i8;
1141  if (NumElements == 16) return MVT::v16i8;
1142  if (NumElements == 32) return MVT::v32i8;
1143  if (NumElements == 64) return MVT::v64i8;
1144  if (NumElements == 128) return MVT::v128i8;
1145  if (NumElements == 256) return MVT::v256i8;
1146  break;
1147  case MVT::i16:
1148  if (NumElements == 1) return MVT::v1i16;
1149  if (NumElements == 2) return MVT::v2i16;
1150  if (NumElements == 3) return MVT::v3i16;
1151  if (NumElements == 4) return MVT::v4i16;
1152  if (NumElements == 8) return MVT::v8i16;
1153  if (NumElements == 16) return MVT::v16i16;
1154  if (NumElements == 32) return MVT::v32i16;
1155  if (NumElements == 64) return MVT::v64i16;
1156  if (NumElements == 128) return MVT::v128i16;
1157  break;
1158  case MVT::i32:
1159  if (NumElements == 1) return MVT::v1i32;
1160  if (NumElements == 2) return MVT::v2i32;
1161  if (NumElements == 3) return MVT::v3i32;
1162  if (NumElements == 4) return MVT::v4i32;
1163  if (NumElements == 5) return MVT::v5i32;
1164  if (NumElements == 8) return MVT::v8i32;
1165  if (NumElements == 16) return MVT::v16i32;
1166  if (NumElements == 32) return MVT::v32i32;
1167  if (NumElements == 64) return MVT::v64i32;
1168  if (NumElements == 128) return MVT::v128i32;
1169  if (NumElements == 256) return MVT::v256i32;
1170  if (NumElements == 512) return MVT::v512i32;
1171  if (NumElements == 1024) return MVT::v1024i32;
1172  if (NumElements == 2048) return MVT::v2048i32;
1173  break;
1174  case MVT::i64:
1175  if (NumElements == 1) return MVT::v1i64;
1176  if (NumElements == 2) return MVT::v2i64;
1177  if (NumElements == 4) return MVT::v4i64;
1178  if (NumElements == 8) return MVT::v8i64;
1179  if (NumElements == 16) return MVT::v16i64;
1180  if (NumElements == 32) return MVT::v32i64;
1181  if (NumElements == 64) return MVT::v64i64;
1182  if (NumElements == 128) return MVT::v128i64;
1183  if (NumElements == 256) return MVT::v256i64;
1184  break;
1185  case MVT::i128:
1186  if (NumElements == 1) return MVT::v1i128;
1187  break;
1188  case MVT::f16:
1189  if (NumElements == 1) return MVT::v1f16;
1190  if (NumElements == 2) return MVT::v2f16;
1191  if (NumElements == 3) return MVT::v3f16;
1192  if (NumElements == 4) return MVT::v4f16;
1193  if (NumElements == 8) return MVT::v8f16;
1194  if (NumElements == 16) return MVT::v16f16;
1195  if (NumElements == 32) return MVT::v32f16;
1196  if (NumElements == 64) return MVT::v64f16;
1197  if (NumElements == 128) return MVT::v128f16;
1198  break;
1199  case MVT::bf16:
1200  if (NumElements == 2) return MVT::v2bf16;
1201  if (NumElements == 3) return MVT::v3bf16;
1202  if (NumElements == 4) return MVT::v4bf16;
1203  if (NumElements == 8) return MVT::v8bf16;
1204  if (NumElements == 16) return MVT::v16bf16;
1205  if (NumElements == 32) return MVT::v32bf16;
1206  if (NumElements == 64) return MVT::v64bf16;
1207  if (NumElements == 128) return MVT::v128bf16;
1208  break;
1209  case MVT::f32:
1210  if (NumElements == 1) return MVT::v1f32;
1211  if (NumElements == 2) return MVT::v2f32;
1212  if (NumElements == 3) return MVT::v3f32;
1213  if (NumElements == 4) return MVT::v4f32;
1214  if (NumElements == 5) return MVT::v5f32;
1215  if (NumElements == 8) return MVT::v8f32;
1216  if (NumElements == 16) return MVT::v16f32;
1217  if (NumElements == 32) return MVT::v32f32;
1218  if (NumElements == 64) return MVT::v64f32;
1219  if (NumElements == 128) return MVT::v128f32;
1220  if (NumElements == 256) return MVT::v256f32;
1221  if (NumElements == 512) return MVT::v512f32;
1222  if (NumElements == 1024) return MVT::v1024f32;
1223  if (NumElements == 2048) return MVT::v2048f32;
1224  break;
1225  case MVT::f64:
1226  if (NumElements == 1) return MVT::v1f64;
1227  if (NumElements == 2) return MVT::v2f64;
1228  if (NumElements == 4) return MVT::v4f64;
1229  if (NumElements == 8) return MVT::v8f64;
1230  if (NumElements == 16) return MVT::v16f64;
1231  if (NumElements == 32) return MVT::v32f64;
1232  if (NumElements == 64) return MVT::v64f64;
1233  if (NumElements == 128) return MVT::v128f64;
1234  if (NumElements == 256) return MVT::v256f64;
1235  break;
1236  }
1238  }
1239 
1240  static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
1241  switch(VT.SimpleTy) {
1242  default:
1243  break;
1244  case MVT::i1:
1245  if (NumElements == 1) return MVT::nxv1i1;
1246  if (NumElements == 2) return MVT::nxv2i1;
1247  if (NumElements == 4) return MVT::nxv4i1;
1248  if (NumElements == 8) return MVT::nxv8i1;
1249  if (NumElements == 16) return MVT::nxv16i1;
1250  if (NumElements == 32) return MVT::nxv32i1;
1251  if (NumElements == 64) return MVT::nxv64i1;
1252  break;
1253  case MVT::i8:
1254  if (NumElements == 1) return MVT::nxv1i8;
1255  if (NumElements == 2) return MVT::nxv2i8;
1256  if (NumElements == 4) return MVT::nxv4i8;
1257  if (NumElements == 8) return MVT::nxv8i8;
1258  if (NumElements == 16) return MVT::nxv16i8;
1259  if (NumElements == 32) return MVT::nxv32i8;
1260  if (NumElements == 64) return MVT::nxv64i8;
1261  break;
1262  case MVT::i16:
1263  if (NumElements == 1) return MVT::nxv1i16;
1264  if (NumElements == 2) return MVT::nxv2i16;
1265  if (NumElements == 4) return MVT::nxv4i16;
1266  if (NumElements == 8) return MVT::nxv8i16;
1267  if (NumElements == 16) return MVT::nxv16i16;
1268  if (NumElements == 32) return MVT::nxv32i16;
1269  break;
1270  case MVT::i32:
1271  if (NumElements == 1) return MVT::nxv1i32;
1272  if (NumElements == 2) return MVT::nxv2i32;
1273  if (NumElements == 4) return MVT::nxv4i32;
1274  if (NumElements == 8) return MVT::nxv8i32;
1275  if (NumElements == 16) return MVT::nxv16i32;
1276  if (NumElements == 32) return MVT::nxv32i32;
1277  break;
1278  case MVT::i64:
1279  if (NumElements == 1) return MVT::nxv1i64;
1280  if (NumElements == 2) return MVT::nxv2i64;
1281  if (NumElements == 4) return MVT::nxv4i64;
1282  if (NumElements == 8) return MVT::nxv8i64;
1283  if (NumElements == 16) return MVT::nxv16i64;
1284  if (NumElements == 32) return MVT::nxv32i64;
1285  break;
1286  case MVT::f16:
1287  if (NumElements == 1) return MVT::nxv1f16;
1288  if (NumElements == 2) return MVT::nxv2f16;
1289  if (NumElements == 4) return MVT::nxv4f16;
1290  if (NumElements == 8) return MVT::nxv8f16;
1291  if (NumElements == 16) return MVT::nxv16f16;
1292  if (NumElements == 32) return MVT::nxv32f16;
1293  break;
1294  case MVT::bf16:
1295  if (NumElements == 1) return MVT::nxv1bf16;
1296  if (NumElements == 2) return MVT::nxv2bf16;
1297  if (NumElements == 4) return MVT::nxv4bf16;
1298  if (NumElements == 8) return MVT::nxv8bf16;
1299  break;
1300  case MVT::f32:
1301  if (NumElements == 1) return MVT::nxv1f32;
1302  if (NumElements == 2) return MVT::nxv2f32;
1303  if (NumElements == 4) return MVT::nxv4f32;
1304  if (NumElements == 8) return MVT::nxv8f32;
1305  if (NumElements == 16) return MVT::nxv16f32;
1306  break;
1307  case MVT::f64:
1308  if (NumElements == 1) return MVT::nxv1f64;
1309  if (NumElements == 2) return MVT::nxv2f64;
1310  if (NumElements == 4) return MVT::nxv4f64;
1311  if (NumElements == 8) return MVT::nxv8f64;
1312  break;
1313  }
1315  }
1316 
1317  static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
1318  if (IsScalable)
1319  return getScalableVectorVT(VT, NumElements);
1320  return getVectorVT(VT, NumElements);
1321  }
1322 
1323  static MVT getVectorVT(MVT VT, ElementCount EC) {
1324  if (EC.isScalable())
1325  return getScalableVectorVT(VT, EC.getKnownMinValue());
1326  return getVectorVT(VT, EC.getKnownMinValue());
1327  }
1328 
1329  /// Return the value type corresponding to the specified type. This returns
1330  /// all pointers as iPTR. If HandleUnknown is true, unknown types are
1331  /// returned as Other, otherwise they are invalid.
1332  static MVT getVT(Type *Ty, bool HandleUnknown = false);
1333 
1334  private:
1335  /// A simple iterator over the MVT::SimpleValueType enum.
1336  struct mvt_iterator {
1337  SimpleValueType VT;
1338 
1339  mvt_iterator(SimpleValueType VT) : VT(VT) {}
1340 
1341  MVT operator*() const { return VT; }
1342  bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; }
1343 
1344  mvt_iterator& operator++() {
1345  VT = (MVT::SimpleValueType)((int)VT + 1);
1346  assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
1347  "MVT iterator overflowed.");
1348  return *this;
1349  }
1350  };
1351 
1352  /// A range of the MVT::SimpleValueType enum.
1353  using mvt_range = iterator_range<mvt_iterator>;
1354 
1355  public:
1356  /// SimpleValueType Iteration
1357  /// @{
1360  }
1361 
1365  }
1366 
1370  }
1371 
1375  }
1376 
1378  return mvt_range(
1381  }
1382 
1384  return mvt_range(
1387  }
1388 
1390  return mvt_range(
1393  }
1394 
1396  return mvt_range(
1399  }
1400 
1402  return mvt_range(
1405  }
1406 
1408  return mvt_range(
1411  }
1412  /// @}
1413  };
1414 
1415 } // end namespace llvm
1416 
1417 #endif // LLVM_SUPPORT_MACHINEVALUETYPE_H
llvm::MVT::v3i16
@ v3i16
Definition: MachineValueType.h:85
llvm::MVT::nxv4i1
@ nxv4i1
Definition: MachineValueType.h:175
llvm::MVT::v1i16
@ v1i16
Definition: MachineValueType.h:83
llvm::MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE
@ FIRST_FP_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:236
llvm::MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE
@ FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:210
llvm::MVT::nxv4i64
@ nxv4i64
Definition: MachineValueType.h:205
llvm::MVT::v16bf16
@ v16bf16
Definition: MachineValueType.h:137
llvm::MVT::FIRST_SCALABLE_VECTOR_VALUETYPE
@ FIRST_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:239
llvm::MVT::nxv2i1
@ nxv2i1
Definition: MachineValueType.h:174
llvm::MVT::getVectorElementType
MVT getVectorElementType() const
Definition: MachineValueType.h:499
llvm::MVT::getStoreSize
TypeSize getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
Definition: MachineValueType.h:1014
llvm::MVT::v4f16
@ v4f16
Definition: MachineValueType.h:126
MathExtras.h
llvm
Definition: AllocatorList.h:23
llvm::MVT::v128i1
@ v128i1
Definition: MachineValueType.h:68
llvm::MVT::nxv1i32
@ nxv1i32
Definition: MachineValueType.h:196
llvm::MVT::getFixedSizeInBits
uint64_t getFixedSizeInBits() const
Return the size of the specified fixed width value type in bits.
Definition: MachineValueType.h:1000
llvm::MVT::isByteSized
bool isByteSized() const
Returns true if the number of bits for the type is a multiple of an 8-bit byte.
Definition: MachineValueType.h:1031
llvm::MVT::nxv2f64
@ nxv2f64
Definition: MachineValueType.h:232
llvm::MVT::operator>=
bool operator>=(const MVT &S) const
Definition: MachineValueType.h:311
llvm::MVT::isFixedLengthVector
bool isFixedLengthVector() const
Definition: MachineValueType.h:359
llvm::MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE
@ LAST_FP_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:168
llvm::MVT::isInteger
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: MachineValueType.h:331
llvm::MVT::v1f64
@ v1f64
Definition: MachineValueType.h:157
llvm::LinearPolySize< TypeSize >::isKnownGT
static bool isKnownGT(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:335
llvm::ElementCount
Definition: TypeSize.h:386
llvm::MVT::v128i32
@ v128i32
Definition: MachineValueType.h:102
llvm::TypeSize::getFixedSize
ScalarTy getFixedSize() const
Definition: TypeSize.h:426
llvm::MVT::ppcf128
@ ppcf128
Definition: MachineValueType.h:56
llvm::MVT::is256BitVector
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: MachineValueType.h:397
llvm::MVT::nxv32f16
@ nxv32f16
Definition: MachineValueType.h:218
llvm::MVT::v32f64
@ v32f64
Definition: MachineValueType.h:162
llvm::MVT::i128
@ i128
Definition: MachineValueType.h:45
llvm::MVT::nxv2f32
@ nxv2f32
Definition: MachineValueType.h:226
llvm::MVT::nxv16f16
@ nxv16f16
Definition: MachineValueType.h:217
llvm::MVT::v16f64
@ v16f64
Definition: MachineValueType.h:161
TypeSize.h
llvm::MVT::bitsLT
bool bitsLT(MVT VT) const
Return true if this has less bits than VT.
Definition: MachineValueType.h:1070
llvm::LinearPolySize< TypeSize >::isKnownLE
static bool isKnownLE(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:341
llvm::MVT::isVector
bool isVector() const
Return true if this is a vector value type.
Definition: MachineValueType.h:347
llvm::MVT::nxv1f64
@ nxv1f64
Definition: MachineValueType.h:231
llvm::MVT::v64f32
@ v64f32
Definition: MachineValueType.h:150
llvm::MVT::v2i1
@ v2i1
Definition: MachineValueType.h:62
ErrorHandling.h
llvm::MVT::v64i64
@ v64i64
Definition: MachineValueType.h:114
llvm::MVT::v512i32
@ v512i32
Definition: MachineValueType.h:104
llvm::MVT::nxv2i64
@ nxv2i64
Definition: MachineValueType.h:204
llvm::MVT::FIRST_FP_VALUETYPE
@ FIRST_FP_VALUETYPE
Definition: MachineValueType.h:58
llvm::MVT::Glue
@ Glue
Definition: MachineValueType.h:247
llvm::MVT::fAny
@ fAny
Definition: MachineValueType.h:286
llvm::MVT::v64f16
@ v64f16
Definition: MachineValueType.h:130
llvm::MVT::nxv4f16
@ nxv4f16
Definition: MachineValueType.h:215
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::MVT::fp_fixedlen_vector_valuetypes
static mvt_range fp_fixedlen_vector_valuetypes()
Definition: MachineValueType.h:1395
llvm::MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE
@ LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:121
llvm::MVT::fp_scalable_vector_valuetypes
static mvt_range fp_scalable_vector_valuetypes()
Definition: MachineValueType.h:1407
llvm::MVT::knownBitsGT
bool knownBitsGT(MVT VT) const
Return true if we know at compile time this has more bits than VT.
Definition: MachineValueType.h:1034
llvm::MVT::integer_valuetypes
static mvt_range integer_valuetypes()
Definition: MachineValueType.h:1362
llvm::MVT::nxv4f64
@ nxv4f64
Definition: MachineValueType.h:233
llvm::MVT::getPow2VectorType
MVT getPow2VectorType() const
Widens the length of the given vector MVT up to the nearest power of 2 and returns that type.
Definition: MachineValueType.h:485
llvm::MVT::v256i32
@ v256i32
Definition: MachineValueType.h:103
llvm::MVT::v2048i32
@ v2048i32
Definition: MachineValueType.h:106
llvm::MVT::LAST_VECTOR_VALUETYPE
@ LAST_VECTOR_VALUETYPE
Definition: MachineValueType.h:243
llvm::MVT::v2f64
@ v2f64
Definition: MachineValueType.h:158
llvm::MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE
@ LAST_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:171
llvm::MVT::v3f16
@ v3f16
Definition: MachineValueType.h:125
llvm::MVT::nxv8i16
@ nxv8i16
Definition: MachineValueType.h:192
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:299
llvm::MVT::is32BitVector
bool is32BitVector() const
Return true if this is a 32-bit vector type.
Definition: MachineValueType.h:371
llvm::MVT::nxv32i16
@ nxv32i16
Definition: MachineValueType.h:194
llvm::LinearPolySize< TypeSize >::isKnownLT
static bool isKnownLT(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:329
llvm::MVT::v128bf16
@ v128bf16
Definition: MachineValueType.h:140
llvm::MVT::isScalableVector
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
Definition: MachineValueType.h:354
llvm::MVT::nxv8bf16
@ nxv8bf16
Definition: MachineValueType.h:223
llvm::MVT::SimpleValueType
SimpleValueType
Definition: MachineValueType.h:32
llvm::MVT::isValid
bool isValid() const
Return true if this is a valid simple valuetype.
Definition: MachineValueType.h:315
llvm::TypeSize::Scalable
static TypeSize Scalable(ScalarTy MinVal)
Definition: TypeSize.h:424
llvm::MVT::v4bf16
@ v4bf16
Definition: MachineValueType.h:135
llvm::MVT::funcref
@ funcref
Definition: MachineValueType.h:255
llvm::MVT::v256f32
@ v256f32
Definition: MachineValueType.h:152
llvm::MVT::MVT
constexpr MVT()=default
llvm::MVT::i1
@ i1
Definition: MachineValueType.h:40
llvm::MVT::nxv16f32
@ nxv16f32
Definition: MachineValueType.h:229
llvm::MVT::v8f16
@ v8f16
Definition: MachineValueType.h:127
llvm::MVT::operator<
bool operator<(const MVT &S) const
Definition: MachineValueType.h:308
llvm::LinearPolySize< ElementCount >::get
static ElementCount get(ScalarTy MinVal, bool Scalable)
Definition: TypeSize.h:290
llvm::MVT::v8f64
@ v8f64
Definition: MachineValueType.h:160
llvm::MVT::changeTypeToInteger
MVT changeTypeToInteger()
Return the type converted to an equivalently sized integer or vector with integer element type.
Definition: MachineValueType.h:462
llvm::MVT::knownBitsLE
bool knownBitsLE(MVT VT) const
Return true if we know at compile time this has fewer than or the same bits as VT.
Definition: MachineValueType.h:1051
llvm::MVT::nxv2bf16
@ nxv2bf16
Definition: MachineValueType.h:221
llvm::MVT::operator<=
bool operator<=(const MVT &S) const
Definition: MachineValueType.h:312
llvm::MVT::v32bf16
@ v32bf16
Definition: MachineValueType.h:138
llvm::MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE
@ LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:211
llvm::MVT::v1f16
@ v1f16
Definition: MachineValueType.h:123
llvm::MVT::f64
@ f64
Definition: MachineValueType.h:53
llvm::MVT::x86amx
@ x86amx
Definition: MachineValueType.h:257
llvm::MVT::getScalarSizeInBits
uint64_t getScalarSizeInBits() const
Definition: MachineValueType.h:1004
llvm::MVT::x86mmx
@ x86mmx
Definition: MachineValueType.h:245
llvm::MVT::SimpleTy
SimpleValueType SimpleTy
Definition: MachineValueType.h:302
llvm::MVT::v64i1
@ v64i1
Definition: MachineValueType.h:67
llvm::MVT::v64i32
@ v64i32
Definition: MachineValueType.h:101
llvm::MVT::nxv32i8
@ nxv32i8
Definition: MachineValueType.h:186
llvm::MVT::v16i1
@ v16i1
Definition: MachineValueType.h:65
llvm::MVT::nxv2f16
@ nxv2f16
Definition: MachineValueType.h:214
llvm::TypeSize::Fixed
static TypeSize Fixed(ScalarTy MinVal)
Definition: TypeSize.h:423
llvm::MVT::v256f64
@ v256f64
Definition: MachineValueType.h:165
llvm::MVT::isVoid
@ isVoid
Definition: MachineValueType.h:249
llvm::MVT::bitsLE
bool bitsLE(MVT VT) const
Return true if this has no more bits than VT.
Definition: MachineValueType.h:1077
llvm::MVT::v8i1
@ v8i1
Definition: MachineValueType.h:64
llvm::MVT::v4f64
@ v4f64
Definition: MachineValueType.h:159
llvm::MVT::v1i1
@ v1i1
Definition: MachineValueType.h:61
llvm::MVT::v16f16
@ v16f16
Definition: MachineValueType.h:128
llvm::MVT::nxv4i8
@ nxv4i8
Definition: MachineValueType.h:183
llvm::MVT::nxv4f32
@ nxv4f32
Definition: MachineValueType.h:227
llvm::MVT::LAST_SCALABLE_VECTOR_VALUETYPE
@ LAST_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:240
llvm::MVT::INVALID_SIMPLE_VALUE_TYPE
@ INVALID_SIMPLE_VALUE_TYPE
Definition: MachineValueType.h:35
llvm::MVT::v1024i32
@ v1024i32
Definition: MachineValueType.h:105
llvm::MVT::FIRST_INTEGER_VALUETYPE
@ FIRST_INTEGER_VALUETYPE
Definition: MachineValueType.h:47
llvm::MVT::v1i64
@ v1i64
Definition: MachineValueType.h:108
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::MVT::getVectorVT
static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable)
Definition: MachineValueType.h:1317
llvm::MVT::getStoreSizeInBits
TypeSize getStoreSizeInBits() const
Return the number of bits overwritten by a store of the specified value type.
Definition: MachineValueType.h:1025
llvm::MVT::v4i16
@ v4i16
Definition: MachineValueType.h:86
llvm::MVT::v4i8
@ v4i8
Definition: MachineValueType.h:75
llvm::MVT::nxv4i16
@ nxv4i16
Definition: MachineValueType.h:191
llvm::MVT::getScalarType
MVT getScalarType() const
If this is a vector, return the element type, otherwise return this.
Definition: MachineValueType.h:495
llvm::Log2_32_Ceil
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:609
llvm::MVT::nxv16i16
@ nxv16i16
Definition: MachineValueType.h:193
llvm::MVT::isFloatingPoint
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
Definition: MachineValueType.h:321
llvm::MVT::scalable_vector_valuetypes
static mvt_range scalable_vector_valuetypes()
Definition: MachineValueType.h:1383
llvm::MVT::f80
@ f80
Definition: MachineValueType.h:54
llvm::MVT::iPTRAny
@ iPTRAny
Definition: MachineValueType.h:276
llvm::MVT::v2i8
@ v2i8
Definition: MachineValueType.h:74
llvm::MVT::v4i64
@ v4i64
Definition: MachineValueType.h:110
llvm::MVT::v32i16
@ v32i16
Definition: MachineValueType.h:89
llvm::MVT::nxv16i8
@ nxv16i8
Definition: MachineValueType.h:185
llvm::MVT::v5f32
@ v5f32
Definition: MachineValueType.h:146
llvm::MVT::nxv1bf16
@ nxv1bf16
Definition: MachineValueType.h:220
llvm::MVT::nxv8i64
@ nxv8i64
Definition: MachineValueType.h:206
llvm::MVT::v16i8
@ v16i8
Definition: MachineValueType.h:77
llvm::MVT::bitsGE
bool bitsGE(MVT VT) const
Return true if this has no less bits than VT.
Definition: MachineValueType.h:1063
llvm::MVT::v16i16
@ v16i16
Definition: MachineValueType.h:88
llvm::MVT::v2i64
@ v2i64
Definition: MachineValueType.h:109
llvm::MVT::v2f16
@ v2f16
Definition: MachineValueType.h:124
llvm::MVT::is16BitVector
bool is16BitVector() const
Return true if this is a 16-bit vector type.
Definition: MachineValueType.h:365
llvm::MVT::MAX_ALLOWED_VALUETYPE
@ MAX_ALLOWED_VALUETYPE
Definition: MachineValueType.h:265
llvm::MVT::v32i64
@ v32i64
Definition: MachineValueType.h:113
llvm::MVT::v16f32
@ v16f32
Definition: MachineValueType.h:148
llvm::MVT::externref
@ externref
Definition: MachineValueType.h:256
llvm::MVT::v128i8
@ v128i8
Definition: MachineValueType.h:80
llvm::MVT::v1f32
@ v1f32
Definition: MachineValueType.h:142
llvm::MVT::FIRST_VALUETYPE
@ FIRST_VALUETYPE
Definition: MachineValueType.h:259
llvm::MVT::nxv32i64
@ nxv32i64
Definition: MachineValueType.h:208
llvm::MVT::v32i1
@ v32i1
Definition: MachineValueType.h:66
llvm::MVT::v2048f32
@ v2048f32
Definition: MachineValueType.h:155
llvm::MVT::vector_valuetypes
static mvt_range vector_valuetypes()
Definition: MachineValueType.h:1372
llvm::MVT::v2bf16
@ v2bf16
Definition: MachineValueType.h:133
TemplateParamKind::Type
@ Type
llvm::MVT::v4f32
@ v4f32
Definition: MachineValueType.h:145
llvm::MVT::getVectorVT
static MVT getVectorVT(MVT VT, ElementCount EC)
Definition: MachineValueType.h:1323
llvm::MVT::getVectorNumElements
unsigned getVectorNumElements() const
Definition: MachineValueType.h:650
llvm::MVT::i8
@ i8
Definition: MachineValueType.h:41
llvm::MVT::v128i16
@ v128i16
Definition: MachineValueType.h:91
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MVT::v5i32
@ v5i32
Definition: MachineValueType.h:97
llvm::MVT::nxv16i32
@ nxv16i32
Definition: MachineValueType.h:200
llvm::MVT::Other
@ Other
Definition: MachineValueType.h:39
llvm::MVT::getSizeInBits
TypeSize getSizeInBits() const
Returns the size of the specified MVT in bits.
Definition: MachineValueType.h:815
llvm::MVT::nxv64i1
@ nxv64i1
Definition: MachineValueType.h:179
llvm::MVT::nxv4i32
@ nxv4i32
Definition: MachineValueType.h:198
llvm::LinearPolySize< TypeSize >::isKnownGE
static bool isKnownGE(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:347
iterator_range.h
llvm::MVT::getFloatingPointVT
static MVT getFloatingPointVT(unsigned BitWidth)
Definition: MachineValueType.h:1083
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:30
llvm::MVT::nxv4bf16
@ nxv4bf16
Definition: MachineValueType.h:222
llvm::MVT::v256i1
@ v256i1
Definition: MachineValueType.h:69
llvm::LinearPolySize::getKnownMinValue
ScalarTy getKnownMinValue() const
Returns the minimum value this size can represent.
Definition: TypeSize.h:297
llvm::MVT::nxv1i64
@ nxv1i64
Definition: MachineValueType.h:203
llvm::MVT::bf16
@ bf16
Definition: MachineValueType.h:50
llvm::MVT::v3i32
@ v3i32
Definition: MachineValueType.h:95
llvm::LinearPolySize::isKnownMultipleOf
bool isKnownMultipleOf(ScalarTy RHS) const
This function tells the caller whether the element count is known at compile time to be a multiple of...
Definition: TypeSize.h:306
llvm::MVT::getVectorVT
static MVT getVectorVT(MVT VT, unsigned NumElements)
Definition: MachineValueType.h:1119
llvm::MVT::nxv2i32
@ nxv2i32
Definition: MachineValueType.h:197
llvm::MVT::nxv1f32
@ nxv1f32
Definition: MachineValueType.h:225
llvm::operator*
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2161
llvm::MVT::changeVectorElementTypeToInteger
MVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
Definition: MachineValueType.h:441
llvm::MVT::i64
@ i64
Definition: MachineValueType.h:44
llvm::MVT::v2i32
@ v2i32
Definition: MachineValueType.h:94
llvm::MVT::is2048BitVector
bool is2048BitVector() const
Return true if this is a 2048-bit vector type.
Definition: MachineValueType.h:424
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::MVT::v2f32
@ v2f32
Definition: MachineValueType.h:143
llvm::MVT::isPow2VectorType
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
Definition: MachineValueType.h:478
llvm::MVT::is128BitVector
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: MachineValueType.h:388
llvm::MVT::v64i8
@ v64i8
Definition: MachineValueType.h:79
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE
@ FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:167
llvm::MVT::nxv1i8
@ nxv1i8
Definition: MachineValueType.h:181
llvm::MVT::v64i16
@ v64i16
Definition: MachineValueType.h:90
llvm::MVT::nxv32i32
@ nxv32i32
Definition: MachineValueType.h:201
llvm::MVT::v4i32
@ v4i32
Definition: MachineValueType.h:96
llvm::MVT::iPTR
@ iPTR
Definition: MachineValueType.h:295
llvm::MVT::is64BitVector
bool is64BitVector() const
Return true if this is a 64-bit vector type.
Definition: MachineValueType.h:379
llvm::MVT::v512i1
@ v512i1
Definition: MachineValueType.h:70
llvm::MVT::v32i32
@ v32i32
Definition: MachineValueType.h:100
llvm::MVT::v1i128
@ v1i128
Definition: MachineValueType.h:118
llvm::MVT::v128f32
@ v128f32
Definition: MachineValueType.h:151
llvm::MVT::v8i64
@ v8i64
Definition: MachineValueType.h:111
llvm::MVT::v64bf16
@ v64bf16
Definition: MachineValueType.h:139
llvm::MVT::getVectorElementCount
ElementCount getVectorElementCount() const
Definition: MachineValueType.h:801
llvm::MVT::v16i32
@ v16i32
Definition: MachineValueType.h:99
llvm::MVT::v256i64
@ v256i64
Definition: MachineValueType.h:116
llvm::MVT::v1i32
@ v1i32
Definition: MachineValueType.h:93
llvm::MVT::all_valuetypes
static mvt_range all_valuetypes()
SimpleValueType Iteration.
Definition: MachineValueType.h:1358
llvm::MVT::nxv64i8
@ nxv64i8
Definition: MachineValueType.h:187
llvm::MVT::nxv16i1
@ nxv16i1
Definition: MachineValueType.h:177
llvm::MVT::v8bf16
@ v8bf16
Definition: MachineValueType.h:136
llvm::MVT::nxv2i16
@ nxv2i16
Definition: MachineValueType.h:190
llvm::MVT::operator>
bool operator>(const MVT &S) const
Definition: MachineValueType.h:307
llvm::Any
Definition: Any.h:26
llvm::MVT::operator!=
bool operator!=(const MVT &S) const
Definition: MachineValueType.h:310
llvm::MVT::Metadata
@ Metadata
Definition: MachineValueType.h:271
llvm::MVT::v128i64
@ v128i64
Definition: MachineValueType.h:115
llvm::MVT::v32f16
@ v32f16
Definition: MachineValueType.h:129
llvm::MVT::isOverloaded
bool isOverloaded() const
Return true if this is an overloaded type for TableGen.
Definition: MachineValueType.h:432
llvm::MVT::token
@ token
Definition: MachineValueType.h:268
llvm::MVT::fixedlen_vector_valuetypes
static mvt_range fixedlen_vector_valuetypes()
Definition: MachineValueType.h:1377
llvm::MVT::operator==
bool operator==(const MVT &S) const
Definition: MachineValueType.h:309
llvm::MVT::integer_fixedlen_vector_valuetypes
static mvt_range integer_fixedlen_vector_valuetypes()
Definition: MachineValueType.h:1389
llvm::MVT::FIRST_VECTOR_VALUETYPE
@ FIRST_VECTOR_VALUETYPE
Definition: MachineValueType.h:242
llvm::MVT::iAny
@ iAny
Definition: MachineValueType.h:291
llvm::MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE
@ FIRST_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:170
llvm::MVT::v256i8
@ v256i8
Definition: MachineValueType.h:81
llvm::MVT::v8i16
@ v8i16
Definition: MachineValueType.h:87
llvm::TypeSize
Definition: TypeSize.h:417
llvm::MVT::knownBitsGE
bool knownBitsGE(MVT VT) const
Return true if we know at compile time this has more than or the same bits as VT.
Definition: MachineValueType.h:1040
llvm::MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE
@ FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE
Definition: MachineValueType.h:120
llvm::MVT::getVectorMinNumElements
unsigned getVectorMinNumElements() const
Given a vector type, return the minimum number of elements it contains.
Definition: MachineValueType.h:806
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::MVT::i32
@ i32
Definition: MachineValueType.h:43
llvm::MVT::nxv8i8
@ nxv8i8
Definition: MachineValueType.h:184
llvm::MVT::v512f32
@ v512f32
Definition: MachineValueType.h:153
llvm::MVT::v8i32
@ v8i32
Definition: MachineValueType.h:98
llvm::MVT::v3f32
@ v3f32
Definition: MachineValueType.h:144
llvm::MVT::nxv8i32
@ nxv8i32
Definition: MachineValueType.h:199
llvm::MVT::nxv1i16
@ nxv1i16
Definition: MachineValueType.h:189
llvm::MVT::nxv8f16
@ nxv8f16
Definition: MachineValueType.h:216
llvm::MVT::v1024i1
@ v1024i1
Definition: MachineValueType.h:71
llvm::MVT::getHalfNumVectorElementsVT
MVT getHalfNumVectorElementsVT() const
Return a VT for a vector type with the same element type but half the number of elements.
Definition: MachineValueType.h:470
llvm::MVT::f128
@ f128
Definition: MachineValueType.h:55
llvm::MVT::v1i8
@ v1i8
Definition: MachineValueType.h:73
llvm::MVT::nxv8i1
@ nxv8i1
Definition: MachineValueType.h:176
llvm::MVT::Any
@ Any
Definition: MachineValueType.h:299
llvm::MVT::v64f64
@ v64f64
Definition: MachineValueType.h:163
llvm::MVT::f16
@ f16
Definition: MachineValueType.h:51
llvm::MVT::LAST_FP_VALUETYPE
@ LAST_FP_VALUETYPE
Definition: MachineValueType.h:59
llvm::MVT::v32f32
@ v32f32
Definition: MachineValueType.h:149
llvm::MVT::LAST_VALUETYPE
@ LAST_VALUETYPE
Definition: MachineValueType.h:260
llvm::MVT::nxv1i1
@ nxv1i1
Definition: MachineValueType.h:173
llvm::MVT::getVT
static MVT getVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:497
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::MVT::isScalarInteger
bool isScalarInteger() const
Return true if this is an integer, not including vectors.
Definition: MachineValueType.h:341
llvm::MVT::getScalableVectorVT
static MVT getScalableVectorVT(MVT VT, unsigned NumElements)
Definition: MachineValueType.h:1240
llvm::MVT::changeVectorElementType
MVT changeVectorElementType(MVT EltVT) const
Return a VT for a vector type whose attributes match ourselves with the exception of the element type...
Definition: MachineValueType.h:452
llvm::TypeSize::getKnownMinSize
ScalarTy getKnownMinSize() const
Definition: TypeSize.h:427
llvm::MVT::Untyped
@ Untyped
Definition: MachineValueType.h:251
llvm::MVT::is1024BitVector
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
Definition: MachineValueType.h:415
llvm::MVT::v32i8
@ v32i8
Definition: MachineValueType.h:78
llvm::MVT::i16
@ i16
Definition: MachineValueType.h:42
llvm::MVT::knownBitsLT
bool knownBitsLT(MVT VT) const
Return true if we know at compile time this has fewer bits than VT.
Definition: MachineValueType.h:1045
llvm::MVT::nxv32i1
@ nxv32i1
Definition: MachineValueType.h:178
llvm::MVT::LAST_INTEGER_VALUETYPE
@ LAST_INTEGER_VALUETYPE
Definition: MachineValueType.h:48
llvm::MVT::vAny
@ vAny
Definition: MachineValueType.h:281
llvm::MVT::v128f64
@ v128f64
Definition: MachineValueType.h:164
llvm::MVT::v8i8
@ v8i8
Definition: MachineValueType.h:76
llvm::MVT::nxv2i8
@ nxv2i8
Definition: MachineValueType.h:182
llvm::MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE
@ LAST_FP_SCALABLE_VECTOR_VALUETYPE
Definition: MachineValueType.h:237
llvm::MVT::nxv16i64
@ nxv16i64
Definition: MachineValueType.h:207
llvm::MVT::v8f32
@ v8f32
Definition: MachineValueType.h:147
llvm::MVT::v2i16
@ v2i16
Definition: MachineValueType.h:84
llvm::MVT::v16i64
@ v16i64
Definition: MachineValueType.h:112
llvm::MVT::bitsGT
bool bitsGT(MVT VT) const
Return true if this has more bits than VT.
Definition: MachineValueType.h:1056
llvm::MVT::v128f16
@ v128f16
Definition: MachineValueType.h:131
llvm::MVT::f32
@ f32
Definition: MachineValueType.h:52
llvm::MVT::nxv1f16
@ nxv1f16
Definition: MachineValueType.h:213
llvm::MVT::v3bf16
@ v3bf16
Definition: MachineValueType.h:134
llvm::MVT::MVT
constexpr MVT(SimpleValueType SVT)
Definition: MachineValueType.h:305
llvm::MVT::nxv8f64
@ nxv8f64
Definition: MachineValueType.h:234
llvm::MVT::v1024f32
@ v1024f32
Definition: MachineValueType.h:154
llvm::MVT::is512BitVector
bool is512BitVector() const
Return true if this is a 512-bit vector type.
Definition: MachineValueType.h:406
llvm::MVT::v4i1
@ v4i1
Definition: MachineValueType.h:63
llvm::MVT::getIntegerVT
static MVT getIntegerVT(unsigned BitWidth)
Definition: MachineValueType.h:1100
llvm::MVT::fp_valuetypes
static mvt_range fp_valuetypes()
Definition: MachineValueType.h:1367
llvm::MVT::nxv8f32
@ nxv8f32
Definition: MachineValueType.h:228
llvm::MVT::integer_scalable_vector_valuetypes
static mvt_range integer_scalable_vector_valuetypes()
Definition: MachineValueType.h:1401