[CodeGen][Float8] Add float8 MVT type #89901

JinjinLi868 · 2024-04-24T09:37:53Z

This patch adds float8(e4m3fn and e5m2) MVT support. It also adds
fixed and scalable vector MVT types for float8.
The series patches(for IR MVT intrinsic):
#89900
#89901
#89902

This patch adds float8(e4m3fn and e5m2) MVT support. It also adds fixed and scalable vector MVT types for float8.

github-actions · 2024-04-24T09:38:11Z

Thank you for submitting a Pull Request (PR) to the LLVM Project!

This PR will be automatically labeled and the relevant teams will be
notified.

If you wish to, you can add reviewers by using the "Reviewers" section on this page.

If this is not working for you, it is probably because you do not have write
permissions for the repository. In which case you can instead tag reviewers by
name in a comment by using @ followed by their GitHub username.

If you have received no comments on your PR for a week, you can request a review
by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate
is once a week. Please remember that you are asking for valuable time from other developers.

If you have further questions, they may be answered by the LLVM GitHub User Guide.

You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums.

llvmbot · 2024-04-24T09:38:41Z

@llvm/pr-subscribers-llvm-ir

@llvm/pr-subscribers-llvm-selectiondag

Author: None (JinjinLi868)

Changes

This patch adds float8(e4m3fn and e5m2) MVT support. It also adds
fixed and scalable vector MVT types for float8.

Patch is 40.46 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/89901.diff

7 Files Affected:

(modified) llvm/include/llvm/CodeGen/SelectionDAG.h (+2)
(modified) llvm/include/llvm/CodeGen/ValueTypes.td (+252-212)
(modified) llvm/include/llvm/CodeGenTypes/MachineValueType.h (+1-1)
(modified) llvm/include/llvm/IR/Intrinsics.td (+2)
(modified) llvm/lib/CodeGen/ValueTypes.cpp (+80-6)
(modified) llvm/utils/TableGen/Common/CodeGenTarget.cpp (+36)
(modified) llvm/utils/TableGen/VTEmitter.cpp (+1-1)

diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h
index f347131be080f6..77d177e4462661 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAG.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAG.h
@@ -1798,6 +1798,8 @@ class SelectionDAG {
   static const fltSemantics &EVTToAPFloatSemantics(EVT VT) {
     switch (VT.getScalarType().getSimpleVT().SimpleTy) {
     default: llvm_unreachable("Unknown FP format");
+    case MVT::f8e4m3fn:  return APFloat::Float8E4M3FN();
+    case MVT::f8e5m2:  return APFloat::Float8E5M2();
     case MVT::f16:     return APFloat::IEEEhalf();
     case MVT::bf16:    return APFloat::BFloat();
     case MVT::f32:     return APFloat::IEEEsingle();
diff --git a/llvm/include/llvm/CodeGen/ValueTypes.td b/llvm/include/llvm/CodeGen/ValueTypes.td
index 900b30d9b02492..ae1eb7e99ad23f 100644
--- a/llvm/include/llvm/CodeGen/ValueTypes.td
+++ b/llvm/include/llvm/CodeGen/ValueTypes.td
@@ -68,223 +68,263 @@ def i32     : VTInt<32,  7>;  // 32-bit integer value
 def i64     : VTInt<64,  8>;  // 64-bit integer value
 def i128    : VTInt<128, 9>;  // 128-bit integer value
 
-def bf16    : VTFP<16,  10>;  // 16-bit brain floating point value
-def f16     : VTFP<16,  11>;  // 16-bit floating point value
-def f32     : VTFP<32,  12>;  // 32-bit floating point value
-def f64     : VTFP<64,  13>;  // 64-bit floating point value
-def f80     : VTFP<80,  14>;  // 80-bit floating point value
-def f128    : VTFP<128, 15>;  // 128-bit floating point value
-def ppcf128 : VTFP<128, 16>;  // PPC 128-bit floating point value
-
-def v1i1    : VTVec<1,    i1, 17>;  //    1 x i1 vector value
-def v2i1    : VTVec<2,    i1, 18>;  //    2 x i1 vector value
-def v3i1    : VTVec<3,    i1, 19>;  //    3 x i1 vector value
-def v4i1    : VTVec<4,    i1, 20>;  //    4 x i1 vector value
-def v8i1    : VTVec<8,    i1, 21>;  //    8 x i1 vector value
-def v16i1   : VTVec<16,   i1, 22>;  //   16 x i1 vector value
-def v32i1   : VTVec<32,   i1, 23>;  //   32 x i1 vector value
-def v64i1   : VTVec<64,   i1, 24>;  //   64 x i1 vector value
-def v128i1  : VTVec<128,  i1, 25>;  //  128 x i1 vector value
-def v256i1  : VTVec<256,  i1, 26>;  //  256 x i1 vector value
-def v512i1  : VTVec<512,  i1, 27>;  //  512 x i1 vector value
-def v1024i1 : VTVec<1024, i1, 28>;  // 1024 x i1 vector value
-def v2048i1 : VTVec<2048, i1, 29>;  // 2048 x i1 vector value
-
-def v128i2  : VTVec<128,  i2, 30>;   //  128 x i2 vector value
-def v256i2  : VTVec<256,  i2, 31>;   //  256 x i2 vector value
-
-def v64i4   : VTVec<64,   i4, 32>;   //   64 x i4 vector value
-def v128i4  : VTVec<128,  i4, 33>;   //  128 x i4 vector value
-
-def v1i8    : VTVec<1,    i8, 34>;  //    1 x i8 vector value
-def v2i8    : VTVec<2,    i8, 35>;  //    2 x i8 vector value
-def v3i8    : VTVec<3,    i8, 36>;  //    3 x i8 vector value
-def v4i8    : VTVec<4,    i8, 37>;  //    4 x i8 vector value
-def v8i8    : VTVec<8,    i8, 38>;  //    8 x i8 vector value
-def v16i8   : VTVec<16,   i8, 39>;  //   16 x i8 vector value
-def v32i8   : VTVec<32,   i8, 40>;  //   32 x i8 vector value
-def v64i8   : VTVec<64,   i8, 41>;  //   64 x i8 vector value
-def v128i8  : VTVec<128,  i8, 42>;  //  128 x i8 vector value
-def v256i8  : VTVec<256,  i8, 43>;  //  256 x i8 vector value
-def v512i8  : VTVec<512,  i8, 44>;  //  512 x i8 vector value
-def v1024i8 : VTVec<1024, i8, 45>;  // 1024 x i8 vector value
-
-def v1i16   : VTVec<1,   i16, 46>;  //   1 x i16 vector value
-def v2i16   : VTVec<2,   i16, 47>;  //   2 x i16 vector value
-def v3i16   : VTVec<3,   i16, 48>;  //   3 x i16 vector value
-def v4i16   : VTVec<4,   i16, 49>;  //   4 x i16 vector value
-def v8i16   : VTVec<8,   i16, 50>;  //   8 x i16 vector value
-def v16i16  : VTVec<16,  i16, 51>;  //  16 x i16 vector value
-def v32i16  : VTVec<32,  i16, 52>;  //  32 x i16 vector value
-def v64i16  : VTVec<64,  i16, 53>;  //  64 x i16 vector value
-def v128i16 : VTVec<128, i16, 54>;  // 128 x i16 vector value
-def v256i16 : VTVec<256, i16, 55>;  // 256 x i16 vector value
-def v512i16 : VTVec<512, i16, 56>;  // 512 x i16 vector value
-
-def v1i32    : VTVec<1,    i32, 57>;  //    1 x i32 vector value
-def v2i32    : VTVec<2,    i32, 58>;  //    2 x i32 vector value
-def v3i32    : VTVec<3,    i32, 59>;  //    3 x i32 vector value
-def v4i32    : VTVec<4,    i32, 60>;  //    4 x i32 vector value
-def v5i32    : VTVec<5,    i32, 61>;  //    5 x i32 vector value
-def v6i32    : VTVec<6,    i32, 62>;  //    6 x f32 vector value
-def v7i32    : VTVec<7,    i32, 63>;  //    7 x f32 vector value
-def v8i32    : VTVec<8,    i32, 64>;  //    8 x i32 vector value
-def v9i32    : VTVec<9,    i32, 65>;  //    9 x i32 vector value
-def v10i32   : VTVec<10,   i32, 66>;  //   10 x i32 vector value
-def v11i32   : VTVec<11,   i32, 67>;  //   11 x i32 vector value
-def v12i32   : VTVec<12,   i32, 68>;  //   12 x i32 vector value
-def v16i32   : VTVec<16,   i32, 69>;  //   16 x i32 vector value
-def v32i32   : VTVec<32,   i32, 70>;  //   32 x i32 vector value
-def v64i32   : VTVec<64,   i32, 71>;  //   64 x i32 vector value
-def v128i32  : VTVec<128,  i32, 72>;  //  128 x i32 vector value
-def v256i32  : VTVec<256,  i32, 73>;  //  256 x i32 vector value
-def v512i32  : VTVec<512,  i32, 74>;  //  512 x i32 vector value
-def v1024i32 : VTVec<1024, i32, 75>;  // 1024 x i32 vector value
-def v2048i32 : VTVec<2048, i32, 76>;  // 2048 x i32 vector value
-
-def v1i64   : VTVec<1,   i64, 77>;  //   1 x i64 vector value
-def v2i64   : VTVec<2,   i64, 78>;  //   2 x i64 vector value
-def v3i64   : VTVec<3,   i64, 79>;  //   3 x i64 vector value
-def v4i64   : VTVec<4,   i64, 80>;  //   4 x i64 vector value
-def v8i64   : VTVec<8,   i64, 81>;  //   8 x i64 vector value
-def v16i64  : VTVec<16,  i64, 82>;  //  16 x i64 vector value
-def v32i64  : VTVec<32,  i64, 83>;  //  32 x i64 vector value
-def v64i64  : VTVec<64,  i64, 84>;  //  64 x i64 vector value
-def v128i64 : VTVec<128, i64, 85>;  // 128 x i64 vector value
-def v256i64 : VTVec<256, i64, 86>;  // 256 x i64 vector value
-
-def v1i128  : VTVec<1,  i128, 87>;  //  1 x i128 vector value
-
-def v1f16    : VTVec<1,    f16,  88>;  //    1 x f16 vector value
-def v2f16    : VTVec<2,    f16,  89>;  //    2 x f16 vector value
-def v3f16    : VTVec<3,    f16,  90>;  //    3 x f16 vector value
-def v4f16    : VTVec<4,    f16,  91>;  //    4 x f16 vector value
-def v8f16    : VTVec<8,    f16,  92>;  //    8 x f16 vector value
-def v16f16   : VTVec<16,   f16,  93>;  //   16 x f16 vector value
-def v32f16   : VTVec<32,   f16,  94>;  //   32 x f16 vector value
-def v64f16   : VTVec<64,   f16,  95>;  //   64 x f16 vector value
-def v128f16  : VTVec<128,  f16,  96>;  //  128 x f16 vector value
-def v256f16  : VTVec<256,  f16,  97>;  //  256 x f16 vector value
-def v512f16  : VTVec<512,  f16,  98>;  //  512 x f16 vector value
-
-def v2bf16   : VTVec<2,   bf16,  99>;  //    2 x bf16 vector value
-def v3bf16   : VTVec<3,   bf16, 100>;  //    3 x bf16 vector value
-def v4bf16   : VTVec<4,   bf16, 101>;  //    4 x bf16 vector value
-def v8bf16   : VTVec<8,   bf16, 102>;  //    8 x bf16 vector value
-def v16bf16  : VTVec<16,  bf16, 103>;  //   16 x bf16 vector value
-def v32bf16  : VTVec<32,  bf16, 104>;  //   32 x bf16 vector value
-def v64bf16  : VTVec<64,  bf16, 105>;  //   64 x bf16 vector value
-def v128bf16 : VTVec<128, bf16, 106>;  //  128 x bf16 vector value
-
-def v1f32    : VTVec<1,    f32, 107>;  //    1 x f32 vector value
-def v2f32    : VTVec<2,    f32, 108>;  //    2 x f32 vector value
-def v3f32    : VTVec<3,    f32, 109>;  //    3 x f32 vector value
-def v4f32    : VTVec<4,    f32, 110>;  //    4 x f32 vector value
-def v5f32    : VTVec<5,    f32, 111>;  //    5 x f32 vector value
-def v6f32    : VTVec<6,    f32, 112>;  //    6 x f32 vector value
-def v7f32    : VTVec<7,    f32, 113>;  //    7 x f32 vector value
-def v8f32    : VTVec<8,    f32, 114>;  //    8 x f32 vector value
-def v9f32    : VTVec<9,    f32, 115>;  //    9 x f32 vector value
-def v10f32   : VTVec<10,   f32, 116>;  //   10 x f32 vector value
-def v11f32   : VTVec<11,   f32, 117>;  //   11 x f32 vector value
-def v12f32   : VTVec<12,   f32, 118>;  //   12 x f32 vector value
-def v16f32   : VTVec<16,   f32, 119>;  //   16 x f32 vector value
-def v32f32   : VTVec<32,   f32, 120>;  //   32 x f32 vector value
-def v64f32   : VTVec<64,   f32, 121>;  //   64 x f32 vector value
-def v128f32  : VTVec<128,  f32, 122>;  //  128 x f32 vector value
-def v256f32  : VTVec<256,  f32, 123>;  //  256 x f32 vector value
-def v512f32  : VTVec<512,  f32, 124>;  //  512 x f32 vector value
-def v1024f32 : VTVec<1024, f32, 125>;  // 1024 x f32 vector value
-def v2048f32 : VTVec<2048, f32, 126>;  // 2048 x f32 vector value
-
-def v1f64    : VTVec<1,    f64, 127>;  //    1 x f64 vector value
-def v2f64    : VTVec<2,    f64, 128>;  //    2 x f64 vector value
-def v3f64    : VTVec<3,    f64, 129>;  //    3 x f64 vector value
-def v4f64    : VTVec<4,    f64, 130>;  //    4 x f64 vector value
-def v8f64    : VTVec<8,    f64, 131>;  //    8 x f64 vector value
-def v16f64   : VTVec<16,   f64, 132>;  //   16 x f64 vector value
-def v32f64   : VTVec<32,   f64, 133>;  //   32 x f64 vector value
-def v64f64   : VTVec<64,   f64, 134>;  //   64 x f64 vector value
-def v128f64  : VTVec<128,  f64, 135>;  //  128 x f64 vector value
-def v256f64  : VTVec<256,  f64, 136>;  //  256 x f64 vector value
-
-def nxv1i1  : VTScalableVec<1,  i1, 137>;  // n x  1 x i1  vector value
-def nxv2i1  : VTScalableVec<2,  i1, 138>;  // n x  2 x i1  vector value
-def nxv4i1  : VTScalableVec<4,  i1, 139>;  // n x  4 x i1  vector value
-def nxv8i1  : VTScalableVec<8,  i1, 140>;  // n x  8 x i1  vector value
-def nxv16i1 : VTScalableVec<16, i1, 141>;  // n x 16 x i1  vector value
-def nxv32i1 : VTScalableVec<32, i1, 142>;  // n x 32 x i1  vector value
-def nxv64i1 : VTScalableVec<64, i1, 143>;  // n x 64 x i1  vector value
-
-def nxv1i8  : VTScalableVec<1,  i8, 144>;  // n x  1 x i8  vector value
-def nxv2i8  : VTScalableVec<2,  i8, 145>;  // n x  2 x i8  vector value
-def nxv4i8  : VTScalableVec<4,  i8, 146>;  // n x  4 x i8  vector value
-def nxv8i8  : VTScalableVec<8,  i8, 147>;  // n x  8 x i8  vector value
-def nxv16i8 : VTScalableVec<16, i8, 148>;  // n x 16 x i8  vector value
-def nxv32i8 : VTScalableVec<32, i8, 149>;  // n x 32 x i8  vector value
-def nxv64i8 : VTScalableVec<64, i8, 150>;  // n x 64 x i8  vector value
-
-def nxv1i16  : VTScalableVec<1,  i16, 151>;  // n x  1 x i16 vector value
-def nxv2i16  : VTScalableVec<2,  i16, 152>;  // n x  2 x i16 vector value
-def nxv4i16  : VTScalableVec<4,  i16, 153>;  // n x  4 x i16 vector value
-def nxv8i16  : VTScalableVec<8,  i16, 154>;  // n x  8 x i16 vector value
-def nxv16i16 : VTScalableVec<16, i16, 155>;  // n x 16 x i16 vector value
-def nxv32i16 : VTScalableVec<32, i16, 156>;  // n x 32 x i16 vector value
-
-def nxv1i32  : VTScalableVec<1,  i32, 157>;  // n x  1 x i32 vector value
-def nxv2i32  : VTScalableVec<2,  i32, 158>;  // n x  2 x i32 vector value
-def nxv4i32  : VTScalableVec<4,  i32, 159>;  // n x  4 x i32 vector value
-def nxv8i32  : VTScalableVec<8,  i32, 160>;  // n x  8 x i32 vector value
-def nxv16i32 : VTScalableVec<16, i32, 161>;  // n x 16 x i32 vector value
-def nxv32i32 : VTScalableVec<32, i32, 162>;  // n x 32 x i32 vector value
-
-def nxv1i64  : VTScalableVec<1,  i64, 163>;  // n x  1 x i64 vector value
-def nxv2i64  : VTScalableVec<2,  i64, 164>;  // n x  2 x i64 vector value
-def nxv4i64  : VTScalableVec<4,  i64, 165>;  // n x  4 x i64 vector value
-def nxv8i64  : VTScalableVec<8,  i64, 166>;  // n x  8 x i64 vector value
-def nxv16i64 : VTScalableVec<16, i64, 167>;  // n x 16 x i64 vector value
-def nxv32i64 : VTScalableVec<32, i64, 168>;  // n x 32 x i64 vector value
-
-def nxv1f16  : VTScalableVec<1,  f16, 169>;  // n x  1 x  f16 vector value
-def nxv2f16  : VTScalableVec<2,  f16, 170>;  // n x  2 x  f16 vector value
-def nxv4f16  : VTScalableVec<4,  f16, 171>;  // n x  4 x  f16 vector value
-def nxv8f16  : VTScalableVec<8,  f16, 172>;  // n x  8 x  f16 vector value
-def nxv16f16 : VTScalableVec<16, f16, 173>;  // n x 16 x  f16 vector value
-def nxv32f16 : VTScalableVec<32, f16, 174>;  // n x 32 x  f16 vector value
-
-def nxv1bf16  : VTScalableVec<1,  bf16, 175>;  // n x  1 x bf16 vector value
-def nxv2bf16  : VTScalableVec<2,  bf16, 176>;  // n x  2 x bf16 vector value
-def nxv4bf16  : VTScalableVec<4,  bf16, 177>;  // n x  4 x bf16 vector value
-def nxv8bf16  : VTScalableVec<8,  bf16, 178>;  // n x  8 x bf16 vector value
-def nxv16bf16 : VTScalableVec<16, bf16, 179>;  // n x 16 x bf16 vector value
-def nxv32bf16 : VTScalableVec<32, bf16, 180>;  // n x 32 x bf16 vector value
-
-def nxv1f32  : VTScalableVec<1,  f32, 181>;  // n x  1 x  f32 vector value
-def nxv2f32  : VTScalableVec<2,  f32, 182>;  // n x  2 x  f32 vector value
-def nxv4f32  : VTScalableVec<4,  f32, 183>;  // n x  4 x  f32 vector value
-def nxv8f32  : VTScalableVec<8,  f32, 184>;  // n x  8 x  f32 vector value
-def nxv16f32 : VTScalableVec<16, f32, 185>;  // n x 16 x  f32 vector value
-
-def nxv1f64  : VTScalableVec<1,  f64, 186>;  // n x  1 x  f64 vector value
-def nxv2f64  : VTScalableVec<2,  f64, 187>;  // n x  2 x  f64 vector value
-def nxv4f64  : VTScalableVec<4,  f64, 188>;  // n x  4 x  f64 vector value
-def nxv8f64  : VTScalableVec<8,  f64, 189>;  // n x  8 x  f64 vector value
-
-def x86mmx    : ValueType<64,   190>;  // X86 MMX value
-def FlagVT    : ValueType<0,    191> { // Pre-RA sched glue
+def f8e4m3fn: VTFP<8,   10>;  // 8-bit floating point value
+def f8e5m2  : VTFP<8,   11>;  // 8-bit floating point value
+def bf16    : VTFP<16,  12>;  // 16-bit brain floating point value
+def f16     : VTFP<16,  13>;  // 16-bit floating point value
+def f32     : VTFP<32,  14>;  // 32-bit floating point value
+def f64     : VTFP<64,  15>;  // 64-bit floating point value
+def f80     : VTFP<80,  16>;  // 80-bit floating point value
+def f128    : VTFP<128, 17>;  // 128-bit floating point value
+def ppcf128 : VTFP<128, 18>;  // PPC 128-bit floating point value
+
+def v1i1    : VTVec<1,    i1, 19>;  //    1 x i1 vector value
+def v2i1    : VTVec<2,    i1, 20>;  //    2 x i1 vector value
+def v3i1    : VTVec<3,    i1, 21>;  //    3 x i1 vector value
+def v4i1    : VTVec<4,    i1, 22>;  //    4 x i1 vector value
+def v8i1    : VTVec<8,    i1, 23>;  //    8 x i1 vector value
+def v16i1   : VTVec<16,   i1, 24>;  //   16 x i1 vector value
+def v32i1   : VTVec<32,   i1, 25>;  //   32 x i1 vector value
+def v64i1   : VTVec<64,   i1, 26>;  //   64 x i1 vector value
+def v128i1  : VTVec<128,  i1, 27>;  //  128 x i1 vector value
+def v256i1  : VTVec<256,  i1, 28>;  //  256 x i1 vector value
+def v512i1  : VTVec<512,  i1, 29>;  //  512 x i1 vector value
+def v1024i1 : VTVec<1024, i1, 30>;  // 1024 x i1 vector value
+def v2048i1 : VTVec<2048, i1, 31>;  // 2048 x i1 vector value
+
+def v128i2  : VTVec<128,  i2, 32>;   //  128 x i2 vector value
+def v256i2  : VTVec<256,  i2, 33>;   //  256 x i2 vector value
+
+def v64i4   : VTVec<64,   i4, 34>;   //   64 x i4 vector value
+def v128i4  : VTVec<128,  i4, 35>;   //  128 x i4 vector value
+
+def v1i8    : VTVec<1,    i8, 36>;  //    1 x i8 vector value
+def v2i8    : VTVec<2,    i8, 37>;  //    2 x i8 vector value
+def v3i8    : VTVec<3,    i8, 38>;  //    3 x i8 vector value
+def v4i8    : VTVec<4,    i8, 39>;  //    4 x i8 vector value
+def v8i8    : VTVec<8,    i8, 40>;  //    8 x i8 vector value
+def v16i8   : VTVec<16,   i8, 41>;  //   16 x i8 vector value
+def v32i8   : VTVec<32,   i8, 42>;  //   32 x i8 vector value
+def v64i8   : VTVec<64,   i8, 43>;  //   64 x i8 vector value
+def v128i8  : VTVec<128,  i8, 44>;  //  128 x i8 vector value
+def v256i8  : VTVec<256,  i8, 45>;  //  256 x i8 vector value
+def v512i8  : VTVec<512,  i8, 46>;  //  512 x i8 vector value
+def v1024i8 : VTVec<1024, i8, 47>;  // 1024 x i8 vector value
+
+def v1i16   : VTVec<1,   i16, 48>;  //   1 x i16 vector value
+def v2i16   : VTVec<2,   i16, 49>;  //   2 x i16 vector value
+def v3i16   : VTVec<3,   i16, 50>;  //   3 x i16 vector value
+def v4i16   : VTVec<4,   i16, 51>;  //   4 x i16 vector value
+def v8i16   : VTVec<8,   i16, 52>;  //   8 x i16 vector value
+def v16i16  : VTVec<16,  i16, 53>;  //  16 x i16 vector value
+def v32i16  : VTVec<32,  i16, 54>;  //  32 x i16 vector value
+def v64i16  : VTVec<64,  i16, 55>;  //  64 x i16 vector value
+def v128i16 : VTVec<128, i16, 56>;  // 128 x i16 vector value
+def v256i16 : VTVec<256, i16, 57>;  // 256 x i16 vector value
+def v512i16 : VTVec<512, i16, 58>;  // 512 x i16 vector value
+
+def v1i32    : VTVec<1,    i32, 59>;  //    1 x i32 vector value
+def v2i32    : VTVec<2,    i32, 60>;  //    2 x i32 vector value
+def v3i32    : VTVec<3,    i32, 61>;  //    3 x i32 vector value
+def v4i32    : VTVec<4,    i32, 62>;  //    4 x i32 vector value
+def v5i32    : VTVec<5,    i32, 63>;  //    5 x i32 vector value
+def v6i32    : VTVec<6,    i32, 64>;  //    6 x f32 vector value
+def v7i32    : VTVec<7,    i32, 65>;  //    7 x f32 vector value
+def v8i32    : VTVec<8,    i32, 66>;  //    8 x i32 vector value
+def v9i32    : VTVec<9,    i32, 67>;  //    9 x i32 vector value
+def v10i32   : VTVec<10,   i32, 68>;  //   10 x i32 vector value
+def v11i32   : VTVec<11,   i32, 69>;  //   11 x i32 vector value
+def v12i32   : VTVec<12,   i32, 70>;  //   12 x i32 vector value
+def v16i32   : VTVec<16,   i32, 71>;  //   16 x i32 vector value
+def v32i32   : VTVec<32,   i32, 72>;  //   32 x i32 vector value
+def v64i32   : VTVec<64,   i32, 73>;  //   64 x i32 vector value
+def v128i32  : VTVec<128,  i32, 74>;  //  128 x i32 vector value
+def v256i32  : VTVec<256,  i32, 75>;  //  256 x i32 vector value
+def v512i32  : VTVec<512,  i32, 76>;  //  512 x i32 vector value
+def v1024i32 : VTVec<1024, i32, 77>;  // 1024 x i32 vector value
+def v2048i32 : VTVec<2048, i32, 78>;  // 2048 x i32 vector value
+
+def v1i64   : VTVec<1,   i64, 79>;  //   1 x i64 vector value
+def v2i64   : VTVec<2,   i64, 80>;  //   2 x i64 vector value
+def v3i64   : VTVec<3,   i64, 81>;  //   3 x i64 vector value
+def v4i64   : VTVec<4,   i64, 82>;  //   4 x i64 vector value
+def v8i64   : VTVec<8,   i64, 83>;  //   8 x i64 vector value
+def v16i64  : VTVec<16,  i64, 84>;  //  16 x i64 vector value
+def v32i64  : VTVec<32,  i64, 85>;  //  32 x i64 vector value
+def v64i64  : VTVec<64,  i64, 86>;  //  64 x i64 vector value
+def v128i64 : VTVec<128, i64, 87>;  // 128 x i64 vector value
+def v256i64 : VTVec<256, i64, 88>;  // 256 x i64 vector value
+
+def v1i128  : VTVec<1,  i128, 89>;  //  1 x i128 vector value
+
+def v1f8e4m3fn    : VTVec<1,    f8e4m3fn,  90>;  //    1 x f8e4m3fn vector value
+def v2f8e4m3fn    : VTVec<2,    f8e4m3fn,  91>;  //    2 x f8e4m3fn vector value
+def v3f8e4m3fn    : VTVec<3,    f8e4m3fn,  92>;  //    3 x f8e4m3fn vector value
+def v4f8e4m3fn    : VTVec<4,    f8e4m3fn,  93>;  //    4 x f8e4m3fn vector value
+def v8f8e4m3fn    : VTVec<8,    f8e4m3fn,  94>;  //    8 x f8e4m3fn vector value
+def v16f8e4m3fn   : VTVec<16,   f8e4m3fn,  95>;  //   16 x f8e4m3fn vector value
+def v32f8e4m3fn   : VTVec<32,   f8e4m3fn,  96>;  //   32 x f8e4m3fn vector value
+def v64f8e4m3fn   : VTVec<64,   f8e4m3fn,  97>;  //   64 x f8e4m3fn vector value
+def v128f8e4m3fn  : VTVec<128,  f8e4m3fn,  98>;  //  128 x f8e4m3fn vector value
+def v256f8e4m3fn  : VTVec<256,  f8e4m3fn,  99>;  //  256 x f8e4m3fn vector value
+def v512f8e4m3fn  : VTVec<512,  f8e4m3fn,  100>;  //  512 x f8e4m3fn vector value
+
+def v1f8e5m2    : VTVec<1,    f8e5m2,  101>;  //    1 x f8e5m2 vector value
+def v2f8e5m2    : VTVec<2,    f8e5m2,  102>;  //    2 x f8e5m2 vector value
+def v3f8e5m2    : VTVec<3,    f8e5m2,  103>;  //    3 x f8e5m2 vector value
+def v4f8e5m2    : VTVec<4,    f8e5m2,  104>;  //    4 x f8e5m2 vector value
+def v8f8e5m2    : VTVec<8,    f8e5m2,  105>;  //    8 x f8e5m2 vector value
+def v16f8e5m2   : VTVec<16,   f8e5m2,  106>;  //   16 x f8e5m2 vector value
+def v32f8e5m2   : VTVec<32,   f8e5m2,  107>;  //   32 x f8e5m2 vector value
+def v64f8e5m2   : VTVec<64,   f8e5m2,  108>;  //   64 x f8e5m2 vector value
+def v128f8e5m2  : VTVec<128,  f8e5m2,  109>;  //  128 x f8e5m2 vector value
+def v256f8e5m2  : VTVec<256,  f8e5m2,  110>;  //  256 x f8e5m2 vector value
+def v512f8e5m2  : VTVec<512,  f8e5m2,  111>;  //  512 x f8e5m2 vector value
+
+def v1f16    : VTVec<1,    f16,  112>;  //    1...
[truncated]

arsenm

These are supposed to mirror IR types. How are these useful without the corresponding high level IR types?

JinjinLi868 · 2024-04-26T03:27:10Z

These are supposed to mirror IR types. How are these useful without the corresponding high level IR types?

on there #89900

arsenm

LGTM as the trivial follow up to #89900, wait for that one before submitting this

RKSimon · 2024-04-26T11:04:33Z

llvm/include/llvm/CodeGenTypes/MachineValueType.h

@@ -49,7 +49,7 @@ namespace llvm {
      // This is the current maximum for LAST_VALUETYPE.
      // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
      // This value must be a multiple of 32.


Does this still hold? In which case (255 % 32) != 0

RKSimon · 2024-06-12T10:12:27Z

@JinjinLi868 reverse-ping?

[CodeGen][Float8] Add float8 MVT type

0ea9686

This patch adds float8(e4m3fn and e5m2) MVT support. It also adds fixed and scalable vector MVT types for float8.

llvmbot added llvm:SelectionDAG SelectionDAGISel as well llvm:ir labels Apr 24, 2024

arsenm reviewed Apr 24, 2024

View reviewed changes

This was referenced Apr 24, 2024

[IR][Float8] Add two kinds float8 IR type #89900

Open

[IR][Float8] Add Float8 IR intrinsics support #89902

Open

arsenm approved these changes Apr 26, 2024

View reviewed changes

RKSimon reviewed Apr 26, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[CodeGen][Float8] Add float8 MVT type #89901

[CodeGen][Float8] Add float8 MVT type #89901

JinjinLi868 commented Apr 24, 2024 •

edited

Loading

github-actions bot commented Apr 24, 2024

llvmbot commented Apr 24, 2024 •

edited

Loading

arsenm left a comment

JinjinLi868 commented Apr 26, 2024

arsenm left a comment

RKSimon Apr 26, 2024

RKSimon commented Jun 12, 2024

[CodeGen][Float8] Add float8 MVT type #89901

Are you sure you want to change the base?

[CodeGen][Float8] Add float8 MVT type #89901

Conversation

JinjinLi868 commented Apr 24, 2024 • edited Loading

github-actions bot commented Apr 24, 2024

llvmbot commented Apr 24, 2024 • edited Loading

arsenm left a comment

Choose a reason for hiding this comment

JinjinLi868 commented Apr 26, 2024

arsenm left a comment

Choose a reason for hiding this comment

RKSimon Apr 26, 2024

Choose a reason for hiding this comment

RKSimon commented Jun 12, 2024

JinjinLi868 commented Apr 24, 2024 •

edited

Loading

llvmbot commented Apr 24, 2024 •

edited

Loading