[llvm] ddaf085 - Fully generate `MachineValueType.h`
NAKAMURA Takumi via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 24 16:53:40 PDT 2023
Author: NAKAMURA Takumi
Date: 2023-04-25T08:53:18+09:00
New Revision: ddaf085e7bcb903d5ae1cafc4667b8c3d302897e
URL: https://github.com/llvm/llvm-project/commit/ddaf085e7bcb903d5ae1cafc4667b8c3d302897e
DIFF: https://github.com/llvm/llvm-project/commit/ddaf085e7bcb903d5ae1cafc4667b8c3d302897e.diff
LOG: Fully generate `MachineValueType.h`
Part of D146914
Added:
Modified:
llvm/unittests/Support/MachineValueType.h
llvm/utils/TableGen/VTEmitter.cpp
Removed:
################################################################################
diff --git a/llvm/unittests/Support/MachineValueType.h b/llvm/unittests/Support/MachineValueType.h
index 3c1870ff5cee..21af20977467 100644
--- a/llvm/unittests/Support/MachineValueType.h
+++ b/llvm/unittests/Support/MachineValueType.h
@@ -38,39 +38,12 @@ namespace llvm::tmp {
// are considered extended value types.
INVALID_SIMPLE_VALUE_TYPE = 0,
-#define GET_VT_ATTR(Ty, n, sz) Ty = n,
+#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) Ty = n,
#define GET_VT_RANGES
#include "GenVT.inc"
#undef GET_VT_ATTR
#undef GET_VT_RANGES
- FIRST_INTEGER_VALUETYPE = i1,
- LAST_INTEGER_VALUETYPE = i128,
-
- FIRST_FP_VALUETYPE = bf16,
- LAST_FP_VALUETYPE = ppcf128,
-
- FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
- LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
-
- FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v1f16,
- LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
-
- FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
- LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
-
- FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
- LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
-
- FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
- LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
-
- FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
- LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
-
- FIRST_VECTOR_VALUETYPE = v1i1,
- LAST_VECTOR_VALUETYPE = nxv8f64,
-
VALUETYPE_SIZE = LAST_VALUETYPE + 1,
// This is the current maximum for LAST_VALUETYPE.
@@ -202,9 +175,15 @@ namespace llvm::tmp {
/// Return true if this is an overloaded type for TableGen.
bool isOverloaded() const {
- return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
- SimpleTy == MVT::fAny || SimpleTy == MVT::vAny ||
- SimpleTy == MVT::iPTRAny);
+ switch (SimpleTy) {
+#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
+ case Ty: \
+ return Any;
+#include "GenVT.inc"
+#undef GET_VT_ATTR
+ default:
+ return false;
+ }
}
/// Return a vector with the same number of elements as this vector, but
@@ -278,183 +257,16 @@ namespace llvm::tmp {
}
MVT getVectorElementType() const {
- // clang-format off
switch (SimpleTy) {
default:
llvm_unreachable("Not a vector MVT!");
- case v1i1:
- case v2i1:
- case v4i1:
- case v8i1:
- case v16i1:
- case v32i1:
- case v64i1:
- case v128i1:
- case v256i1:
- case v512i1:
- case v1024i1:
- case v2048i1:
- case nxv1i1:
- case nxv2i1:
- case nxv4i1:
- case nxv8i1:
- case nxv16i1:
- case nxv32i1:
- case nxv64i1: return i1;
- case v128i2:
- case v256i2: return i2;
- case v64i4:
- case v128i4: return i4;
- case v1i8:
- case v2i8:
- case v4i8:
- case v8i8:
- case v16i8:
- case v32i8:
- case v64i8:
- case v128i8:
- case v256i8:
- case v512i8:
- case v1024i8:
- case nxv1i8:
- case nxv2i8:
- case nxv4i8:
- case nxv8i8:
- case nxv16i8:
- case nxv32i8:
- case nxv64i8: return i8;
- case v1i16:
- case v2i16:
- case v3i16:
- case v4i16:
- case v8i16:
- case v16i16:
- case v32i16:
- case v64i16:
- case v128i16:
- case v256i16:
- case v512i16:
- case nxv1i16:
- case nxv2i16:
- case nxv4i16:
- case nxv8i16:
- case nxv16i16:
- case nxv32i16: return i16;
- case v1i32:
- case v2i32:
- case v3i32:
- case v4i32:
- case v5i32:
- case v6i32:
- case v7i32:
- case v8i32:
- case v9i32:
- case v10i32:
- case v11i32:
- case v12i32:
- case v16i32:
- case v32i32:
- case v64i32:
- case v128i32:
- case v256i32:
- case v512i32:
- case v1024i32:
- case v2048i32:
- case nxv1i32:
- case nxv2i32:
- case nxv4i32:
- case nxv8i32:
- case nxv16i32:
- case nxv32i32: return i32;
- case v1i64:
- case v2i64:
- case v3i64:
- case v4i64:
- case v8i64:
- case v16i64:
- case v32i64:
- case v64i64:
- case v128i64:
- case v256i64:
- case nxv1i64:
- case nxv2i64:
- case nxv4i64:
- case nxv8i64:
- case nxv16i64:
- case nxv32i64: return i64;
- case v1i128: return i128;
- case v1f16:
- case v2f16:
- case v3f16:
- case v4f16:
- case v8f16:
- case v16f16:
- case v32f16:
- case v64f16:
- case v128f16:
- case v256f16:
- case v512f16:
- case nxv1f16:
- case nxv2f16:
- case nxv4f16:
- case nxv8f16:
- case nxv16f16:
- case nxv32f16: return f16;
- case v2bf16:
- case v3bf16:
- case v4bf16:
- case v8bf16:
- case v16bf16:
- case v32bf16:
- case v64bf16:
- case v128bf16:
- case nxv1bf16:
- case nxv2bf16:
- case nxv4bf16:
- case nxv8bf16:
- case nxv16bf16:
- case nxv32bf16: return bf16;
- case v1f32:
- case v2f32:
- case v3f32:
- case v4f32:
- case v5f32:
- case v6f32:
- case v7f32:
- case v8f32:
- case v9f32:
- case v10f32:
- case v11f32:
- case v12f32:
- case v16f32:
- case v32f32:
- case v64f32:
- case v128f32:
- case v256f32:
- case v512f32:
- case v1024f32:
- case v2048f32:
- case nxv1f32:
- case nxv2f32:
- case nxv4f32:
- case nxv8f32:
- case nxv16f32: return f32;
- case v1f64:
- case v2f64:
- case v3f64:
- case v4f64:
- case v8f64:
- case v16f64:
- case v32f64:
- case v64f64:
- case v128f64:
- case v256f64:
- case nxv1f64:
- case nxv2f64:
- case nxv4f64:
- case nxv8f64: return f64;
+
+#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
+ case Ty: \
+ return ElTy;
+#include "GenVT.inc"
+#undef GET_VT_VECATTR
}
- // clang-format on
}
/// Given a vector type, return the minimum number of elements it contains.
@@ -462,177 +274,12 @@ namespace llvm::tmp {
switch (SimpleTy) {
default:
llvm_unreachable("Not a vector MVT!");
- case v2048i1:
- case v2048i32:
- case v2048f32: return 2048;
- case v1024i1:
- case v1024i8:
- case v1024i32:
- case v1024f32: return 1024;
- case v512i1:
- case v512i8:
- case v512i16:
- case v512i32:
- case v512f16:
- case v512f32: return 512;
- case v256i1:
- case v256i2:
- case v256i8:
- case v256i16:
- case v256f16:
- case v256i32:
- case v256i64:
- case v256f32:
- case v256f64: return 256;
- case v128i1:
- case v128i2:
- case v128i4:
- case v128i8:
- case v128i16:
- case v128i32:
- case v128i64:
- case v128f16:
- case v128bf16:
- case v128f32:
- case v128f64: return 128;
- case v64i1:
- case v64i4:
- case v64i8:
- case v64i16:
- case v64i32:
- case v64i64:
- case v64f16:
- case v64bf16:
- case v64f32:
- case v64f64:
- case nxv64i1:
- case nxv64i8: return 64;
- case v32i1:
- case v32i8:
- case v32i16:
- case v32i32:
- case v32i64:
- case v32f16:
- case v32bf16:
- case v32f32:
- case v32f64:
- case nxv32i1:
- case nxv32i8:
- case nxv32i16:
- case nxv32i32:
- case nxv32i64:
- case nxv32f16:
- case nxv32bf16: return 32;
- case v16i1:
- case v16i8:
- case v16i16:
- case v16i32:
- case v16i64:
- case v16f16:
- case v16bf16:
- case v16f32:
- case v16f64:
- case nxv16i1:
- case nxv16i8:
- case nxv16i16:
- case nxv16i32:
- case nxv16i64:
- case nxv16f16:
- case nxv16bf16:
- case nxv16f32: return 16;
- case v12i32:
- case v12f32: return 12;
- case v11i32:
- case v11f32: return 11;
- case v10i32:
- case v10f32: return 10;
- case v9i32:
- case v9f32: return 9;
- case v8i1:
- case v8i8:
- case v8i16:
- case v8i32:
- case v8i64:
- case v8f16:
- case v8bf16:
- case v8f32:
- case v8f64:
- case nxv8i1:
- case nxv8i8:
- case nxv8i16:
- case nxv8i32:
- case nxv8i64:
- case nxv8f16:
- case nxv8bf16:
- case nxv8f32:
- case nxv8f64: return 8;
- case v7i32:
- case v7f32: return 7;
- case v6i32:
- case v6f32: return 6;
- case v5i32:
- case v5f32: return 5;
- case v4i1:
- case v4i8:
- case v4i16:
- case v4i32:
- case v4i64:
- case v4f16:
- case v4bf16:
- case v4f32:
- case v4f64:
- case nxv4i1:
- case nxv4i8:
- case nxv4i16:
- case nxv4i32:
- case nxv4i64:
- case nxv4f16:
- case nxv4bf16:
- case nxv4f32:
- case nxv4f64: return 4;
- case v3i16:
- case v3i32:
- case v3i64:
- case v3f16:
- case v3bf16:
- case v3f32:
- case v3f64: return 3;
- case v2i1:
- case v2i8:
- case v2i16:
- case v2i32:
- case v2i64:
- case v2f16:
- case v2bf16:
- case v2f32:
- case v2f64:
- case nxv2i1:
- case nxv2i8:
- case nxv2i16:
- case nxv2i32:
- case nxv2i64:
- case nxv2f16:
- case nxv2bf16:
- case nxv2f32:
- case nxv2f64: return 2;
- case v1i1:
- case v1i8:
- case v1i16:
- case v1i32:
- case v1i64:
- case v1i128:
- case v1f16:
- case v1f32:
- case v1f64:
- case nxv1i1:
- case nxv1i8:
- case nxv1i16:
- case nxv1i32:
- case nxv1i64:
- case nxv1f16:
- case nxv1bf16:
- case nxv1f32:
- case nxv1f64: return 1;
+
+#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
+ case Ty: \
+ return nElem;
+#include "GenVT.inc"
+#undef GET_VT_VECATTR
}
}
@@ -661,10 +308,9 @@ namespace llvm::tmp {
default:
llvm_unreachable("getSizeInBits called on extended MVT.");
-#define GET_VT_ATTR(Ty, N, Sz) \
+#define GET_VT_ATTR(Ty, N, Sz, Any, Int, FP, Vec, Sc) \
case Ty: \
- return (MVT(Ty).isScalableVector() ? TypeSize::Scalable(Sz) \
- : TypeSize::Fixed(Sz));
+ return (Sc ? TypeSize::Scalable(Sz) : TypeSize::Fixed(Sz));
#include "GenVT.inc"
#undef GET_VT_ATTR
}
@@ -778,273 +424,42 @@ namespace llvm::tmp {
}
static MVT getFloatingPointVT(unsigned BitWidth) {
- switch (BitWidth) {
- default:
- llvm_unreachable("Bad bit width!");
- case 16:
- return MVT::f16;
- case 32:
- return MVT::f32;
- case 64:
- return MVT::f64;
- case 80:
- return MVT::f80;
- case 128:
- return MVT::f128;
- }
+#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
+ if (FP == 3 && sz == BitWidth) \
+ return Ty;
+#include "GenVT.inc"
+#undef GET_VT_ATTR
+
+ llvm_unreachable("Bad bit width!");
}
static MVT getIntegerVT(unsigned BitWidth) {
- switch (BitWidth) {
- default:
- return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
- case 1:
- return MVT::i1;
- case 2:
- return MVT::i2;
- case 4:
- return MVT::i4;
- case 8:
- return MVT::i8;
- case 16:
- return MVT::i16;
- case 32:
- return MVT::i32;
- case 64:
- return MVT::i64;
- case 128:
- return MVT::i128;
- }
+#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
+ if (Int == 3 && sz == BitWidth) \
+ return Ty;
+#include "GenVT.inc"
+#undef GET_VT_ATTR
+
+ return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}
static MVT getVectorVT(MVT VT, unsigned NumElements) {
- // clang-format off
- switch (VT.SimpleTy) {
- default:
- break;
- case MVT::i1:
- if (NumElements == 1) return MVT::v1i1;
- if (NumElements == 2) return MVT::v2i1;
- if (NumElements == 4) return MVT::v4i1;
- if (NumElements == 8) return MVT::v8i1;
- if (NumElements == 16) return MVT::v16i1;
- if (NumElements == 32) return MVT::v32i1;
- if (NumElements == 64) return MVT::v64i1;
- if (NumElements == 128) return MVT::v128i1;
- if (NumElements == 256) return MVT::v256i1;
- if (NumElements == 512) return MVT::v512i1;
- if (NumElements == 1024) return MVT::v1024i1;
- if (NumElements == 2048) return MVT::v2048i1;
- break;
- case MVT::i2:
- if (NumElements == 128) return MVT::v128i2;
- if (NumElements == 256) return MVT::v256i2;
- break;
- case MVT::i4:
- if (NumElements == 64) return MVT::v64i4;
- if (NumElements == 128) return MVT::v128i4;
- break;
- case MVT::i8:
- if (NumElements == 1) return MVT::v1i8;
- if (NumElements == 2) return MVT::v2i8;
- if (NumElements == 4) return MVT::v4i8;
- if (NumElements == 8) return MVT::v8i8;
- if (NumElements == 16) return MVT::v16i8;
- if (NumElements == 32) return MVT::v32i8;
- if (NumElements == 64) return MVT::v64i8;
- if (NumElements == 128) return MVT::v128i8;
- if (NumElements == 256) return MVT::v256i8;
- if (NumElements == 512) return MVT::v512i8;
- if (NumElements == 1024) return MVT::v1024i8;
- break;
- case MVT::i16:
- if (NumElements == 1) return MVT::v1i16;
- if (NumElements == 2) return MVT::v2i16;
- if (NumElements == 3) return MVT::v3i16;
- if (NumElements == 4) return MVT::v4i16;
- if (NumElements == 8) return MVT::v8i16;
- if (NumElements == 16) return MVT::v16i16;
- if (NumElements == 32) return MVT::v32i16;
- if (NumElements == 64) return MVT::v64i16;
- if (NumElements == 128) return MVT::v128i16;
- if (NumElements == 256) return MVT::v256i16;
- if (NumElements == 512) return MVT::v512i16;
- break;
- case MVT::i32:
- if (NumElements == 1) return MVT::v1i32;
- if (NumElements == 2) return MVT::v2i32;
- if (NumElements == 3) return MVT::v3i32;
- if (NumElements == 4) return MVT::v4i32;
- if (NumElements == 5) return MVT::v5i32;
- if (NumElements == 6) return MVT::v6i32;
- if (NumElements == 7) return MVT::v7i32;
- if (NumElements == 8) return MVT::v8i32;
- if (NumElements == 9) return MVT::v9i32;
- if (NumElements == 10) return MVT::v10i32;
- if (NumElements == 11) return MVT::v11i32;
- if (NumElements == 12) return MVT::v12i32;
- if (NumElements == 16) return MVT::v16i32;
- if (NumElements == 32) return MVT::v32i32;
- if (NumElements == 64) return MVT::v64i32;
- if (NumElements == 128) return MVT::v128i32;
- if (NumElements == 256) return MVT::v256i32;
- if (NumElements == 512) return MVT::v512i32;
- if (NumElements == 1024) return MVT::v1024i32;
- if (NumElements == 2048) return MVT::v2048i32;
- break;
- case MVT::i64:
- if (NumElements == 1) return MVT::v1i64;
- if (NumElements == 2) return MVT::v2i64;
- if (NumElements == 3) return MVT::v3i64;
- if (NumElements == 4) return MVT::v4i64;
- if (NumElements == 8) return MVT::v8i64;
- if (NumElements == 16) return MVT::v16i64;
- if (NumElements == 32) return MVT::v32i64;
- if (NumElements == 64) return MVT::v64i64;
- if (NumElements == 128) return MVT::v128i64;
- if (NumElements == 256) return MVT::v256i64;
- break;
- case MVT::i128:
- if (NumElements == 1) return MVT::v1i128;
- break;
- case MVT::f16:
- if (NumElements == 1) return MVT::v1f16;
- if (NumElements == 2) return MVT::v2f16;
- if (NumElements == 3) return MVT::v3f16;
- if (NumElements == 4) return MVT::v4f16;
- if (NumElements == 8) return MVT::v8f16;
- if (NumElements == 16) return MVT::v16f16;
- if (NumElements == 32) return MVT::v32f16;
- if (NumElements == 64) return MVT::v64f16;
- if (NumElements == 128) return MVT::v128f16;
- if (NumElements == 256) return MVT::v256f16;
- if (NumElements == 512) return MVT::v512f16;
- break;
- case MVT::bf16:
- if (NumElements == 2) return MVT::v2bf16;
- if (NumElements == 3) return MVT::v3bf16;
- if (NumElements == 4) return MVT::v4bf16;
- if (NumElements == 8) return MVT::v8bf16;
- if (NumElements == 16) return MVT::v16bf16;
- if (NumElements == 32) return MVT::v32bf16;
- if (NumElements == 64) return MVT::v64bf16;
- if (NumElements == 128) return MVT::v128bf16;
- break;
- case MVT::f32:
- if (NumElements == 1) return MVT::v1f32;
- if (NumElements == 2) return MVT::v2f32;
- if (NumElements == 3) return MVT::v3f32;
- if (NumElements == 4) return MVT::v4f32;
- if (NumElements == 5) return MVT::v5f32;
- if (NumElements == 6) return MVT::v6f32;
- if (NumElements == 7) return MVT::v7f32;
- if (NumElements == 8) return MVT::v8f32;
- if (NumElements == 9) return MVT::v9f32;
- if (NumElements == 10) return MVT::v10f32;
- if (NumElements == 11) return MVT::v11f32;
- if (NumElements == 12) return MVT::v12f32;
- if (NumElements == 16) return MVT::v16f32;
- if (NumElements == 32) return MVT::v32f32;
- if (NumElements == 64) return MVT::v64f32;
- if (NumElements == 128) return MVT::v128f32;
- if (NumElements == 256) return MVT::v256f32;
- if (NumElements == 512) return MVT::v512f32;
- if (NumElements == 1024) return MVT::v1024f32;
- if (NumElements == 2048) return MVT::v2048f32;
- break;
- case MVT::f64:
- if (NumElements == 1) return MVT::v1f64;
- if (NumElements == 2) return MVT::v2f64;
- if (NumElements == 3) return MVT::v3f64;
- if (NumElements == 4) return MVT::v4f64;
- if (NumElements == 8) return MVT::v8f64;
- if (NumElements == 16) return MVT::v16f64;
- if (NumElements == 32) return MVT::v32f64;
- if (NumElements == 64) return MVT::v64f64;
- if (NumElements == 128) return MVT::v128f64;
- if (NumElements == 256) return MVT::v256f64;
- break;
- }
+#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
+ if (!Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
+ return Ty;
+#include "GenVT.inc"
+#undef GET_VT_VECATTR
+
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
- // clang-format on
}
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
- switch(VT.SimpleTy) {
- default:
- break;
- case MVT::i1:
- if (NumElements == 1) return MVT::nxv1i1;
- if (NumElements == 2) return MVT::nxv2i1;
- if (NumElements == 4) return MVT::nxv4i1;
- if (NumElements == 8) return MVT::nxv8i1;
- if (NumElements == 16) return MVT::nxv16i1;
- if (NumElements == 32) return MVT::nxv32i1;
- if (NumElements == 64) return MVT::nxv64i1;
- break;
- case MVT::i8:
- if (NumElements == 1) return MVT::nxv1i8;
- if (NumElements == 2) return MVT::nxv2i8;
- if (NumElements == 4) return MVT::nxv4i8;
- if (NumElements == 8) return MVT::nxv8i8;
- if (NumElements == 16) return MVT::nxv16i8;
- if (NumElements == 32) return MVT::nxv32i8;
- if (NumElements == 64) return MVT::nxv64i8;
- break;
- case MVT::i16:
- if (NumElements == 1) return MVT::nxv1i16;
- if (NumElements == 2) return MVT::nxv2i16;
- if (NumElements == 4) return MVT::nxv4i16;
- if (NumElements == 8) return MVT::nxv8i16;
- if (NumElements == 16) return MVT::nxv16i16;
- if (NumElements == 32) return MVT::nxv32i16;
- break;
- case MVT::i32:
- if (NumElements == 1) return MVT::nxv1i32;
- if (NumElements == 2) return MVT::nxv2i32;
- if (NumElements == 4) return MVT::nxv4i32;
- if (NumElements == 8) return MVT::nxv8i32;
- if (NumElements == 16) return MVT::nxv16i32;
- if (NumElements == 32) return MVT::nxv32i32;
- break;
- case MVT::i64:
- if (NumElements == 1) return MVT::nxv1i64;
- if (NumElements == 2) return MVT::nxv2i64;
- if (NumElements == 4) return MVT::nxv4i64;
- if (NumElements == 8) return MVT::nxv8i64;
- if (NumElements == 16) return MVT::nxv16i64;
- if (NumElements == 32) return MVT::nxv32i64;
- break;
- case MVT::f16:
- if (NumElements == 1) return MVT::nxv1f16;
- if (NumElements == 2) return MVT::nxv2f16;
- if (NumElements == 4) return MVT::nxv4f16;
- if (NumElements == 8) return MVT::nxv8f16;
- if (NumElements == 16) return MVT::nxv16f16;
- if (NumElements == 32) return MVT::nxv32f16;
- break;
- case MVT::bf16:
- if (NumElements == 1) return MVT::nxv1bf16;
- if (NumElements == 2) return MVT::nxv2bf16;
- if (NumElements == 4) return MVT::nxv4bf16;
- if (NumElements == 8) return MVT::nxv8bf16;
- if (NumElements == 16) return MVT::nxv16bf16;
- if (NumElements == 32) return MVT::nxv32bf16;
- break;
- case MVT::f32:
- if (NumElements == 1) return MVT::nxv1f32;
- if (NumElements == 2) return MVT::nxv2f32;
- if (NumElements == 4) return MVT::nxv4f32;
- if (NumElements == 8) return MVT::nxv8f32;
- if (NumElements == 16) return MVT::nxv16f32;
- break;
- case MVT::f64:
- if (NumElements == 1) return MVT::nxv1f64;
- if (NumElements == 2) return MVT::nxv2f64;
- if (NumElements == 4) return MVT::nxv4f64;
- if (NumElements == 8) return MVT::nxv8f64;
- break;
- }
+#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
+ if (Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
+ return Ty;
+#include "GenVT.inc"
+#undef GET_VT_VECATTR
+
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}
diff --git a/llvm/utils/TableGen/VTEmitter.cpp b/llvm/utils/TableGen/VTEmitter.cpp
index f7ae0f5bc38e..d398a7e7b58f 100644
--- a/llvm/utils/TableGen/VTEmitter.cpp
+++ b/llvm/utils/TableGen/VTEmitter.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h"
@@ -63,26 +62,41 @@ void VTEmitter::run(raw_ostream &OS) {
}
};
- OS << "#ifdef GET_VT_ATTR // (Ty, n, sz)\n";
+ OS << "#ifdef GET_VT_ATTR // (Ty, n, sz, Any, Int, FP, Vec, Sc)\n";
for (const auto *VT : VTsByNumber) {
if (!VT)
continue;
- auto Name = VT->getName();
- Name = StringSwitch<StringRef>(Name)
- .Case("OtherVT", "Other")
- .Case("FlagVT", "Glue")
- .Case("untyped", "Untyped")
- .Case("MetadataVT", "Metadata")
- .Default(Name);
+ auto Name = VT->getValueAsString("LLVMName");
auto Value = VT->getValueAsInt("Value");
-
+ bool IsInteger = VT->getValueAsInt("isInteger");
+ bool IsFP = VT->getValueAsInt("isFP");
+ bool IsVector = VT->getValueAsInt("isVector");
+ bool IsScalable = VT->getValueAsInt("isScalable");
+
+ UpdateVTRange("INTEGER_FIXEDLEN_VECTOR_VALUETYPE", Name,
+ IsInteger && IsVector && !IsScalable);
+ UpdateVTRange("INTEGER_SCALABLE_VECTOR_VALUETYPE", Name,
+ IsInteger && IsScalable);
+ UpdateVTRange("FP_FIXEDLEN_VECTOR_VALUETYPE", Name,
+ IsFP && IsVector && !IsScalable);
+ UpdateVTRange("FP_SCALABLE_VECTOR_VALUETYPE", Name, IsFP && IsScalable);
+ UpdateVTRange("FIXEDLEN_VECTOR_VALUETYPE", Name, IsVector && !IsScalable);
+ UpdateVTRange("SCALABLE_VECTOR_VALUETYPE", Name, IsScalable);
+ UpdateVTRange("VECTOR_VALUETYPE", Name, IsVector);
+ UpdateVTRange("INTEGER_VALUETYPE", Name, IsInteger && !IsVector);
+ UpdateVTRange("FP_VALUETYPE", Name, IsFP && !IsVector);
UpdateVTRange("VALUETYPE", Name, Value < 224);
// clang-format off
OS << " GET_VT_ATTR("
<< Name << ", "
<< Value << ", "
- << VT->getValueAsInt("Size") << ")\n";
+ << VT->getValueAsInt("Size") << ", "
+ << VT->getValueAsInt("isOverloaded") << ", "
+ << (IsInteger ? Name[0] == 'i' ? 3 : 1 : 0) << ", "
+ << (IsFP ? Name[0] == 'f' ? 3 : 1 : 0) << ", "
+ << IsVector << ", "
+ << IsScalable << ")\n";
// clang-format on
}
OS << "#endif\n\n";
@@ -94,6 +108,23 @@ void VTEmitter::run(raw_ostream &OS) {
<< " LAST_" << KV.first << " = " << KV.second.Last << ",\n";
}
OS << "#endif\n\n";
+
+ OS << "#ifdef GET_VT_VECATTR // (Ty, Sc, nElem, ElTy, ElSz)\n";
+ for (const auto *VT : VTsByNumber) {
+ if (!VT || !VT->getValueAsInt("isVector"))
+ continue;
+ const auto *ElTy = VT->getValueAsDef("ElementType");
+ assert(ElTy);
+ // clang-format off
+ OS << " GET_VT_VECATTR("
+ << VT->getValueAsString("LLVMName") << ", "
+ << VT->getValueAsInt("isScalable") << ", "
+ << VT->getValueAsInt("nElem") << ", "
+ << ElTy->getName() << ", "
+ << ElTy->getValueAsInt("Size") << ")\n";
+ // clang-format on
+ }
+ OS << "#endif\n\n";
}
static TableGen::Emitter::OptClass<VTEmitter> X("gen-vt", "Generate ValueType");
More information about the llvm-commits
mailing list