Add LLVM type support for fp8

[kushanam]

Summary

(see the change adding fp8 support to APFloat: https://reviews.llvm.org/D133823)

The purpose of this patch is to add the two FP8 data types (E5M2 and E4M3) to the LLVM. This is the first step towards adding high level FP8 support. The consequent steps will enable the target specific codegen datatype lowerings.

Update: The RFC is posted here: https://discourse.llvm.org/t/add-llvm-type-support-for-fp8-data-types-f8e4m3-and-f8e5m2/67598

[jakeh-gc]

Would it be possible to qualify the E4M3 type similarly to the APFloat semantics?
My personal preference would be the FN (finite with NaN) suffix. E4M3FN with appropriate casing in each context.

[rengolin]

Make sure you add a note to the changelog, so people know you've changed all the enums involved.

[stellaraccident]

Hi Renato - I've reviewed and this lgtm, but I rarely work on/review this part of the codebase. Do you feel like you are a good reviewer for it (the author reached out to me asking for some help coordinating reviewers)?

[ezhulenev]

llvm/include/llvm/CodeGen/ValueTypes.td

242

Comments mention f16 vectors (should be f8)

[kushanam]

addressing the "Comments mention f16 vectors (should be f8)" comment

llvm/include/llvm/CodeGen/ValueTypes.td

242

Comments mention f16 vectors (should be f8)

Thanks, Addressed.

[stellaraccident]

llvm/include/llvm/CodeGen/SelectionDAG.h

1819

I think we agreed that this should be f8e4m3 (no "p") to match the others. We would follow the convention that we established in MLIR, as that was what was discussed.

https://github.com/llvm/llvm-project/blob/main/mlir/lib/AsmParser/TokenKinds.def#L96

[arsenm]

Missing bitcode and assembler tests

llvm/include/llvm-c/Core.h

150

Typo but

llvm/include/llvm/IR/Type.h

161

Capitalize Bit

190–192

Should add some transform tests that hit this

[arsenm]

llvm/lib/IR/Constants.cpp

1543–1555

This isn't tested

3165–3172

Not tested

[arsenm]

llvm/lib/IR/Type.cpp

40–43

Move to bottom?

[dmgreen]

llvm/docs/BitCodeFormat.rst

1150

code 26 -> code 27

llvm/include/llvm/Support/MachineValueType.h

222

These look like they will be incorrect for the newly added vector sizes. Same for the SCALABLE ones below.

333

This looks like it might be overflowing now too.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

2308

HALF -> FP8

[arsenm]

llvm/include/llvm-c/Core.h

150–151

You can't break the C API. Thees need to go to the end

[kushanam]

Addressing review commnents, adding funtionality to pass the MLIR tests

[arsenm]

Tests still missing

[kushanam]

In D140088#4005134, @arsenm wrote:

Tests still missing

Hi @arsenm, I looked at the existing tests and got an assumption that the existing way to test those, is to have the codegen pipeline supporting the datatype in the "Target" level. That is something I am working on for the follow up patch and thought then I could add the tests. If you could give me a pointer to the existing tests that I might have missed, I would add them. Thank you in advance!

[arsenm]

In D140088#4005142, @kushanam wrote:

In D140088#4005134, @arsenm wrote:

Tests still missing

Hi @arsenm, I looked at the existing tests and got an assumption that the existing way to test those, is to have the codegen pipeline supporting the datatype in the "Target" level. That is something I am working on for the follow up patch and thought then I could add the tests. If you could give me a pointer to the existing tests that I might have missed, I would add them. Thank you in advance!

All of the IR changes are testable without codegen support. Needs some tests in test/Assembler, test/Bitcode, test/Verifier, and some constant folding tests in test/Transforms/InstSimplify. See 8c24f33158d81d5f4b0c5d27c2f07396f0f1484b which added bfloat (although this includes far fewer tests than I would have liked to see. For example it's missing the all important bitcode compatibility tests)

[arsenm]

In D140088#4005153, @arsenm wrote:

In D140088#4005142, @kushanam wrote:

In D140088#4005134, @arsenm wrote:

Tests still missing

Hi @arsenm, I looked at the existing tests and got an assumption that the existing way to test those, is to have the codegen pipeline supporting the datatype in the "Target" level. That is something I am working on for the follow up patch and thought then I could add the tests. If you could give me a pointer to the existing tests that I might have missed, I would add them. Thank you in advance!

All of the IR changes are testable without codegen support. Needs some tests in test/Assembler, test/Bitcode, test/Verifier, and some constant folding tests in test/Transforms/InstSimplify. See 8c24f33158d81d5f4b0c5d27c2f07396f0f1484b which added bfloat (although this includes far fewer tests than I would have liked to see. For example it's missing the all important bitcode compatibility tests)

I think I covered all the bases for testing an IR change in D139902. This is a bit broader as it's a type

[kushanam]

In D140088#4005160, @arsenm wrote:

In D140088#4005153, @arsenm wrote:

In D140088#4005142, @kushanam wrote:

In D140088#4005134, @arsenm wrote:

Tests still missing

Hi @arsenm, I looked at the existing tests and got an assumption that the existing way to test those, is to have the codegen pipeline supporting the datatype in the "Target" level. That is something I am working on for the follow up patch and thought then I could add the tests. If you could give me a pointer to the existing tests that I might have missed, I would add them. Thank you in advance!

All of the IR changes are testable without codegen support. Needs some tests in test/Assembler, test/Bitcode, test/Verifier, and some constant folding tests in test/Transforms/InstSimplify. See 8c24f33158d81d5f4b0c5d27c2f07396f0f1484b which added bfloat (although this includes far fewer tests than I would have liked to see. For example it's missing the all important bitcode compatibility tests)

I think I covered all the bases for testing an IR change in D139902. This is a bit broader as it's a type

Thank you Matt, for the pointers.

[kushanam]

Adding the smoke tests for f8e5m2 and f6e4m3 types

[arsenm]

Also needs bitcode compatibility.ll test

llvm/test/Assembler/fp8.ll

2

no opt, especially -O3

28–32

The constant folding tests belong in test/Transforms/InstSimplify, and should cover the full range of floating point classes and operations

61

Should check math intrinsics

[arsenm]

llvm/lib/IR/Type.cpp

214–223

This whole function should probably convert to a switch

[nikic]

Is there an RFC for this change? In https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279 the addition of an LLVM IR type was explicitly out of scope. See also in particular the comment by @efriedma here: https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279/3

I'm personally rather skeptical about adding new ad-hoc floating-point types to IR without at least some restructuring of the existing system. At the IR level, my expectation would be that all the different float types get consolidated into a single type that is parameterized over the floating-point semantics.

[pjannaty]

In D140088#4015926, @nikic wrote:

Is there an RFC for this change? In https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279 the addition of an LLVM IR type was explicitly out of scope. See also in particular the comment by @efriedma here: https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279/3

I'm personally rather skeptical about adding new ad-hoc floating-point types to IR without at least some restructuring of the existing system. At the IR level, my expectation would be that all the different float types get consolidated into a single type that is parameterized over the floating-point semantics.

Hi Nikita et al, Thanks for the feedback. The idea of parametrizing APFloat sounds like a neat one, though also complex given both the amount of overhauling that is needed to get it right, as well as the need for proper design and dealing with a myriad of exceptions (e.g. NaNs, Infs, etc), for which my team doesn't have LLVM competence (or bandwidth) yet to implement on our own. From a pragmatic standpoint, I am afraid this effort would require many months of concerted planning, deliberation, implementation and testing before it would be ready to serve as a basis for FP8 extensions.

As you may know, the introduction of FP8 is one of the main features of NVIDIA's new Hopper GPUs, so we are trying very hard to adopt it across all DL frameworks. We hope LLVM will be a benefit in this process, since its features are inherited by many different frameworks. This patch (which defines the types) and another currently in development (to introduce ptx codegen) is needed as part of supporting native Hopper instructions for FP8 casts. My team has already implemented FP8 support in XLA and we now have end-to-end support in TF (and JAX and others) through XLA. If the changes cannot be provided in LLVM in a reasonable timeframe, we will need to pursue framework specific hacks to enable efficient type conversions, which is something we'd very much like to avoid.

[stellaraccident]

In D140088#4015926, @nikic wrote:

Is there an RFC for this change? In https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279 the addition of an LLVM IR type was explicitly out of scope. See also in particular the comment by @efriedma here: https://discourse.llvm.org/t/rfc-add-apfloat-and-mlir-type-support-for-fp8-e5m2/65279/3

I'm personally rather skeptical about adding new ad-hoc floating-point types to IR without at least some restructuring of the existing system. At the IR level, my expectation would be that all the different float types get consolidated into a single type that is parameterized over the floating-point semantics.

Indeed, the original RFC was scoped to enable a further discussion about adding these types to LLVM IR but did not address that topic itself. I don't work on this level of LLVM, and all I can offer is:

• On the MLIR side, we concluded that we didn't need to figure out a generalization strategy for this scope (yet) given the existing parameterization on fltSemantics (which is similar to LLVM).
• Much of this was modeled after patches to add BFLOAT16 support to APFloat/MLIR/LLVM, and that was deemed a straight-forward addition (but we don't just blindly carry forward precedent, so just fyi).

Sounds like an RFC is in order?

[nikic]

To clarify, I'm not necessarily saying that we can't move forward with this implementation approach, just that it should go through an RFC to have a wider discussion on the topic. The outcome of that may well be that we should just carry on as before.

I should also clarify that I'm definitely not excepting a fully-generic floating point system in the same vein as we have for integers, but rather some more consolidated handling for floating-point types (as a single floating point type parameterized over semantics, rather than a collection of many separate types). Based on @stellaraccident's comment, that would be similar to what MLIR does? This should be much simpler to do than fully-generic floats.

Finally, I think something very important when it comes to these specific types (as opposed to "more float types" in general) is that these types deviate from IEEE semantics in ways that existing types don't, so need to be careful about how these affect IR semantics and middle-end optimization. I'm pretty sure that just exposing the existing code to these types will cause miscompiles in some cases -- e.g. it looks like creating an infinity value of these types will create a NaN instead, so if we create Inf as a neutral value for min/max, we'll now use NaN instead, which would be incorrect. There's probably more things like this lurking in various transforms.

In order to be reasonably confident about optimization correctness for these types, what we'd want is to land basic LangRef + IR support first, then work with @nlopes for Alive2 support (ironing out and specifying any details about semantics along the way) and then duplicating key bits of existing tests for the new types, and checking that alive2 does not detect miscompiles.

llvm/tools/llvm-c-test/echo.cpp

83

Drive-by note: This is creating the wrong type...

llvm/docs/BitCodeFormat.rst

 TYPE_CODE_HALF Record
 ^^^^^^^^^^^^^^^^^^^^^
 
 ``[HALF]``
 
 The ``HALF`` record (code 10) adds a ``half`` (16-bit floating point) type to
 the type table.
 
+TYPE_CODE_F8E5M2 Record
+^^^^^^^^^^^^^^^^^^^^^
+
+``[F8E5M2]``
+
+The ``F8E5M2`` record (code 26) adds an ``F8E5M2`` (8-bit floating point) type to
+the type table.
+
+TYPE_CODE_F8E4M3 Record
+^^^^^^^^^^^^^^^^^^^^^
+
+``[F8E4M3]``
+
+The ``F8E4M3`` record (code 27) adds an ``F8E4M3`` (8-bit floating point) type to
+the type table.
+
 TYPE_CODE_BFLOAT Record
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 ``[BFLOAT]``
 
 The ``BFLOAT`` record (code 23) adds a ``bfloat`` (16-bit brain floating point)
 type to the type table.
 

llvm/include/llvm-c/Core.h

typedef enum {
   LLVMCatchRet       = 62,
   LLVMCatchPad       = 63,
   LLVMCleanupPad     = 64,
   LLVMCatchSwitch    = 65
 } LLVMOpcode;
 
 typedef enum {
   LLVMVoidTypeKind,      /**< type with no size */
   LLVMHalfTypeKind,      /**< 16 bit floating point type */
   LLVMFloatTypeKind,     /**< 32 bit floating point type */
   LLVMDoubleTypeKind,    /**< 64 bit floating point type */
   LLVMX86_FP80TypeKind,  /**< 80 bit floating point type (X87) */
   LLVMFP128TypeKind,     /**< 128 bit floating point type (112-bit mantissa)*/
   LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
   LLVMLabelTypeKind,     /**< Labels */
   LLVMIntegerTypeKind,   /**< Arbitrary bit width integers */
   LLVMFunctionTypeKind,  /**< Functions */
   LLVMStructTypeKind,    /**< Structures */
   LLVMArrayTypeKind,     /**< Arrays */
   LLVMPointerTypeKind,   /**< Pointers */
   LLVMVectorTypeKind,    /**< Fixed width SIMD vector type */
   LLVMMetadataTypeKind,  /**< Metadata */
   LLVMX86_MMXTypeKind,   /**< X86 MMX */
   LLVMTokenTypeKind,     /**< Tokens */
   LLVMScalableVectorTypeKind, /**< Scalable SIMD vector type */
   LLVMBFloatTypeKind,    /**< 16 bit brain floating point type */
-  LLVMX86_AMXTypeKind    /**< X86 AMX */
+  LLVMX86_AMXTypeKind,    /**< X86 AMX */
+  LLVMFloatE4M3TypeKind, /**< 8 bit floating point with 3 bit mantissa */
+  LLVMFloatE5M2TypeKind  /**< 8 bit floating point with 2 bit mantissa */
 } LLVMTypeKind;
 
 typedef enum {
   LLVMExternalLinkage,    /**< Externally visible function */
   LLVMAvailableExternallyLinkage,
   LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
   LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
                             equivalent. */

 
 /**
  * @defgroup LLVMCCoreTypeFloat Floating Point Types
  *
  * @{
  */
 
 /**
+ * Obtain a 8-bit floating point type from a context.
+ */
+LLVMTypeRef LLVMFloatE4M3TypeInContext(LLVMContextRef C);
+
+/**
+ * Obtain a 8-bit floating point type from a context.
+ */
+LLVMTypeRef LLVMFloatE5M2TypeInContext(LLVMContextRef C);
+
+/**
  * Obtain a 16-bit floating point type from a context.
  */
 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
 
 /**
  * Obtain a 16-bit brain floating point type from a context.
  */
 LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C);

  */
 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
 
 /**
  * Obtain a floating point type from the global context.
  *
  * These map to the functions in this group of the same name.
  */
+LLVMTypeRef LLVMFloatE4M3Type(void);
+LLVMTypeRef LLVMFloatE5M2Type(void);
 LLVMTypeRef LLVMHalfType(void);
 LLVMTypeRef LLVMBFloatType(void);
 LLVMTypeRef LLVMFloatType(void);
 LLVMTypeRef LLVMDoubleType(void);
 LLVMTypeRef LLVMX86FP80Type(void);
 LLVMTypeRef LLVMFP128Type(void);
 LLVMTypeRef LLVMPPCFP128Type(void);
 

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum TypeCodes {
   TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
 
   TYPE_CODE_TOKEN = 22, // TOKEN
 
   TYPE_CODE_BFLOAT = 23,  // BRAIN FLOATING POINT
   TYPE_CODE_X86_AMX = 24, // X86 AMX
 
   TYPE_CODE_OPAQUE_POINTER = 25, // OPAQUE_POINTER: [addrspace]
+
+  TYPE_CODE_F8E5M2 = 26, // F8E5M2
+  TYPE_CODE_F8E4M3 = 27, // F8E4M3
 };
 
 enum OperandBundleTagCode {
   OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N]
 };
 
 enum SyncScopeNameCode {
   SYNC_SCOPE_NAME = 1,

llvm/include/llvm/CodeGen/SelectionDAG.h

void RepositionNode(allnodes_iterator Position, SDNode *N) {
     AllNodes.insert(Position, AllNodes.remove(N));
   }
 
   /// Returns an APFloat semantics tag appropriate for the given type. If VT is
   /// a vector type, the element semantics are returned.
   static const fltSemantics &EVTToAPFloatSemantics(EVT VT) {
     switch (VT.getScalarType().getSimpleVT().SimpleTy) {
     default: llvm_unreachable("Unknown FP format");
+    case MVT::f8e4m3:
+      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();
     case MVT::f64:     return APFloat::IEEEdouble();
     case MVT::f80:     return APFloat::x87DoubleExtended();
     case MVT::f128:    return APFloat::IEEEquad();
     case MVT::ppcf128: return APFloat::PPCDoubleDouble();
     }

llvm/include/llvm/CodeGen/ValueTypes.td

 def i2      : ValueType<2,   3>;  // 2-bit integer value
 def i4      : ValueType<4,   4>;  // 4-bit integer value
 def i8      : ValueType<8,   5>;  // 8-bit integer value
 def i16     : ValueType<16,  6>;  // 16-bit integer value
 def i32     : ValueType<32,  7>;  // 32-bit integer value
 def i64     : ValueType<64,  8>;  // 64-bit integer value
 def i128    : ValueType<128, 9>;  // 128-bit integer value
 
-def bf16    : ValueType<16,  10>;  // 16-bit brain floating point value
-def f16     : ValueType<16,  11>;  // 16-bit floating point value
-def f32     : ValueType<32,  12>;  // 32-bit floating point value
-def f64     : ValueType<64,  13>;  // 64-bit floating point value
-def f80     : ValueType<80,  14>;  // 80-bit floating point value
-def f128    : ValueType<128, 15>;  // 128-bit floating point value
-def ppcf128 : ValueType<128, 16>;  // PPC 128-bit floating point value
-
-def v1i1    : ValueType<1,    17>;  //    1 x i1 vector value
-def v2i1    : ValueType<2,    18>;  //    2 x i1 vector value
-def v4i1    : ValueType<4,    19>;  //    4 x i1 vector value
-def v8i1    : ValueType<8,    20>;  //    8 x i1 vector value
-def v16i1   : ValueType<16,   21>;  //   16 x i1 vector value
-def v32i1   : ValueType<32,   22>;  //   32 x i1 vector value
-def v64i1   : ValueType<64,   23>;  //   64 x i1 vector value
-def v128i1  : ValueType<128,  24>;  //  128 x i1 vector value
-def v256i1  : ValueType<256,  25>;  //  256 x i1 vector value
-def v512i1  : ValueType<512,  26>;  //  512 x i1 vector value
-def v1024i1 : ValueType<1024, 27>;  // 1024 x i1 vector value
-def v2048i1 : ValueType<2048, 28>;  // 2048 x i1 vector value
-
-def v128i2  : ValueType<256,  29>;   //  128 x i2 vector value
-def v256i2  : ValueType<512,  30>;   //  256 x i2 vector value
-
-def v64i4   : ValueType<256,  31>;   //   64 x i4 vector value
-def v128i4  : ValueType<512,  32>;   //  128 x i4 vector value
-
-def v1i8    : ValueType<8,    33>;  //    1 x i8 vector value
-def v2i8    : ValueType<16,   34>;  //    2 x i8 vector value
-def v4i8    : ValueType<32,   35>;  //    4 x i8 vector value
-def v8i8    : ValueType<64,   36>;  //    8 x i8 vector value
-def v16i8   : ValueType<128,  37>;  //   16 x i8 vector value
-def v32i8   : ValueType<256,  38>;  //   32 x i8 vector value
-def v64i8   : ValueType<512,  39>;  //   64 x i8 vector value
-def v128i8  : ValueType<1024, 40>;  //  128 x i8 vector value
-def v256i8  : ValueType<2048, 41>;  //  256 x i8 vector value
-def v512i8  : ValueType<4096, 42>;  //  512 x i8 vector value
-def v1024i8 : ValueType<8192, 43>;  // 1024 x i8 vector value
-
-def v1i16   : ValueType<16,   44>;  //   1 x i16 vector value
-def v2i16   : ValueType<32,   45>;  //   2 x i16 vector value
-def v3i16   : ValueType<48,   46>;  //   3 x i16 vector value
-def v4i16   : ValueType<64,   47>;  //   4 x i16 vector value
-def v8i16   : ValueType<128,  48>;  //   8 x i16 vector value
-def v16i16  : ValueType<256,  49>;  //  16 x i16 vector value
-def v32i16  : ValueType<512,  50>;  //  32 x i16 vector value
-def v64i16  : ValueType<1024, 51>;  //  64 x i16 vector value
-def v128i16 : ValueType<2048, 52>;  // 128 x i16 vector value
-def v256i16 : ValueType<4096, 53>;  // 256 x i16 vector value
-def v512i16 : ValueType<8192, 54>;  // 512 x i16 vector value
-
-def v1i32    : ValueType<32,    55>;  //    1 x i32 vector value
-def v2i32    : ValueType<64,    56>;  //    2 x i32 vector value
-def v3i32    : ValueType<96,    57>;  //    3 x i32 vector value
-def v4i32    : ValueType<128,   58>;  //    4 x i32 vector value
-def v5i32    : ValueType<160,   59>;  //    5 x i32 vector value
-def v6i32    : ValueType<192,   60>;  //    6 x f32 vector value
-def v7i32    : ValueType<224,   61>;  //    7 x f32 vector value
-def v8i32    : ValueType<256,   62>;  //    8 x i32 vector value
-def v9i32    : ValueType<288,   63>;  //    9 x i32 vector value
-def v10i32   : ValueType<320,   64>;  //   10 x i32 vector value
-def v11i32   : ValueType<352,   65>;  //   11 x i32 vector value
-def v12i32   : ValueType<384,   66>;  //   12 x i32 vector value
-def v16i32   : ValueType<512,   67>;  //   16 x i32 vector value
-def v32i32   : ValueType<1024,  68>;  //   32 x i32 vector value
-def v64i32   : ValueType<2048,  69>;  //   64 x i32 vector value
-def v128i32  : ValueType<4096,  70>;  //  128 x i32 vector value
-def v256i32  : ValueType<8192,  71>;  //  256 x i32 vector value
-def v512i32  : ValueType<16384, 72>;  //  512 x i32 vector value
-def v1024i32 : ValueType<32768, 73>;  // 1024 x i32 vector value
-def v2048i32 : ValueType<65536, 74>;  // 2048 x i32 vector value
-
-def v1i64   : ValueType<64,    75>;  //   1 x i64 vector value
-def v2i64   : ValueType<128,   76>;  //   2 x i64 vector value
-def v3i64   : ValueType<192,   77>;  //   3 x i64 vector value
-def v4i64   : ValueType<256,   78>;  //   4 x i64 vector value
-def v8i64   : ValueType<512,   79>;  //   8 x i64 vector value
-def v16i64  : ValueType<1024,  80>;  //  16 x i64 vector value
-def v32i64  : ValueType<2048,  81>;  //  32 x i64 vector value
-def v64i64  : ValueType<4096,  82>;  //  64 x i64 vector value
-def v128i64 : ValueType<8192,  83>;  // 128 x i64 vector value
-def v256i64 : ValueType<16384, 84>;  // 256 x i64 vector value
-
-def v1i128 : ValueType<128, 85>;  //  1 x i128 vector value
-
-def v1f16    : ValueType<16,     86>;  //    1 x f16 vector value
-def v2f16    : ValueType<32,     87>;  //    2 x f16 vector value
-def v3f16    : ValueType<48,     88>;  //    3 x f16 vector value
-def v4f16    : ValueType<64,     89>;  //    4 x f16 vector value
-def v8f16    : ValueType<128,    90>;  //    8 x f16 vector value
-def v16f16   : ValueType<256,    91>;  //   16 x f16 vector value
-def v32f16   : ValueType<512,    92>;  //   32 x f16 vector value
-def v64f16   : ValueType<1024,   93>;  //   64 x f16 vector value
-def v128f16  : ValueType<2048,   94>;  //  128 x f16 vector value
-def v256f16  : ValueType<4096,   95>;  //  256 x f16 vector value
-def v512f16  : ValueType<8192,   96>;  //  512 x f16 vector value
-
-def v2bf16   : ValueType<32,     97>;  //    2 x bf16 vector value
-def v3bf16   : ValueType<48,     98>;  //    3 x bf16 vector value
-def v4bf16   : ValueType<64,     99>;  //    4 x bf16 vector value
-def v8bf16   : ValueType<128,   100>;  //    8 x bf16 vector value
-def v16bf16  : ValueType<256,   101>;  //   16 x bf16 vector value
-def v32bf16  : ValueType<512,   102>;  //   32 x bf16 vector value
-def v64bf16  : ValueType<1024,  103>;  //   64 x bf16 vector value
-def v128bf16 : ValueType<2048,  104>;  //  128 x bf16 vector value
-
-def v1f32    : ValueType<32,    105>;  //    1 x f32 vector value
-def v2f32    : ValueType<64,    106>;  //    2 x f32 vector value
-def v3f32    : ValueType<96,    107>;  //    3 x f32 vector value
-def v4f32    : ValueType<128,   108>;  //    4 x f32 vector value
-def v5f32    : ValueType<160,   109>;  //    5 x f32 vector value
-def v6f32    : ValueType<192,   110>;  //    6 x f32 vector value
-def v7f32    : ValueType<224,   111>;  //    7 x f32 vector value
-def v8f32    : ValueType<256,   112>;  //    8 x f32 vector value
-def v9f32    : ValueType<288,   113>;  //    9 x f32 vector value
-def v10f32   : ValueType<320,   114>;  //   10 x f32 vector value
-def v11f32   : ValueType<352,   115>;  //   11 x f32 vector value
-def v12f32   : ValueType<384,   116>;  //   12 x f32 vector value
-def v16f32   : ValueType<512,   117>;  //   16 x f32 vector value
-def v32f32   : ValueType<1024,  118>;  //   32 x f32 vector value
-def v64f32   : ValueType<2048,  119>;  //   64 x f32 vector value
-def v128f32  : ValueType<4096,  120>;  //  128 x f32 vector value
-def v256f32  : ValueType<8192,  121>;  //  256 x f32 vector value
-def v512f32  : ValueType<16384, 122>;  //  512 x f32 vector value
-def v1024f32 : ValueType<32768, 123>;  // 1024 x f32 vector value
-def v2048f32 : ValueType<65536, 124>;  // 2048 x f32 vector value
-
-def v1f64    : ValueType<64,    125>;  //    1 x f64 vector value
-def v2f64    : ValueType<128,   126>;  //    2 x f64 vector value
-def v3f64    : ValueType<192,   127>;  //    3 x f64 vector value
-def v4f64    : ValueType<256,   128>;  //    4 x f64 vector value
-def v8f64    : ValueType<512,   129>;  //    8 x f64 vector value
-def v16f64   : ValueType<1024,  130>;  //   16 x f64 vector value
-def v32f64   : ValueType<2048,  131>;  //   32 x f64 vector value
-def v64f64   : ValueType<4096,  132>;  //   64 x f64 vector value
-def v128f64  : ValueType<8192,  133>;  //  128 x f64 vector value
-def v256f64  : ValueType<16384, 134>;  //  256 x f64 vector value
-
-def nxv1i1  : ValueType<1,  135>;  // n x  1 x i1  vector value
-def nxv2i1  : ValueType<2,  136>;  // n x  2 x i1  vector value
-def nxv4i1  : ValueType<4,  137>;  // n x  4 x i1  vector value
-def nxv8i1  : ValueType<8,  138>;  // n x  8 x i1  vector value
-def nxv16i1 : ValueType<16, 139>;  // n x 16 x i1  vector value
-def nxv32i1 : ValueType<32, 140>;  // n x 32 x i1  vector value
-def nxv64i1 : ValueType<64, 141>;  // n x 64 x i1  vector value
-
-def nxv1i8  : ValueType<8,   142>;  // n x  1 x i8  vector value
-def nxv2i8  : ValueType<16,  143>;  // n x  2 x i8  vector value
-def nxv4i8  : ValueType<32,  144>;  // n x  4 x i8  vector value
-def nxv8i8  : ValueType<64,  145>;  // n x  8 x i8  vector value
-def nxv16i8 : ValueType<128, 146>;  // n x 16 x i8  vector value
-def nxv32i8 : ValueType<256, 147>;  // n x 32 x i8  vector value
-def nxv64i8 : ValueType<512, 148>;  // n x 64 x i8  vector value
-
-def nxv1i16  : ValueType<16,  149>;  // n x  1 x i16 vector value
-def nxv2i16  : ValueType<32,  150>;  // n x  2 x i16 vector value
-def nxv4i16  : ValueType<64,  151>;  // n x  4 x i16 vector value
-def nxv8i16  : ValueType<128, 152>;  // n x  8 x i16 vector value
-def nxv16i16 : ValueType<256, 153>;  // n x 16 x i16 vector value
-def nxv32i16 : ValueType<512, 154>;  // n x 32 x i16 vector value
-
-def nxv1i32  : ValueType<32,   155>;  // n x  1 x i32 vector value
-def nxv2i32  : ValueType<64,   156>;  // n x  2 x i32 vector value
-def nxv4i32  : ValueType<128,  157>;  // n x  4 x i32 vector value
-def nxv8i32  : ValueType<256,  158>;  // n x  8 x i32 vector value
-def nxv16i32 : ValueType<512,  159>;  // n x 16 x i32 vector value
-def nxv32i32 : ValueType<1024, 160>;  // n x 32 x i32 vector value
-
-def nxv1i64  : ValueType<64,   161>;  // n x  1 x i64 vector value
-def nxv2i64  : ValueType<128,  162>;  // n x  2 x i64 vector value
-def nxv4i64  : ValueType<256,  163>;  // n x  4 x i64 vector value
-def nxv8i64  : ValueType<512,  164>;  // n x  8 x i64 vector value
-def nxv16i64 : ValueType<1024, 165>;  // n x 16 x i64 vector value
-def nxv32i64 : ValueType<2048, 166>;  // n x 32 x i64 vector value
-
-def nxv1f16  : ValueType<16,  167>;  // n x  1 x  f16 vector value
-def nxv2f16  : ValueType<32,  168>;  // n x  2 x  f16 vector value
-def nxv4f16  : ValueType<64,  169>;  // n x  4 x  f16 vector value
-def nxv8f16  : ValueType<128, 170>;  // n x  8 x  f16 vector value
-def nxv16f16 : ValueType<256, 171>;  // n x 16 x  f16 vector value
-def nxv32f16 : ValueType<512, 172>;  // n x 32 x  f16 vector value
-
-def nxv1bf16 : ValueType<16,  173>;  // n x  1 x bf16 vector value
-def nxv2bf16 : ValueType<32,  174>;  // n x  2 x bf16 vector value
-def nxv4bf16 : ValueType<64,  175>;  // n x  4 x bf16 vector value
-def nxv8bf16 : ValueType<128, 176>;  // n x  8 x bf16 vector value
-def nxv16bf16 : ValueType<256, 177>;  // n x 16 x bf16 vector value
-def nxv32bf16 : ValueType<512, 178>;  // n x 32 x bf16 vector value
-
-def nxv1f32  : ValueType<32,  179>;  // n x  1 x  f32 vector value
-def nxv2f32  : ValueType<64,  180>;  // n x  2 x  f32 vector value
-def nxv4f32  : ValueType<128, 181>;  // n x  4 x  f32 vector value
-def nxv8f32  : ValueType<256, 182>;  // n x  8 x  f32 vector value
-def nxv16f32 : ValueType<512, 183>;  // n x 16 x  f32 vector value
-
-def nxv1f64  : ValueType<64,  184>;  // n x  1 x  f64 vector value
-def nxv2f64  : ValueType<128, 185>;  // n x  2 x  f64 vector value
-def nxv4f64  : ValueType<256, 186>;  // n x  4 x  f64 vector value
-def nxv8f64  : ValueType<512, 187>;  // n x  8 x  f64 vector value
-
-def x86mmx    : ValueType<64,   188>;  // X86 MMX value
-def FlagVT    : ValueType<0,    189>;  // Pre-RA sched glue
-def isVoid    : ValueType<0,    190>;  // Produces no value
-def untyped   : ValueType<8,    191>;  // Produces an untyped value
-def funcref   : ValueType<0,    192>;  // WebAssembly's funcref type
-def externref : ValueType<0,    193>;  // WebAssembly's externref type
-def x86amx    : ValueType<8192, 194>;  // X86 AMX value
-def i64x8     : ValueType<512,  195>;  // 8 Consecutive GPRs (AArch64)
+def f8e4m3 : ValueType<8,   10>;   // 8-bit brain floating point value
+def f8e5m2 : ValueType<8,   11>;   // 8-bit brain floating point value
+def bf16    : ValueType<16,  12>;  // 16-bit brain floating point value
+def f16     : ValueType<16,  13>;  // 16-bit floating point value
+def f32     : ValueType<32,  14>;  // 32-bit floating point value
+def f64     : ValueType<64,  15>;  // 64-bit floating point value
+def f80     : ValueType<80,  16>;  // 80-bit floating point value
+def f128    : ValueType<128, 17>;  // 128-bit floating point value
+def ppcf128 : ValueType<128, 18>;  // PPC 128-bit floating point value
+
+def v1i1    : ValueType<1,    19>;  //    1 x i1 vector value
+def v2i1    : ValueType<2,    20>;  //    2 x i1 vector value
+def v4i1    : ValueType<4,    21>;  //    4 x i1 vector value
+def v8i1    : ValueType<8,    22>;  //    8 x i1 vector value
+def v16i1   : ValueType<16,   23>;  //   16 x i1 vector value
+def v32i1   : ValueType<32,   24>;  //   32 x i1 vector value
+def v64i1   : ValueType<64,   25>;  //   64 x i1 vector value
+def v128i1  : ValueType<128,  26>;  //  128 x i1 vector value
+def v256i1  : ValueType<256,  27>;  //  256 x i1 vector value
+def v512i1  : ValueType<512,  28>;  //  512 x i1 vector value
+def v1024i1 : ValueType<1024, 29>;  // 1024 x i1 vector value
+def v2048i1 : ValueType<2048, 30>;  // 2048 x i1 vector value
+
+def v128i2  : ValueType<256,  31>;   //  128 x i2 vector value
+def v256i2  : ValueType<512,  32>;   //  256 x i2 vector value
+
+def v64i4   : ValueType<256,  33>;   //   64 x i4 vector value
+def v128i4  : ValueType<512,  34>;   //  128 x i4 vector value
+
+def v1i8    : ValueType<8,    35>;  //    1 x i8 vector value
+def v2i8    : ValueType<16,   36>;  //    2 x i8 vector value
+def v4i8    : ValueType<32,   37>;  //    4 x i8 vector value
+def v8i8    : ValueType<64,   38>;  //    8 x i8 vector value
+def v16i8   : ValueType<128,  39>;  //   16 x i8 vector value
+def v32i8   : ValueType<256,  40>;  //   32 x i8 vector value
+def v64i8   : ValueType<512,  41>;  //   64 x i8 vector value
+def v128i8  : ValueType<1024, 42>;  //  128 x i8 vector value
+def v256i8  : ValueType<2048, 43>;  //  256 x i8 vector value
+def v512i8  : ValueType<4096, 44>;  //  512 x i8 vector value
+def v1024i8 : ValueType<8192, 45>;  // 1024 x i8 vector value
+
+def v1i16   : ValueType<16,   46>;  //   1 x i16 vector value
+def v2i16   : ValueType<32,   47>;  //   2 x i16 vector value
+def v3i16   : ValueType<48,   48>;  //   3 x i16 vector value
+def v4i16   : ValueType<64,   49>;  //   4 x i16 vector value
+def v8i16   : ValueType<128,  50>;  //   8 x i16 vector value
+def v16i16  : ValueType<256,  51>;  //  16 x i16 vector value
+def v32i16  : ValueType<512,  52>;  //  32 x i16 vector value
+def v64i16  : ValueType<1024, 53>;  //  64 x i16 vector value
+def v128i16 : ValueType<2048, 54>;  // 128 x i16 vector value
+def v256i16 : ValueType<4096, 55>;  // 256 x i16 vector value
+def v512i16 : ValueType<8192, 56>;  // 512 x i16 vector value
+
+def v1i32    : ValueType<32,    57>;  //    1 x i32 vector value
+def v2i32    : ValueType<64,    58>;  //    2 x i32 vector value
+def v3i32    : ValueType<96,    59>;  //    3 x i32 vector value
+def v4i32    : ValueType<128,   60>;  //    4 x i32 vector value
+def v5i32    : ValueType<160,   61>;  //    5 x i32 vector value
+def v6i32    : ValueType<192,   62>;  //    6 x f32 vector value
+def v7i32    : ValueType<224,   63>;  //    7 x f32 vector value
+def v8i32    : ValueType<256,   64>;  //    8 x i32 vector value
+def v9i32    : ValueType<288,   65>;  //    9 x i32 vector value
+def v10i32   : ValueType<320,   66>;  //   10 x i32 vector value
+def v11i32   : ValueType<352,   67>;  //   11 x i32 vector value
+def v12i32   : ValueType<384,   68>;  //   12 x i32 vector value
+def v16i32   : ValueType<512,   69>;  //   16 x i32 vector value
+def v32i32   : ValueType<1024,  70>;  //   32 x i32 vector value
+def v64i32   : ValueType<2048,  71>;  //   64 x i32 vector value
+def v128i32  : ValueType<4096,  72>;  //  128 x i32 vector value
+def v256i32  : ValueType<8192,  73>;  //  256 x i32 vector value
+def v512i32  : ValueType<16384, 74>;  //  512 x i32 vector value
+def v1024i32 : ValueType<32768, 75>;  // 1024 x i32 vector value
+def v2048i32 : ValueType<65536, 76>;  // 2048 x i32 vector value
+
+def v1i64   : ValueType<64,    77>;  //   1 x i64 vector value
+def v2i64   : ValueType<128,   78>;  //   2 x i64 vector value
+def v3i64   : ValueType<192,   79>;  //   3 x i64 vector value
+def v4i64   : ValueType<256,   80>;  //   4 x i64 vector value
+def v8i64   : ValueType<512,   81>;  //   8 x i64 vector value
+def v16i64  : ValueType<1024,  82>;  //  16 x i64 vector value
+def v32i64  : ValueType<2048,  83>;  //  32 x i64 vector value
+def v64i64  : ValueType<4096,  84>;  //  64 x i64 vector value
+def v128i64 : ValueType<8192,  85>;  // 128 x i64 vector value
+def v256i64 : ValueType<16384, 86>;  // 256 x i64 vector value
+
+def v1i128 : ValueType<128, 87>;  //  1 x i128 vector value
+
+def v1f8e4m3    : ValueType<8,    88>;  //    1 x fp8 vector value
+def v2f8e4m3    : ValueType<16,   89>;  //    2 x fp8 vector value
+def v3f8e4m3    : ValueType<24,   90>;  //    3 x fp8 vector value
+def v4f8e4m3    : ValueType<32,   91>;  //    4 x fp8 vector value
+def v8f8e4m3    : ValueType<64,   92>;  //    8 x fp8 vector value
+def v16f8e4m3   : ValueType<128,  93>;  //   16 x fp8 vector value
+def v32f8e4m3   : ValueType<256,  94>;  //   32 x fp8 vector value
+def v64f8e4m3   : ValueType<512,  95>;  //   64 x fp8 vector value
+def v128f8e4m3  : ValueType<1024, 96>;  //  128 x fp8 vector value
+
+def v1f8e5m2    : ValueType<8,    97>;  //    1 x fp8 vector value
+def v2f8e5m2    : ValueType<16,   98>;  //    2 x fp8 vector value
+def v3f8e5m2    : ValueType<24,   99>;  //    3 x fp8 vector value
+def v4f8e5m2    : ValueType<32,   100>;  //    4 x fp8 vector value
+def v8f8e5m2    : ValueType<64,   101>;  //    8 x fp8 vector value
+def v16f8e5m2   : ValueType<128,  102>;  //   16 x fp8 vector value
+def v32f8e5m2   : ValueType<256,  103>;  //   32 x fp8 vector value
+def v64f8e5m2   : ValueType<512,  104>;  //   64 x fp8 vector value
+def v128f8e5m2  : ValueType<1024, 105>;  //  128 x fp8 vector value
+
+def v1f16    : ValueType<16,     106>;  //    1 x f16 vector value
+def v2f16    : ValueType<32,     107>;  //    2 x f16 vector value
+def v3f16    : ValueType<48,     108>;  //    3 x f16 vector value
+def v4f16    : ValueType<64,     109>;  //    4 x f16 vector value
+def v8f16    : ValueType<128,    110>;  //    8 x f16 vector value
+def v16f16   : ValueType<256,    111>;  //   16 x f16 vector value
+def v32f16   : ValueType<512,    112>;  //   32 x f16 vector value
+def v64f16   : ValueType<1024,   113>;  //   64 x f16 vector value
+def v128f16  : ValueType<2048,   114>;  //  128 x f16 vector value
+def v256f16  : ValueType<4096,   115>;  //  256 x f16 vector value
+def v512f16  : ValueType<8192,   116>;  //  512 x f16 vector value
+
+def v2bf16   : ValueType<32,    117>;  //    2 x bf16 vector value
+def v3bf16   : ValueType<48,    118>;  //    3 x bf16 vector value
+def v4bf16   : ValueType<64,    119>;  //    4 x bf16 vector value
+def v8bf16   : ValueType<128,   120>;  //    8 x bf16 vector value
+def v16bf16  : ValueType<256,   121>;  //   16 x bf16 vector value
+def v32bf16  : ValueType<512,   122>;  //   32 x bf16 vector value
+def v64bf16  : ValueType<1024,  123>;  //   64 x bf16 vector value
+def v128bf16 : ValueType<2048,  124>;  //  128 x bf16 vector value
+
+def v1f32    : ValueType<32,    125>;  //    1 x f32 vector value
+def v2f32    : ValueType<64,    126>;  //    2 x f32 vector value
+def v3f32    : ValueType<96,    127>;  //    3 x f32 vector value
+def v4f32    : ValueType<128,   128>;  //    4 x f32 vector value
+def v5f32    : ValueType<160,   129>;  //    5 x f32 vector value
+def v6f32    : ValueType<192,   130>;  //    6 x f32 vector value
+def v7f32    : ValueType<224,   131>;  //    7 x f32 vector value
+def v8f32    : ValueType<256,   132>;  //    8 x f32 vector value
+def v9f32    : ValueType<288,   133>;  //    9 x f32 vector value
+def v10f32   : ValueType<320,   134>;  //   10 x f32 vector value
+def v11f32   : ValueType<352,   135>;  //   11 x f32 vector value
+def v12f32   : ValueType<384,   136>;  //   12 x f32 vector value
+def v16f32   : ValueType<512,   137>;  //   16 x f32 vector value
+def v32f32   : ValueType<1024,  138>;  //   32 x f32 vector value
+def v64f32   : ValueType<2048,  139>;  //   64 x f32 vector value
+def v128f32  : ValueType<4096,  140>;  //  128 x f32 vector value
+def v256f32  : ValueType<8192,  141>;  //  256 x f32 vector value
+def v512f32  : ValueType<16384, 142>;  //  512 x f32 vector value
+def v1024f32 : ValueType<32768, 143>;  // 1024 x f32 vector value
+def v2048f32 : ValueType<65536, 144>;  // 2048 x f32 vector value
+
+def v1f64    : ValueType<64,    145>;  //    1 x f64 vector value
+def v2f64    : ValueType<128,   146>;  //    2 x f64 vector value
+def v3f64    : ValueType<192,   147>;  //    3 x f64 vector value
+def v4f64    : ValueType<256,   148>;  //    4 x f64 vector value
+def v8f64    : ValueType<512,   149>;  //    8 x f64 vector value
+def v16f64   : ValueType<1024,  150>;  //   16 x f64 vector value
+def v32f64   : ValueType<2048,  151>;  //   32 x f64 vector value
+def v64f64   : ValueType<4096,  152>;  //   64 x f64 vector value
+def v128f64  : ValueType<8192,  153>;  //  128 x f64 vector value
+def v256f64  : ValueType<16384, 154>;  //  256 x f64 vector value
+
+def nxv1i1  : ValueType<1,  155>;  // n x  1 x i1  vector value
+def nxv2i1  : ValueType<2,  156>;  // n x  2 x i1  vector value
+def nxv4i1  : ValueType<4,  157>;  // n x  4 x i1  vector value
+def nxv8i1  : ValueType<8,  158>;  // n x  8 x i1  vector value
+def nxv16i1 : ValueType<16, 159>;  // n x 16 x i1  vector value
+def nxv32i1 : ValueType<32, 160>;  // n x 32 x i1  vector value
+def nxv64i1 : ValueType<64, 161>;  // n x 64 x i1  vector value
+
+def nxv1i8  : ValueType<8,   162>;  // n x  1 x i8  vector value
+def nxv2i8  : ValueType<16,  163>;  // n x  2 x i8  vector value
+def nxv4i8  : ValueType<32,  164>;  // n x  4 x i8  vector value
+def nxv8i8  : ValueType<64,  165>;  // n x  8 x i8  vector value
+def nxv16i8 : ValueType<128, 166>;  // n x 16 x i8  vector value
+def nxv32i8 : ValueType<256, 167>;  // n x 32 x i8  vector value
+def nxv64i8 : ValueType<512, 168>;  // n x 64 x i8  vector value
+
+def nxv1i16  : ValueType<16,  169>;  // n x  1 x i16 vector value
+def nxv2i16  : ValueType<32,  170>;  // n x  2 x i16 vector value
+def nxv4i16  : ValueType<64,  171>;  // n x  4 x i16 vector value
+def nxv8i16  : ValueType<128, 172>;  // n x  8 x i16 vector value
+def nxv16i16 : ValueType<256, 173>;  // n x 16 x i16 vector value
+def nxv32i16 : ValueType<512, 174>;  // n x 32 x i16 vector value
+
+def nxv1i32  : ValueType<32,   175>;  // n x  1 x i32 vector value
+def nxv2i32  : ValueType<64,   176>;  // n x  2 x i32 vector value
+def nxv4i32  : ValueType<128,  177>;  // n x  4 x i32 vector value
+def nxv8i32  : ValueType<256,  178>;  // n x  8 x i32 vector value
+def nxv16i32 : ValueType<512,  179>;  // n x 16 x i32 vector value
+def nxv32i32 : ValueType<1024, 180>;  // n x 32 x i32 vector value
+
+def nxv1i64  : ValueType<64,   181>;  // n x  1 x i64 vector value
+def nxv2i64  : ValueType<128,  182>;  // n x  2 x i64 vector value
+def nxv4i64  : ValueType<256,  183>;  // n x  4 x i64 vector value
+def nxv8i64  : ValueType<512,  184>;  // n x  8 x i64 vector value
+def nxv16i64 : ValueType<1024, 185>;  // n x 16 x i64 vector value
+def nxv32i64 : ValueType<2048, 186>;  // n x 32 x i64 vector value
+
+def nxv1f8e4m3 : ValueType<8,   187>;  // n x  1 x  f8e4m3  vector value
+def nxv2f8e4m3 : ValueType<16,  188>;  // n x  2 x  f8e4m3  vector value
+def nxv4f8e4m3 : ValueType<32,  189>;  // n x  4 x  f8e4m3  vector value
+def nxv8f8e4m3 : ValueType<64,  190>;  // n x  8 x  f8e4m3  vector value
+
+def nxv1f8e5m2 : ValueType<8,   191>;  // n x  1 x  f8e5m2  vector value
+def nxv2f8e5m2 : ValueType<16,  192>;  // n x  2 x  f8e5m2  vector value
+def nxv4f8e5m2 : ValueType<32,  193>;  // n x  4 x  f8e5m2  vector value
+def nxv8f8e5m2 : ValueType<64,  194>;  // n x  8 x  f8e5m2  vector value
+
+def nxv1f16  : ValueType<16,  195>;  // n x  1 x  f16 vector value
+def nxv2f16  : ValueType<32,  196>;  // n x  2 x  f16 vector value
+def nxv4f16  : ValueType<64,  197>;  // n x  4 x  f16 vector value
+def nxv8f16  : ValueType<128, 198>;  // n x  8 x  f16 vector value
+def nxv16f16 : ValueType<256, 199>;  // n x 16 x  f16 vector value
+def nxv32f16 : ValueType<512, 200>;  // n x 32 x  f16 vector value
+
+def nxv1bf16 : ValueType<16,   201>;  // n x  1 x bf16 vector value
+def nxv2bf16 : ValueType<32,   202>;  // n x  2 x bf16 vector value
+def nxv4bf16 : ValueType<64,   203>;  // n x  4 x bf16 vector value
+def nxv8bf16 : ValueType<128,  204>;  // n x  8 x bf16 vector value
+def nxv16bf16 : ValueType<256, 205>;  // n x 16 x bf16 vector value
+def nxv32bf16 : ValueType<512, 206>;  // n x 32 x bf16 vector value
+
+def nxv1f32  : ValueType<32,  207>;  // n x  1 x  f32 vector value
+def nxv2f32  : ValueType<64,  208>;  // n x  2 x  f32 vector value
+def nxv4f32  : ValueType<128, 209>;  // n x  4 x  f32 vector value
+def nxv8f32  : ValueType<256, 210>;  // n x  8 x  f32 vector value
+def nxv16f32 : ValueType<512, 211>;  // n x 16 x  f32 vector value
+
+def nxv1f64  : ValueType<64,  212>;  // n x  1 x  f64 vector value
+def nxv2f64  : ValueType<128, 213>;  // n x  2 x  f64 vector value
+def nxv4f64  : ValueType<256, 214>;  // n x  4 x  f64 vector value
+def nxv8f64  : ValueType<512, 215>;  // n x  8 x  f64 vector value
+
+def x86mmx    : ValueType<64,   216>;  // X86 MMX value
+def FlagVT    : ValueType<0,    217>;  // Pre-RA sched glue
+def isVoid    : ValueType<0,    218>;  // Produces no value
+def untyped   : ValueType<8,    219>;  // Produces an untyped value
+def funcref   : ValueType<0,    220>;  // WebAssembly's funcref type
+def externref : ValueType<0,    221>;  // WebAssembly's externref type
+def x86amx    : ValueType<8192, 222>;  // X86 AMX value
+def i64x8     : ValueType<512,  223>;  // 8 Consecutive GPRs (AArch64)
 
 def token      : ValueType<0, 248>;  // TokenTy
 def MetadataVT : ValueType<0, 249>;  // Metadata
 
 // Pseudo valuetype mapped to the current pointer size to any address space.
 // Should only be used in TableGen.
 def iPTRAny    : ValueType<0, 250>;
 

llvm/include/llvm/IR/DataLayout.h

return ATy->getNumElements() *
            getTypeAllocSizeInBits(ATy->getElementType());
   }
   case Type::StructTyID:
     // Get the layout annotation... which is lazily created on demand.
     return TypeSize::Fixed(
                         getStructLayout(cast<StructType>(Ty))->getSizeInBits());
   case Type::IntegerTyID:
     return TypeSize::Fixed(Ty->getIntegerBitWidth());
+  case Type::F8E5M2TyID:
+  case Type::F8E4M3TyID:
+    return TypeSize::Fixed(8);
   case Type::HalfTyID:
   case Type::BFloatTyID:
     return TypeSize::Fixed(16);
   case Type::FloatTyID:
     return TypeSize::Fixed(32);
   case Type::DoubleTyID:
   case Type::X86_MMXTyID:
     return TypeSize::Fixed(64);

llvm/include/llvm/IR/IRBuilder.h

#endif
   /// Fetch the type representing a 128-bit integer.
   IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
 
   /// Fetch the type representing an N-bit integer.
   IntegerType *getIntNTy(unsigned N) {
     return Type::getIntNTy(Context, N);
   }
 
+  /// Fetch the type representing a 8-bit floating point value.
+  Type *getF8E5M2Ty() { return Type::getF8E5M2Ty(Context); }
+
+  /// Fetch the type representing a 8-bit floating point value.
+  Type *getF8E4M3Ty() { return Type::getF8E4M3Ty(Context); }
+
   /// Fetch the type representing a 16-bit floating point value.
   Type *getHalfTy() {
     return Type::getHalfTy(Context);
   }
 
   /// Fetch the type representing a 16-bit brain floating point value.
   Type *getBFloatTy() {
     return Type::getBFloatTy(Context);

llvm/include/llvm/IR/Type.h

public:
   /// Note: If you add an element to this, you need to add an element to the
   /// Type::getPrimitiveType function, or else things will break!
   /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
   ///
   enum TypeID {
     // PrimitiveTypes
     HalfTyID = 0,  ///< 16-bit floating point type
     BFloatTyID,    ///< 16-bit floating point type (7-bit significand)
+    F8E5M2TyID,   ///< 8-bit floating type (5 Bit exponent)
+    F8E4M3TyID,   ///< 8-bit floating type (4 Bit exponent)
     FloatTyID,     ///< 32-bit floating point type
     DoubleTyID,    ///< 64-bit floating point type
     X86_FP80TyID,  ///< 80-bit floating point type (X87)
     FP128TyID,     ///< 128-bit floating point type (112-bit significand)
     PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
     VoidTyID,      ///< type with no size
     LabelTyID,     ///< Labels
     MetadataTyID,  ///< Metadata
public:
   TypeID getTypeID() const { return ID; }
 
   /// Return true if this is 'void'.
   bool isVoidTy() const { return getTypeID() == VoidTyID; }
 
   /// Return true if this is 'half', a 16-bit IEEE fp type.
   bool isHalfTy() const { return getTypeID() == HalfTyID; }
 
+  /// Return true if this is 'F8E5M2'.
+  bool isF8E5M2() const { return getTypeID() == F8E5M2TyID; }
+
+  /// Return true if this is 'F8E4M3'.
+  bool isF8E4M3() const { return getTypeID() == F8E4M3TyID; }
+
   /// Return true if this is 'bfloat', a 16-bit bfloat type.
   bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
 
   /// Return true if this is a 16-bit float type.
   bool is16bitFPTy() const {
     return getTypeID() == BFloatTyID || getTypeID() == HalfTyID;
   }
 
+  /// Return true if this is an 8-bit float type.
+  bool is8BitFPTy() const {
+    return getTypeID() == F8E5M2TyID || getTypeID() == F8E4M3TyID;
+  }
+
   /// Return true if this is 'float', a 32-bit IEEE fp type.
   bool isFloatTy() const { return getTypeID() == FloatTyID; }
 
   /// Return true if this is 'double', a 64-bit IEEE fp type.
   bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
 
   /// Return true if this is x86 long double.
   bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
public:
   /// values
   bool isIEEELikeFPTy() const {
     switch (getTypeID()) {
     case DoubleTyID:
     case FloatTyID:
     case HalfTyID:
     case BFloatTyID:
     case FP128TyID:
+    case F8E5M2TyID:
+    case F8E4M3TyID:
       return true;
     default:
       return false;
     }
   }
 
   /// Return true if this is one of the floating-point types
   bool isFloatingPointTy() const {
     return isIEEELikeFPTy() || getTypeID() == X86_FP80TyID ||
public:
   static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
 
   //===--------------------------------------------------------------------===//
   // These are the builtin types that are always available.
   //
   static Type *getVoidTy(LLVMContext &C);
   static Type *getLabelTy(LLVMContext &C);
   static Type *getHalfTy(LLVMContext &C);
+  static Type *getF8E5M2Ty(LLVMContext &C);
+  static Type *getF8E4M3Ty(LLVMContext &C);
   static Type *getBFloatTy(LLVMContext &C);
   static Type *getFloatTy(LLVMContext &C);
   static Type *getDoubleTy(LLVMContext &C);
   static Type *getMetadataTy(LLVMContext &C);
   static Type *getX86_FP80Ty(LLVMContext &C);
   static Type *getFP128Ty(LLVMContext &C);
   static Type *getPPC_FP128Ty(LLVMContext &C);
   static Type *getX86_MMXTy(LLVMContext &C);
template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
     llvm_unreachable("Unsupported type in Type::getScalarTy");
   }
   static Type *getFloatingPointTy(LLVMContext &C, const fltSemantics &S);
 
   //===--------------------------------------------------------------------===//
   // Convenience methods for getting pointer types with one of the above builtin
   // types as pointee.
   //
+  static PointerType *getF8E5M2PtrTy(LLVMContext &C, unsigned AS = 0);
+  static PointerType *getF8E4M3PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);

llvm/include/llvm/Support/MachineValueType.h

enum SimpleValueType : uint8_t {
       i16            =   6,   // This is a 16 bit integer value
       i32            =   7,   // This is a 32 bit integer value
       i64            =   8,   // This is a 64 bit integer value
       i128           =   9,   // This is a 128 bit integer value
 
       FIRST_INTEGER_VALUETYPE = i1,
       LAST_INTEGER_VALUETYPE  = i128,
 
-      bf16           =  10,   // This is a 16 bit brain floating point value
-      f16            =  11,   // This is a 16 bit floating point value
-      f32            =  12,   // This is a 32 bit floating point value
-      f64            =  13,   // This is a 64 bit floating point value
-      f80            =  14,   // This is a 80 bit floating point value
-      f128           =  15,   // This is a 128 bit floating point value
-      ppcf128        =  16,   // This is a PPC 128-bit floating point value
+      f8e4m3         =  10,   // This is an 8 bit floating point value (e4m3) 
+      f8e5m2         =  11,   // This is an 8 bit floating point value (e5m2) 
+      bf16           =  12,   // This is a 16 bit brain floating point value
+      f16            =  13,   // This is a 16 bit floating point value
+      f32            =  14,   // This is a 32 bit floating point value
+      f64            =  15,   // This is a 64 bit floating point value
+      f80            =  16,   // This is a 80 bit floating point value
+      f128           =  17,   // This is a 128 bit floating point value
+      ppcf128        =  18,   // This is a PPC 128-bit floating point value
 
-      FIRST_FP_VALUETYPE = bf16,
+      FIRST_FP_VALUETYPE = f8e4m3,
       LAST_FP_VALUETYPE  = ppcf128,
 
-      v1i1           =  17,   //    1 x i1
-      v2i1           =  18,   //    2 x i1
-      v4i1           =  19,   //    4 x i1
-      v8i1           =  20,   //    8 x i1
-      v16i1          =  21,   //   16 x i1
-      v32i1          =  22,   //   32 x i1
-      v64i1          =  23,   //   64 x i1
-      v128i1         =  24,   //  128 x i1
-      v256i1         =  25,   //  256 x i1
-      v512i1         =  26,   //  512 x i1
-      v1024i1        =  27,   // 1024 x i1
-      v2048i1        =  28,   // 2048 x i1
-
-      v128i2         =  29,   //  128 x i2
-      v256i2         =  30,   //  256 x i2
-
-      v64i4          =  31,   //   64 x i4
-      v128i4         =  32,   //  128 x i4
-
-      v1i8           =  33,   //    1 x i8
-      v2i8           =  34,   //    2 x i8
-      v4i8           =  35,   //    4 x i8
-      v8i8           =  36,   //    8 x i8
-      v16i8          =  37,   //   16 x i8
-      v32i8          =  38,   //   32 x i8
-      v64i8          =  39,   //   64 x i8
-      v128i8         =  40,   //  128 x i8
-      v256i8         =  41,   //  256 x i8
-      v512i8         =  42,   //  512 x i8
-      v1024i8        =  43,   // 1024 x i8
-
-      v1i16          =  44,   //   1 x i16
-      v2i16          =  45,   //   2 x i16
-      v3i16          =  46,   //   3 x i16
-      v4i16          =  47,   //   4 x i16
-      v8i16          =  48,   //   8 x i16
-      v16i16         =  49,   //  16 x i16
-      v32i16         =  50,   //  32 x i16
-      v64i16         =  51,   //  64 x i16
-      v128i16        =  52,   // 128 x i16
-      v256i16        =  53,   // 256 x i16
-      v512i16        =  54,   // 512 x i16
-
-      v1i32          =  55,   //    1 x i32
-      v2i32          =  56,   //    2 x i32
-      v3i32          =  57,   //    3 x i32
-      v4i32          =  58,   //    4 x i32
-      v5i32          =  59,   //    5 x i32
-      v6i32          =  60,   //    6 x i32
-      v7i32          =  61,   //    7 x i32
-      v8i32          =  62,   //    8 x i32
-      v9i32          =  63,   //    9 x i32
-      v10i32         =  64,   //   10 x i32
-      v11i32         =  65,   //   11 x i32
-      v12i32         =  66,   //   12 x i32
-      v16i32         =  67,   //   16 x i32
-      v32i32         =  68,   //   32 x i32
-      v64i32         =  69,   //   64 x i32
-      v128i32        =  70,   //  128 x i32
-      v256i32        =  71,   //  256 x i32
-      v512i32        =  72,   //  512 x i32
-      v1024i32       =  73,   // 1024 x i32
-      v2048i32       =  74,   // 2048 x i32
-
-      v1i64          =  75,   //   1 x i64
-      v2i64          =  76,   //   2 x i64
-      v3i64          =  77,   //   3 x i64
-      v4i64          =  78,   //   4 x i64
-      v8i64          =  79,   //   8 x i64
-      v16i64         =  80,   //  16 x i64
-      v32i64         =  81,   //  32 x i64
-      v64i64         =  82,   //  64 x i64
-      v128i64        =  83,   // 128 x i64
-      v256i64        =  84,   // 256 x i64
+      v1i1           =  19,   //    1 x i1
+      v2i1           =  20,   //    2 x i1
+      v4i1           =  21,   //    4 x i1
+      v8i1           =  22,   //    8 x i1
+      v16i1          =  23,   //   16 x i1
+      v32i1          =  24,   //   32 x i1
+      v64i1          =  25,   //   64 x i1
+      v128i1         =  26,   //  128 x i1
+      v256i1         =  27,   //  256 x i1
+      v512i1         =  28,   //  512 x i1
+      v1024i1        =  29,   // 1024 x i1
+      v2048i1        =  30,   // 2048 x i1
+
+      v128i2         =  31,   //  128 x i2
+      v256i2         =  32,   //  256 x i2
+
+      v64i4          =  33,   //   64 x i4
+      v128i4         =  34,   //  128 x i45
+      v1i8           =  35,   //    1 x i8
+      v2i8           =  36,   //    2 x i8
+      v4i8           =  37,   //    4 x i8
+      v8i8           =  38,   //    8 x i8
+      v16i8          =  39,   //   16 x i8
+      v32i8          =  40,   //   32 x i8
+      v64i8          =  41,   //   64 x i8
+      v128i8         =  42,   //  128 x i8
+      v256i8         =  43,   //  256 x i8
+      v512i8         =  44,   //  512 x i8
+      v1024i8        =  45,   // 1024 x i8
+
+      v1i16          =  46,   //   1 x i16
+      v2i16          =  47,   //   2 x i16
+      v3i16          =  48,   //   3 x i16
+      v4i16          =  49,   //   4 x i16
+      v8i16          =  50,   //   8 x i16
+      v16i16         =  51,   //  16 x i16
+      v32i16         =  52,   //  32 x i16
+      v64i16         =  53,   //  64 x i16
+      v128i16        =  54,   // 128 x i16
+      v256i16        =  55,   // 256 x i16
+      v512i16        =  56,   // 512 x i16
+
+      v1i32          =  57,   //    1 x i32
+      v2i32          =  58,   //    2 x i32
+      v3i32          =  59,   //    3 x i32
+      v4i32          =  60,   //    4 x i32
+      v5i32          =  61,   //    5 x i32
+      v6i32          =  62,   //    6 x i32
+      v7i32          =  63,   //    7 x i32
+      v8i32          =  64,   //    8 x i32
+      v9i32          =  65,   //    9 x i32
+      v10i32         =  66,   //   10 x i32
+      v11i32         =  67,   //   11 x i32
+      v12i32         =  68,   //   12 x i32
+      v16i32         =  69,   //   16 x i32
+      v32i32         =  70,   //   32 x i32
+      v64i32         =  71,   //   64 x i32
+      v128i32        =  72,   //  128 x i32
+      v256i32        =  73,   //  256 x i32
+      v512i32        =  74,   //  512 x i32
+      v1024i32       =  75,   // 1024 x i32
+      v2048i32       =  76,   // 2048 x i32
+
+      v1i64          =  77,   //   1 x i64
+      v2i64          =  78,   //   2 x i64
+      v3i64          =  79,   //   3 x i64
+      v4i64          =  80,   //   4 x i64
+      v8i64          =  81,   //   8 x i64
+      v16i64         =  82,   //  16 x i64
+      v32i64         =  83,   //  32 x i64
+      v64i64         =  84,   //  64 x i64
+      v128i64        =  85,   // 128 x i64
+      v256i64        =  86,   // 256 x i64
 
-      v1i128         =  85,   //  1 x i128
+      v1i128         =  87,   //  1 x i128
 
       FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
       LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
 
-      v1f16          =  86,   //    1 x f16
-      v2f16          =  87,   //    2 x f16
-      v3f16          =  88,   //    3 x f16
-      v4f16          =  89,   //    4 x f16
-      v8f16          =  90,   //    8 x f16
-      v16f16         =  91,   //   16 x f16
-      v32f16         =  92,   //   32 x f16
-      v64f16         =  93,   //   64 x f16
-      v128f16        =  94,   //  128 x f16
-      v256f16        =  95,   //  256 x f16
-      v512f16        =  96,   //  512 x f16
-
-      v2bf16         =  97,   //    2 x bf16
-      v3bf16         =  98,   //    3 x bf16
-      v4bf16         =  99,   //    4 x bf16
-      v8bf16         = 100,   //    8 x bf16
-      v16bf16        = 101,   //   16 x bf16
-      v32bf16        = 102,   //   32 x bf16
-      v64bf16        = 103,   //   64 x bf16
-      v128bf16       = 104,   //  128 x bf16
-
-      v1f32          = 105,   //    1 x f32
-      v2f32          = 106,   //    2 x f32
-      v3f32          = 107,   //    3 x f32
-      v4f32          = 108,   //    4 x f32
-      v5f32          = 109,   //    5 x f32
-      v6f32          = 110,   //    6 x f32
-      v7f32          = 111,   //    7 x f32
-      v8f32          = 112,   //    8 x f32
-      v9f32          = 113,   //    9 x f32
-      v10f32         = 114,   //   10 x f32
-      v11f32         = 115,   //   11 x f32
-      v12f32         = 116,   //   12 x f32
-      v16f32         = 117,   //   16 x f32
-
-      v32f32         = 118,   //   32 x f32
-      v64f32         = 119,   //   64 x f32
-      v128f32        = 120,   //  128 x f32
-      v256f32        = 121,   //  256 x f32
-      v512f32        = 122,   //  512 x f32
-      v1024f32       = 123,   // 1024 x f32
-      v2048f32       = 124,   // 2048 x f32
-
-      v1f64          = 125,   //    1 x f64
-      v2f64          = 126,   //    2 x f64
-      v3f64          = 127,   //    3 x f64
-      v4f64          = 128,   //    4 x f64
-      v8f64          = 129,   //    8 x f64
-      v16f64         = 130,   //   16 x f64
-      v32f64         = 131,   //   32 x f64
-      v64f64         = 132,   //   64 x f64
-      v128f64        = 133,   //  128 x f64
-      v256f64        = 134,   //  256 x f64
+      v1f8e4m3      =  88,   //    1 x f8e4m3
+      v2f8e4m3      =  89,   //    2 x f8e4m3
+      v3f8e4m3      =  90,   //    3 x f8e4m3
+      v4f8e4m3      =  91,   //    4 x f8e4m3
+      v8f8e4m3      =  92,   //    8 x f8e4m3
+      v16f8e4m3     =  93,   //   16 x f8e4m3
+      v32f8e4m3     =  94,   //   32 x f8e4m3
+      v64f8e4m3     =  95,   //   64 x f8e4m3
+      v128f8e4m3    =  96,   //  128 x f8e4m3
+
+      v1f8e5m2      =  97,   //    1 x f8e5m2
+      v2f8e5m2      =  98,  //    2 x f8e5m2
+      v3f8e5m2      =  99,  //    3 x f8e5m2
+      v4f8e5m2      =  100,  //    4 x f8e5m2
+      v8f8e5m2      =  101,  //    8 x f8e5m2
+      v16f8e5m2     =  102,  //   16 x f8e5m2
+      v32f8e5m2     =  103,  //   32 x f8e5m2
+      v64f8e5m2     =  104,  //   64 x f8e5m2
+      v128f8e5m2    =  105,  //  128 x f8e5m2
+
+      v1f16          =  106, //    1 x f16
+      v2f16          =  107,   //    2 x f16
+      v3f16          =  108,   //    3 x f16
+      v4f16          =  109,   //    4 x f16
+      v8f16          =  110,   //    8 x f16
+      v16f16         =  111,   //   16 x f16
+      v32f16         =  112,   //   32 x f16
+      v64f16         =  113,   //   64 x f16
+      v128f16        =  114,   //  128 x f16
+      v256f16        =  115,   //  256 x f16
+      v512f16        =  116,   //  512 x f16
+
+      v2bf16         = 117,   //    2 x bf16
+      v3bf16         = 118,   //    3 x bf16
+      v4bf16         = 119,   //    4 x bf16
+      v8bf16         = 120,   //    8 x bf16
+      v16bf16        = 121,   //   16 x bf16
+      v32bf16        = 122,   //   32 x bf16
+      v64bf16        = 123,   //   64 x bf16
+      v128bf16       = 124,   //  128 x bf16
+
+      v1f32          = 125,   //    1 x f32
+      v2f32          = 126,   //    2 x f32
+      v3f32          = 127,   //    3 x f32
+      v4f32          = 128,   //    4 x f32
+      v5f32          = 129,   //    5 x f32
+      v6f32          = 130,   //    6 x f32
+      v7f32          = 131,   //    7 x f32
+      v8f32          = 132,   //    8 x f32
+      v9f32          = 133,   //    9 x f32
+      v10f32         = 134,   //   10 x f32
+      v11f32         = 135,   //   11 x f32
+      v12f32         = 136,   //   12 x f32
+      v16f32         = 137,   //   16 x f32
+
+      v32f32         = 138,   //   32 x f32
+      v64f32         = 139,   //   64 x f32
+      v128f32        = 140,   //  128 x f32
+      v256f32        = 141,   //  256 x f32
+      v512f32        = 142,   //  512 x f32
+      v1024f32       = 143,   // 1024 x f32
+      v2048f32       = 144,   // 2048 x f32
+
+      v1f64          = 145,   //    1 x f64
+      v2f64          = 146,   //    2 x f64
+      v3f64          = 147,   //    3 x f64
+      v4f64          = 148,   //    4 x f64
+      v8f64          = 149,   //    8 x f64
+      v16f64         = 150,   //   16 x f64
+      v32f64         = 151,   //   32 x f64
+      v64f64         = 152,   //   64 x f64
+      v128f64        = 153,   //  128 x f64
+      v256f64        = 154,   //  256 x f64
 
-      FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v1f16,
+      FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v1f8e4m3,
       LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
 
       FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
       LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
 
-      nxv1i1         = 135,   // n x  1 x i1
-      nxv2i1         = 136,   // n x  2 x i1
-      nxv4i1         = 137,   // n x  4 x i1
-      nxv8i1         = 138,   // n x  8 x i1
-      nxv16i1        = 139,   // n x 16 x i1
-      nxv32i1        = 140,   // n x 32 x i1
-      nxv64i1        = 141,   // n x 64 x i1
-
-      nxv1i8         = 142,   // n x  1 x i8
-      nxv2i8         = 143,   // n x  2 x i8
-      nxv4i8         = 144,   // n x  4 x i8
-      nxv8i8         = 145,   // n x  8 x i8
-      nxv16i8        = 146,   // n x 16 x i8
-      nxv32i8        = 147,   // n x 32 x i8
-      nxv64i8        = 148,   // n x 64 x i8
-
-      nxv1i16        = 149,  // n x  1 x i16
-      nxv2i16        = 150,  // n x  2 x i16
-      nxv4i16        = 151,  // n x  4 x i16
-      nxv8i16        = 152,  // n x  8 x i16
-      nxv16i16       = 153,  // n x 16 x i16
-      nxv32i16       = 154,  // n x 32 x i16
-
-      nxv1i32        = 155,  // n x  1 x i32
-      nxv2i32        = 156,  // n x  2 x i32
-      nxv4i32        = 157,  // n x  4 x i32
-      nxv8i32        = 158,  // n x  8 x i32
-      nxv16i32       = 159,  // n x 16 x i32
-      nxv32i32       = 160,  // n x 32 x i32
-
-      nxv1i64        = 161,  // n x  1 x i64
-      nxv2i64        = 162,  // n x  2 x i64
-      nxv4i64        = 163,  // n x  4 x i64
-      nxv8i64        = 164,  // n x  8 x i64
-      nxv16i64       = 165,  // n x 16 x i64
-      nxv32i64       = 166,  // n x 32 x i64
+      nxv1i1         = 155,   // n x  1 x i1
+      nxv2i1         = 156,   // n x  2 x i1
+      nxv4i1         = 157,   // n x  4 x i1
+      nxv8i1         = 158,   // n x  8 x i1
+      nxv16i1        = 159,   // n x 16 x i1
+      nxv32i1        = 160,   // n x 32 x i1
+      nxv64i1        = 161,   // n x 64 x i1
+
+      nxv1i8         = 162,   // n x  1 x i8
+      nxv2i8         = 163,   // n x  2 x i8
+      nxv4i8         = 164,   // n x  4 x i8
+      nxv8i8         = 165,   // n x  8 x i8
+      nxv16i8        = 166,   // n x 16 x i8
+      nxv32i8        = 167,   // n x 32 x i8
+      nxv64i8        = 168,   // n x 64 x i8
+
+      nxv1i16        = 169,  // n x  1 x i16
+      nxv2i16        = 170,  // n x  2 x i16
+      nxv4i16        = 171,  // n x  4 x i16
+      nxv8i16        = 172,  // n x  8 x i16
+      nxv16i16       = 173,  // n x 16 x i16
+      nxv32i16       = 174,  // n x 32 x i16
+
+      nxv1i32        = 175,  // n x  1 x i32
+      nxv2i32        = 176,  // n x  2 x i32
+      nxv4i32        = 177,  // n x  4 x i32
+      nxv8i32        = 178,  // n x  8 x i32
+      nxv16i32       = 179,  // n x 16 x i32
+      nxv32i32       = 180,  // n x 32 x i32
+
+      nxv1i64        = 181,  // n x  1 x i64
+      nxv2i64        = 182,  // n x  2 x i64
+      nxv4i64        = 183,  // n x  4 x i64
+      nxv8i64        = 184,  // n x  8 x i64
+      nxv16i64       = 185,  // n x 16 x i64
+      nxv32i64       = 186,  // n x 32 x i64
 
       FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
       LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
 
-      nxv1f16        = 167,  // n x  1 x f16
-      nxv2f16        = 168,  // n x  2 x f16
-      nxv4f16        = 169,  // n x  4 x f16
-      nxv8f16        = 170,  // n x  8 x f16
-      nxv16f16       = 171,  // n x 16 x f16
-      nxv32f16       = 172,  // n x 32 x f16
-
-      nxv1bf16       = 173,  // n x  1 x bf16
-      nxv2bf16       = 174,  // n x  2 x bf16
-      nxv4bf16       = 175,  // n x  4 x bf16
-      nxv8bf16       = 176,  // n x  8 x bf16
-      nxv16bf16      = 177,  // n x 16 x bf16
-      nxv32bf16      = 178,  // n x 32 x bf16
-
-      nxv1f32        = 179,  // n x  1 x f32
-      nxv2f32        = 180,  // n x  2 x f32
-      nxv4f32        = 181,  // n x  4 x f32
-      nxv8f32        = 182,  // n x  8 x f32
-      nxv16f32       = 183,  // n x 16 x f32
-
-      nxv1f64        = 184,  // n x  1 x f64
-      nxv2f64        = 185,  // n x  2 x f64
-      nxv4f64        = 186,  // n x  4 x f64
-      nxv8f64        = 187,  // n x  8 x f64
+      nxv1f8e4m3     = 187,  // n x  1 x f8e4m3
+      nxv2f8e4m3     = 188,  // n x  2 x f8e4m3
+      nxv4f8e4m3     = 189,  // n x  4 x f8e4m3
+      nxv8f8e4m3     = 190,  // n x  8 x f8e4m3
+
+      nxv1f8e5m2     = 191,  // n x  1 x f8e5m2
+      nxv2f8e5m2     = 192,  // n x  2 x f8e5m2
+      nxv4f8e5m2     = 193,  // n x  4 x f8e5m2
+      nxv8f8e5m2     = 194,  // n x  8 x f8e5m2
+
+      nxv1f16        = 195,  // n x  1 x f16
+      nxv2f16        = 196,  // n x  2 x f16
+      nxv4f16        = 197,  // n x  4 x f16
+      nxv8f16        = 198,  // n x  8 x f16
+      nxv16f16       = 199,  // n x 16 x f16
+      nxv32f16       = 200,  // n x 32 x f16
+
+      nxv1bf16       = 201,  // n x  1 x bf16
+      nxv2bf16       = 202,  // n x  2 x bf16
+      nxv4bf16       = 203,  // n x  4 x bf16
+      nxv8bf16       = 204,  // n x  8 x bf16
+      nxv16bf16      = 205,  // n x 16 x bf16
+      nxv32bf16      = 206,  // n x 32 x bf16
+
+      nxv1f32        = 207,  // n x  1 x f32
+      nxv2f32        = 208,  // n x  2 x f32
+      nxv4f32        = 209,  // n x  4 x f32
+      nxv8f32        = 210,  // n x  8 x f32
+      nxv16f32       = 211,  // n x 16 x f32
+
+      nxv1f64        = 212,  // n x  1 x f64
+      nxv2f64        = 213,  // n x  2 x f64
+      nxv4f64        = 214,  // n x  4 x f64
+      nxv8f64        = 215,  // n x  8 x f64
 
-      FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
+      FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f8e4m3,
       LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
 
       FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
       LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
 
       FIRST_VECTOR_VALUETYPE = v1i1,
       LAST_VECTOR_VALUETYPE  = nxv8f64,
 
-      x86mmx         = 188,    // This is an X86 MMX value
+      x86mmx         = 216,    // This is an X86 MMX value
 
-      Glue           = 189,    // This glues nodes together during pre-RA sched
+      Glue           = 217,    // This glues nodes together during pre-RA sched
 
-      isVoid         = 190,    // This has no value
+      isVoid         = 218,    // This has no value
 
-      Untyped        = 191,    // This value takes a register, but has
+      Untyped        = 219,    // This value takes a register, but has
                                // unspecified type.  The register class
                                // will be determined by the opcode.
 
-      funcref        = 192,    // WebAssembly's funcref type
-      externref      = 193,    // WebAssembly's externref type
-      x86amx         = 194,    // This is an X86 AMX value
-      i64x8          = 195,    // 8 Consecutive GPRs (AArch64)
+      funcref        = 220,    // WebAssembly's funcref type
+      externref      = 221,    // WebAssembly's externref type
+      x86amx         = 222,    // This is an X86 AMX value
+      i64x8          = 223,    // 8 Consecutive GPRs (AArch64)
 
       FIRST_VALUETYPE =  1,    // This is always the beginning of the list.
       LAST_VALUETYPE = i64x8,  // This always remains at the end of the list.
       VALUETYPE_SIZE = LAST_VALUETYPE + 1,
 
       // 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.
       MAX_ALLOWED_VALUETYPE = 224,
 
       // A value of type llvm::TokenTy
       token          = 248,
 
       // This is MDNode or MDString.
       Metadata       = 249,
 
       // An int value the size of the pointer of the current
public:
 
     bool isFixedLengthVector() const {
       return (SimpleTy >= MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE &&
               SimpleTy <= MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
     }
 
     /// Return true if this is a 16-bit vector type.
     bool is16BitVector() const {
-      return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
-              SimpleTy == MVT::v16i1 || SimpleTy == MVT::v1f16);
+      return (SimpleTy == MVT::v2i8     || SimpleTy == MVT::v1i16    ||
+              SimpleTy == MVT::v2f8e4m3 || SimpleTy == MVT::v2f8e5m2 ||
+              SimpleTy == MVT::v16i1    || SimpleTy == MVT::v1f16);
     }
 
     /// Return true if this is a 32-bit vector type.
     bool is32BitVector() const {
-      return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8   ||
-              SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32  ||
-              SimpleTy == MVT::v2f16 || SimpleTy == MVT::v2bf16 ||
+      return (SimpleTy == MVT::v32i1    || SimpleTy == MVT::v4i8     ||
+              SimpleTy == MVT::v2i16    || SimpleTy == MVT::v1i32    ||
+              SimpleTy == MVT::v4f8e4m3 || SimpleTy == MVT::v4f8e5m2 ||
+              SimpleTy == MVT::v2f16    || SimpleTy == MVT::v2bf16   ||
               SimpleTy == MVT::v1f32);
     }
 
     /// Return true if this is a 64-bit vector type.
     bool is64BitVector() const {
-      return (SimpleTy == MVT::v64i1  || SimpleTy == MVT::v8i8  ||
-              SimpleTy == MVT::v4i16  || SimpleTy == MVT::v2i32 ||
-              SimpleTy == MVT::v1i64  || SimpleTy == MVT::v4f16 ||
-              SimpleTy == MVT::v4bf16 ||SimpleTy == MVT::v2f32  ||
+      return (SimpleTy == MVT::v64i1    || SimpleTy == MVT::v8i8     ||
+              SimpleTy == MVT::v4i16    || SimpleTy == MVT::v2i32    ||
+              SimpleTy == MVT::v8f8e4m3 || SimpleTy == MVT::v8f8e5m2 ||
+              SimpleTy == MVT::v1i64    || SimpleTy == MVT::v4f16    ||
+              SimpleTy == MVT::v4bf16   ||SimpleTy == MVT::v2f32     ||
               SimpleTy == MVT::v1f64);
     }
 
     /// Return true if this is a 128-bit vector type.
     bool is128BitVector() const {
-      return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8  ||
-              SimpleTy == MVT::v8i16  || SimpleTy == MVT::v4i32  ||
-              SimpleTy == MVT::v2i64  || SimpleTy == MVT::v1i128 ||
-              SimpleTy == MVT::v8f16  || SimpleTy == MVT::v8bf16 ||
-              SimpleTy == MVT::v4f32  || SimpleTy == MVT::v2f64);
+      return (SimpleTy == MVT::v128i1    || SimpleTy == MVT::v16i8     ||
+              SimpleTy == MVT::v8i16     || SimpleTy == MVT::v4i32     ||
+              SimpleTy == MVT::v2i64     || SimpleTy == MVT::v1i128    ||
+              SimpleTy == MVT::v16f8e4m3 || SimpleTy == MVT::v16f8e5m2 ||
+              SimpleTy == MVT::v8f16     || SimpleTy == MVT::v8bf16    ||
+              SimpleTy == MVT::v4f32     || SimpleTy == MVT::v2f64);
     }
 
     /// Return true if this is a 256-bit vector type.
     bool is256BitVector() const {
-      return (SimpleTy == MVT::v16f16 || SimpleTy == MVT::v16bf16 ||
-              SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 ||
-              SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
-              SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64 ||
-              SimpleTy == MVT::v256i1 || SimpleTy == MVT::v128i2 ||
+      return (SimpleTy == MVT::v16f16    || SimpleTy == MVT::v16bf16   ||
+              SimpleTy == MVT::v8f32     || SimpleTy == MVT::v4f64     ||
+              SimpleTy == MVT::v32i8     || SimpleTy == MVT::v16i16    ||
+              SimpleTy == MVT::v32f8e4m3 || SimpleTy == MVT::v32f8e5m2 ||
+              SimpleTy == MVT::v8i32     || SimpleTy == MVT::v4i64     ||
+              SimpleTy == MVT::v256i1    || SimpleTy == MVT::v128i2    ||
               SimpleTy == MVT::v64i4);
     }
 
     /// Return true if this is a 512-bit vector type.
     bool is512BitVector() const {
-      return (SimpleTy == MVT::v32f16 || SimpleTy == MVT::v32bf16 ||
-              SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64 ||
-              SimpleTy == MVT::v512i1 || SimpleTy == MVT::v256i2 ||
-              SimpleTy == MVT::v128i4 || SimpleTy == MVT::v64i8 ||
-              SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
+      return (SimpleTy == MVT::v32f16    || SimpleTy == MVT::v32bf16   ||
+              SimpleTy == MVT::v16f32    || SimpleTy == MVT::v8f64     ||
+              SimpleTy == MVT::v512i1    || SimpleTy == MVT::v256i2    ||
+              SimpleTy == MVT::v128i4    || SimpleTy == MVT::v64i8     ||
+              SimpleTy == MVT::v64f8e4m3 || SimpleTy == MVT::v64f8e5m2 ||
+              SimpleTy == MVT::v32i16    || SimpleTy == MVT::v16i32    ||
               SimpleTy == MVT::v8i64);
     }
 
     /// Return true if this is a 1024-bit vector type.
     bool is1024BitVector() const {
-      return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
-              SimpleTy == MVT::v64i16  || SimpleTy == MVT::v32i32 ||
-              SimpleTy == MVT::v16i64  || SimpleTy == MVT::v64f16 ||
-              SimpleTy == MVT::v32f32  || SimpleTy == MVT::v16f64 ||
+      return (SimpleTy == MVT::v1024i1    || SimpleTy == MVT::v128i8     ||
+              SimpleTy == MVT::v64i16     || SimpleTy == MVT::v32i32     ||
+              SimpleTy == MVT::v128f8e4m3 || SimpleTy == MVT::v128f8e5m2 ||
+              SimpleTy == MVT::v16i64     || SimpleTy == MVT::v64f16     ||
+              SimpleTy == MVT::v32f32     || SimpleTy == MVT::v16f64     ||
               SimpleTy == MVT::v64bf16);
     }
 
     /// Return true if this is a 2048-bit vector type.
     bool is2048BitVector() const {
       return (SimpleTy == MVT::v256i8  || SimpleTy == MVT::v128i16 ||
               SimpleTy == MVT::v64i32  || SimpleTy == MVT::v32i64  ||
               SimpleTy == MVT::v128f16 || SimpleTy == MVT::v64f32  ||
MVT getVectorElementType() const {
       case v256i64:
       case nxv1i64:
       case nxv2i64:
       case nxv4i64:
       case nxv8i64:
       case nxv16i64:
       case nxv32i64: return i64;
       case v1i128: return i128;
+      case v1f8e4m3:
+      case v2f8e4m3:
+      case v3f8e4m3:
+      case v4f8e4m3:
+      case v8f8e4m3:
+      case v16f8e4m3:
+      case v32f8e4m3:
+      case v64f8e4m3:
+      case v128f8e4m3:
+      case nxv1f8e4m3:
+      case nxv2f8e4m3:
+      case nxv4f8e4m3:
+      case nxv8f8e4m3: return f8e4m3;
+      case v1f8e5m2:
+      case v2f8e5m2:
+      case v3f8e5m2:
+      case v4f8e5m2:
+      case v8f8e5m2:
+      case v16f8e5m2:
+      case v32f8e5m2:
+      case v64f8e5m2:
+      case v128f8e5m2:
+      case nxv1f8e5m2:
+      case nxv2f8e5m2:
+      case nxv4f8e5m2:
+      case nxv8f8e5m2: return f8e5m2;
       case v1f16:
       case v2f16:
       case v3f16:
       case v4f16:
       case v8f16:
       case v16f16:
       case v32f16:
       case v64f16:
unsigned getVectorMinNumElements() const {
       case v256f64: return 256;
       case v128i1:
       case v128i2:
       case v128i4:
       case v128i8:
       case v128i16:
       case v128i32:
       case v128i64:
+      case v128f8e4m3:
+      case v128f8e5m2:
       case v128f16:
       case v128bf16:
       case v128f32:
       case v128f64: return 128;
       case v64i1:
       case v64i4:
       case v64i8:
       case v64i16:
       case v64i32:
       case v64i64:
+      case v64f8e4m3:
+      case v64f8e5m2:
       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 v32f8e4m3:
+      case v32f8e5m2:
       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 v16f8e4m3:
+      case v16f8e5m2:
       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 v8f8e4m3:
+      case v8f8e5m2:
       case v8bf16:
       case v8f32:
       case v8f64:
       case nxv8i1:
       case nxv8i8:
       case nxv8i16:
       case nxv8i32:
       case nxv8i64:
+      case nxv8f8e4m3:
+      case nxv8f8e5m2:
       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 v4f8e4m3:
+      case v4f8e5m2:
       case v4f16:
       case v4bf16:
       case v4f32:
       case v4f64:
       case nxv4i1:
       case nxv4i8:
       case nxv4i16:
       case nxv4i32:
       case nxv4i64:
+      case nxv4f8e4m3:
+      case nxv4f8e5m2:
       case nxv4f16:
       case nxv4bf16:
       case nxv4f32:
       case nxv4f64: return 4;
       case v3i16:
       case v3i32:
       case v3i64:
+      case v3f8e4m3:
+      case v3f8e5m2:
       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 v2f8e4m3:
+      case v2f8e5m2:
       case v2f32:
       case v2f64:
       case nxv2i1:
       case nxv2i8:
       case nxv2i16:
       case nxv2i32:
       case nxv2i64:
+      case nxv2f8e4m3:
+      case nxv2f8e5m2:
       case nxv2f16:
       case nxv2bf16:
       case nxv2f32:
       case nxv2f64: return 2;
       case v1i1:
       case v1i8:
       case v1i16:
       case v1i32:
       case v1i64:
       case v1i128:
+      case v1f8e4m3:
+      case v1f8e5m2:
       case v1f16:
       case v1f32:
       case v1f64:
       case nxv1i1:
       case nxv1i8:
       case nxv1i16:
       case nxv1i32:
       case nxv1i64:
+      case nxv1f8e4m3:
+      case nxv1f8e5m2:
       case nxv1f16:
       case nxv1bf16:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
     ElementCount getVectorElementCount() const {
TypeSize getSizeInBits() const {
       case i2:
       case v2i1: return TypeSize::Fixed(2);
       case nxv2i1: return TypeSize::Scalable(2);
       case i4:
       case v4i1: return TypeSize::Fixed(4);
       case nxv4i1: return TypeSize::Scalable(4);
       case i8  :
       case v1i8:
-      case v8i1: return TypeSize::Fixed(8);
+      case v8i1:
+      case f8e4m3:
+      case f8e5m2:
+      case v1f8e4m3:
+      case v1f8e5m2: return TypeSize::Fixed(8);
       case nxv1i8:
-      case nxv8i1: return TypeSize::Scalable(8);
+      case nxv8i1: 
+      case nxv1f8e4m3:
+      case nxv1f8e5m2: return TypeSize::Scalable(8);
       case i16 :
       case f16:
       case bf16:
       case v16i1:
       case v2i8:
+      case v2f8e4m3:
+      case v2f8e5m2:
       case v1i16:
       case v1f16: return TypeSize::Fixed(16);
       case nxv16i1:
       case nxv2i8:
       case nxv1i16:
       case nxv1bf16:
+      case nxv2f8e4m3:
+      case nxv2f8e5m2:
       case nxv1f16: return TypeSize::Scalable(16);
+      case v3f8e4m3:
+      case v3f8e5m2: return TypeSize::Scalable(24);
       case f32 :
       case i32 :
       case v32i1:
       case v4i8:
+      case v4f8e4m3:
+      case v4f8e5m2:
       case v2i16:
       case v2f16:
       case v2bf16:
       case v1f32:
       case v1i32: return TypeSize::Fixed(32);
       case nxv32i1:
       case nxv4i8:
       case nxv2i16:
       case nxv1i32:
+      case nxv4f8e4m3:
+      case nxv4f8e5m2:
       case nxv2f16:
       case nxv2bf16:
       case nxv1f32: return TypeSize::Scalable(32);
       case v3i16:
       case v3f16:
       case v3bf16: return TypeSize::Fixed(48);
       case x86mmx:
       case f64 :
       case i64 :
       case v64i1:
       case v8i8:
       case v4i16:
       case v2i32:
       case v1i64:
+      case v8f8e4m3:
+      case v8f8e5m2:
       case v4f16:
       case v4bf16:
       case v2f32:
       case v1f64: return TypeSize::Fixed(64);
       case nxv64i1:
       case nxv8i8:
       case nxv4i16:
       case nxv2i32:
       case nxv1i64:
+      case nxv8f8e4m3:
+      case nxv8f8e5m2:
       case nxv4f16:
       case nxv4bf16:
       case nxv2f32:
       case nxv1f64: return TypeSize::Scalable(64);
       case f80 :  return TypeSize::Fixed(80);
       case v3i32:
       case v3f32: return TypeSize::Fixed(96);
       case f128:
       case ppcf128:
       case i128:
       case v128i1:
       case v16i8:
       case v8i16:
       case v4i32:
       case v2i64:
       case v1i128:
+      case v16f8e4m3:
+      case v16f8e5m2:
       case v8f16:
       case v8bf16:
       case v4f32:
       case v2f64: return TypeSize::Fixed(128);
       case nxv16i8:
       case nxv8i16:
       case nxv4i32:
       case nxv2i64:
TypeSize getSizeInBits() const {
       case v7f32: return TypeSize::Fixed(224);
       case v256i1:
       case v128i2:
       case v64i4:
       case v32i8:
       case v16i16:
       case v8i32:
       case v4i64:
+      case v32f8e4m3:
+      case v32f8e5m2:
       case v16f16:
       case v16bf16:
       case v8f32:
       case v4f64: return TypeSize::Fixed(256);
       case nxv32i8:
       case nxv16i16:
       case nxv8i32:
       case nxv4i64:
TypeSize getSizeInBits() const {
       case i64x8:
       case v512i1:
       case v256i2:
       case v128i4:
       case v64i8:
       case v32i16:
       case v16i32:
       case v8i64:
+      case v64f8e4m3:
+      case v64f8e5m2:
       case v32f16:
       case v32bf16:
       case v16f32:
       case v8f64: return TypeSize::Fixed(512);
       case nxv64i8:
       case nxv32i16:
       case nxv16i32:
       case nxv8i64:
       case nxv32f16:
       case nxv32bf16:
       case nxv16f32:
       case nxv8f64: return TypeSize::Scalable(512);
       case v1024i1:
       case v128i8:
       case v64i16:
       case v32i32:
       case v16i64:
+      case v128f8e4m3:
+      case v128f8e5m2:
       case v64f16:
       case v64bf16:
       case v32f32:
       case v16f64: return TypeSize::Fixed(1024);
       case nxv32i32:
       case nxv16i64: return TypeSize::Scalable(1024);
       case v2048i1:
       case v256i8:
bool bitsLE(MVT VT) const {
              "Comparison between scalable and fixed types");
       return knownBitsLE(VT);
     }
 
     static MVT getFloatingPointVT(unsigned BitWidth) {
       switch (BitWidth) {
       default:
         llvm_unreachable("Bad bit width!");
+      case 8:
+        return MVT::f8e4m3; // or should we consider f8e5m2
       case 16:
         return MVT::f16;
       case 32:
         return MVT::f32;
       case 64:
         return MVT::f64;
       case 80:
         return MVT::f80;
static MVT getVectorVT(MVT VT, unsigned NumElements) {
         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::f8e4m3:
+        if (NumElements == 1)   return MVT::v1f8e4m3;
+        if (NumElements == 2)   return MVT::v2f8e4m3;
+        if (NumElements == 3)   return MVT::v3f8e4m3;
+        if (NumElements == 4)   return MVT::v4f8e4m3;
+        if (NumElements == 8)   return MVT::v8f8e4m3;
+        if (NumElements == 16)  return MVT::v16f8e4m3;
+        if (NumElements == 32)  return MVT::v32f8e4m3;
+        if (NumElements == 64)  return MVT::v64f8e4m3;
+        if (NumElements == 128) return MVT::v128f8e4m3;
+        break;
+      case MVT::f8e5m2:
+        if (NumElements == 1)   return MVT::v1f8e5m2;
+        if (NumElements == 2)   return MVT::v2f8e5m2;
+        if (NumElements == 3)   return MVT::v3f8e5m2;
+        if (NumElements == 4)   return MVT::v4f8e5m2;
+        if (NumElements == 8)   return MVT::v8f8e5m2;
+        if (NumElements == 16)  return MVT::v16f8e5m2;
+        if (NumElements == 32)  return MVT::v32f8e5m2;
+        if (NumElements == 64)  return MVT::v64f8e5m2;
+        if (NumElements == 128) return MVT::v128f8e5m2;
+        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;
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
         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::f8e4m3:
+          if (NumElements == 1)  return MVT::nxv1f8e4m3;
+          if (NumElements == 2)  return MVT::nxv2f8e4m3;
+          if (NumElements == 4)  return MVT::nxv4f8e4m3;
+          if (NumElements == 8)  return MVT::nxv8f8e4m3;
+          break;
+        case MVT::f8e5m2:
+          if (NumElements == 1)  return MVT::nxv1f8e5m2;
+          if (NumElements == 2)  return MVT::nxv2f8e5m2;
+          if (NumElements == 4)  return MVT::nxv4f8e5m2;
+          if (NumElements == 8)  return MVT::nxv8f8e5m2;
+          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;

llvm/lib/AsmParser/LLLexer.cpp

#define TYPEKEYWORD(STR, LLVMTY)                                               \
   TYPEKEYWORD("x86_fp80",  Type::getX86_FP80Ty(Context));
   TYPEKEYWORD("fp128",     Type::getFP128Ty(Context));
   TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
   TYPEKEYWORD("label",     Type::getLabelTy(Context));
   TYPEKEYWORD("metadata",  Type::getMetadataTy(Context));
   TYPEKEYWORD("x86_mmx",   Type::getX86_MMXTy(Context));
   TYPEKEYWORD("x86_amx",   Type::getX86_AMXTy(Context));
   TYPEKEYWORD("token",     Type::getTokenTy(Context));
+  TYPEKEYWORD("f8e5m2",    Type::getF8E5M2Ty(Context));
+  TYPEKEYWORD("f8e4m3",    Type::getF8E4M3Ty(Context));
 
   if (Keyword == "ptr") {
     // setOpaquePointers() must be called before creating any pointer types.
     if (!Context.hasSetOpaquePointersValue()) {
       Context.setOpaquePointers(true);
     } else if (Context.supportsTypedPointers()) {
       Warning("ptr type is only supported in -opaque-pointers mode");
       return lltok::Error;

 /// Lex all tokens that start with a 0x prefix, knowing they match and are not
 /// labels.
 ///    HexFPConstant     0x[0-9A-Fa-f]+
 ///    HexFP80Constant   0xK[0-9A-Fa-f]+
 ///    HexFP128Constant  0xL[0-9A-Fa-f]+
 ///    HexPPC128Constant 0xM[0-9A-Fa-f]+
 ///    HexHalfConstant   0xH[0-9A-Fa-f]+
 ///    HexBFloatConstant 0xR[0-9A-Fa-f]+
+///    HexFP8Constant    0xQ[0-9A-Fa-f]+
 lltok::Kind LLLexer::Lex0x() {
   CurPtr = TokStart + 2;
 
   char Kind;
   if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H' ||
-      CurPtr[0] == 'R') {
+      CurPtr[0] == 'R' || CurPtr[0] == 'Q') {
     Kind = *CurPtr++;
   } else {
     Kind = 'J';
   }
 
   if (!isxdigit(static_cast<unsigned char>(CurPtr[0]))) {
     // Bad token, return it as an error.
     CurPtr = TokStart+1;
case 'H':
     APFloatVal = APFloat(APFloat::IEEEhalf(),
                          APInt(16,HexIntToVal(TokStart+3, CurPtr)));
     return lltok::APFloat;
   case 'R':
     // Brain floating point
     APFloatVal = APFloat(APFloat::BFloat(),
                          APInt(16, HexIntToVal(TokStart + 3, CurPtr)));
     return lltok::APFloat;
+  case 'Q':
+    // FP8 
+    APFloatVal = APFloat(APFloat::Float8E5M2(),
+                         APInt(8, HexIntToVal(TokStart + 1, CurPtr)));
+    return lltok::APFloat;
   }
 }
 
 /// Lex tokens for a label or a numeric constant, possibly starting with -.
 ///    Label             [-a-zA-Z$._0-9]+:
 ///    NInteger          -[0-9]+
 ///    FPConstant        [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
 ///    PInteger          [0-9]+

llvm/lib/AsmParser/LLParser.cpp

if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
         // The convert call above may quiet an SNaN, so manufacture another
         // SNaN. The bitcast works because the payload (significand) parameter
         // is truncated to fit.
         APInt Payload = ID.APFloatVal.bitcastToAPInt();
         ID.APFloatVal = APFloat::getSNaN(ID.APFloatVal.getSemantics(),
                                          ID.APFloatVal.isNegative(), &Payload);
       }
     }
+    // // There is only one defined FP8 literal type, Float8E5M2 (e.g. 0xQ23)
+    // // For the case the literal is of type Float8E5M2, and the assiened var is
+    // // Float8E4M3, convert the type.
+    // if (&ID.APFloatVal.getSemantics() == &APFloat::Float8E5M2() &&
+    //     Ty->isF8E4M3()) {
+    //   bool Ignored;
+    //   ID.APFloatVal.convert(APFloat::Float8E4M3FN(),
+    //                         APFloat::rmNearestTiesToEven, &Ignored);
+    // }
     V = ConstantFP::get(Context, ID.APFloatVal);
 
     if (V->getType() != Ty)
       return error(ID.Loc, "floating point constant does not have type '" +
                                getTypeString(Ty) + "'");
 
     return false;
   case ValID::t_Null:

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
       // type list.  This allows us to reserve space.
       if (Record.empty())
         return error("Invalid numentry record");
       TypeList.resize(Record[0]);
       continue;
     case bitc::TYPE_CODE_VOID:      // VOID
       ResultTy = Type::getVoidTy(Context);
       break;
-    case bitc::TYPE_CODE_HALF:     // HALF
+    case bitc::TYPE_CODE_HALF:     // FP8
       ResultTy = Type::getHalfTy(Context);
       break;
+    case bitc::TYPE_CODE_F8E4M3: // FP8
+      ResultTy = Type::getF8E4M3Ty(Context);
+      break;
+    case bitc::TYPE_CODE_F8E5M2: // HALF
+      ResultTy = Type::getF8E5M2Ty(Context);
+      break;
     case bitc::TYPE_CODE_BFLOAT:    // BFLOAT
       ResultTy = Type::getBFloatTy(Context);
       break;
     case bitc::TYPE_CODE_FLOAT:     // FLOAT
       ResultTy = Type::getFloatTy(Context);
       break;
     case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
       ResultTy = Type::getDoubleTy(Context);

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeTypeTable() {
   // Loop over all of the types, emitting each in turn.
   for (Type *T : TypeList) {
     int AbbrevToUse = 0;
     unsigned Code = 0;
 
     switch (T->getTypeID()) {
     case Type::VoidTyID:      Code = bitc::TYPE_CODE_VOID;      break;
     case Type::HalfTyID:      Code = bitc::TYPE_CODE_HALF;      break;
+    case Type::F8E4M3TyID:
+      Code = bitc::TYPE_CODE_F8E4M3;
+      break;
+    case Type::F8E5M2TyID:
+      Code = bitc::TYPE_CODE_F8E5M2;
+      break;
     case Type::BFloatTyID:    Code = bitc::TYPE_CODE_BFLOAT;    break;
     case Type::FloatTyID:     Code = bitc::TYPE_CODE_FLOAT;     break;
     case Type::DoubleTyID:    Code = bitc::TYPE_CODE_DOUBLE;    break;
     case Type::X86_FP80TyID:  Code = bitc::TYPE_CODE_X86_FP80;  break;
     case Type::FP128TyID:     Code = bitc::TYPE_CODE_FP128;     break;
     case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
     case Type::LabelTyID:     Code = bitc::TYPE_CODE_LABEL;     break;
     case Type::MetadataTyID:  Code = bitc::TYPE_CODE_METADATA;  break;

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::i1:      return Type::getInt1Ty(Context);
   case MVT::i2:      return Type::getIntNTy(Context, 2);
   case MVT::i4:      return Type::getIntNTy(Context, 4);
   case MVT::i8:      return Type::getInt8Ty(Context);
   case MVT::i16:     return Type::getInt16Ty(Context);
   case MVT::i32:     return Type::getInt32Ty(Context);
   case MVT::i64:     return Type::getInt64Ty(Context);
   case MVT::i128:    return IntegerType::get(Context, 128);
+  case MVT::f8e4m3: return Type::getF8E4M3Ty(Context);
+  case MVT::f8e5m2: return Type::getF8E5M2Ty(Context);
   case MVT::f16:     return Type::getHalfTy(Context);
   case MVT::bf16:    return Type::getBFloatTy(Context);
   case MVT::f32:     return Type::getFloatTy(Context);
   case MVT::f64:     return Type::getDoubleTy(Context);
   case MVT::f80:     return Type::getX86_FP80Ty(Context);
   case MVT::f128:    return Type::getFP128Ty(Context);
   case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
   case MVT::x86mmx:  return Type::getX86_MMXTy(Context);
Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::v64i64:
     return FixedVectorType::get(Type::getInt64Ty(Context), 64);
   case MVT::v128i64:
     return FixedVectorType::get(Type::getInt64Ty(Context), 128);
   case MVT::v256i64:
     return FixedVectorType::get(Type::getInt64Ty(Context), 256);
   case MVT::v1i128:
     return FixedVectorType::get(Type::getInt128Ty(Context), 1);
+  case MVT::v1f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 1);
+  case MVT::v2f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 2);
+  case MVT::v3f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 3);
+  case MVT::v4f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 4);
+  case MVT::v8f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 8);
+  case MVT::v16f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 16);
+  case MVT::v32f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 32);
+  case MVT::v64f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 64);
+  case MVT::v128f8e4m3 :
+    return FixedVectorType::get(Type::getF8E4M3Ty(Context), 128);
+  case MVT::v1f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 1);
+  case MVT::v2f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 2);
+  case MVT::v3f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 3);
+  case MVT::v4f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 4);
+  case MVT::v8f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 8);
+  case MVT::v16f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 16);
+  case MVT::v32f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 32);
+  case MVT::v64f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 64);
+  case MVT::v128f8e5m2 :
+    return FixedVectorType::get(Type::getF8E5M2Ty(Context), 128);
   case MVT::v1f16:
     return FixedVectorType::get(Type::getHalfTy(Context), 1);
   case MVT::v2f16:
     return FixedVectorType::get(Type::getHalfTy(Context), 2);
   case MVT::v3f16:
     return FixedVectorType::get(Type::getHalfTy(Context), 3);
   case MVT::v4f16:
     return FixedVectorType::get(Type::getHalfTy(Context), 4);
Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::nxv4i64:
     return ScalableVectorType::get(Type::getInt64Ty(Context), 4);
   case MVT::nxv8i64:
     return ScalableVectorType::get(Type::getInt64Ty(Context), 8);
   case MVT::nxv16i64:
     return ScalableVectorType::get(Type::getInt64Ty(Context), 16);
   case MVT::nxv32i64:
     return ScalableVectorType::get(Type::getInt64Ty(Context), 32);
+  case MVT::nxv1f8e4m3:
+    return ScalableVectorType::get(Type::getF8E4M3Ty(Context), 1);
+  case MVT::nxv2f8e4m3:
+    return ScalableVectorType::get(Type::getF8E4M3Ty(Context), 2);
+  case MVT::nxv4f8e4m3:
+    return ScalableVectorType::get(Type::getF8E4M3Ty(Context), 4);
+  case MVT::nxv8f8e4m3:
+    return ScalableVectorType::get(Type::getF8E4M3Ty(Context), 8);
+  case MVT::nxv1f8e5m2:
+    return ScalableVectorType::get(Type::getF8E5M2Ty(Context), 1);
+  case MVT::nxv2f8e5m2:
+    return ScalableVectorType::get(Type::getF8E5M2Ty(Context), 2);
+  case MVT::nxv4f8e5m2:
+    return ScalableVectorType::get(Type::getF8E5M2Ty(Context), 4);
+  case MVT::nxv8f8e5m2:
+    return ScalableVectorType::get(Type::getF8E5M2Ty(Context), 8);
   case MVT::nxv1f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 1);
   case MVT::nxv2f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 2);
   case MVT::nxv4f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 4);
   case MVT::nxv8f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 8);
MVT MVT::getVT(Type *Ty, bool HandleUnknown){
   switch (Ty->getTypeID()) {
   default:
     if (HandleUnknown) return MVT(MVT::Other);
     llvm_unreachable("Unknown type!");
   case Type::VoidTyID:
     return MVT::isVoid;
   case Type::IntegerTyID:
     return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth());
+  case Type::F8E4M3TyID:
+    return MVT(MVT::f8e4m3);
+  case Type::F8E5M2TyID:
+    return MVT(MVT::f8e5m2);
   case Type::HalfTyID:      return MVT(MVT::f16);
   case Type::BFloatTyID:    return MVT(MVT::bf16);
   case Type::FloatTyID:     return MVT(MVT::f32);
   case Type::DoubleTyID:    return MVT(MVT::f64);
   case Type::X86_FP80TyID:  return MVT(MVT::f80);
   case Type::X86_MMXTyID:   return MVT(MVT::x86mmx);
   case Type::X86_AMXTyID:   return MVT(MVT::x86amx);
   case Type::FP128TyID:     return MVT(MVT::f128);

llvm/lib/IR/AsmWriter.cpp

void TypePrinting::incorporateTypes() {
   NamedTypes.erase(NextToUse, NamedTypes.end());
 }
 
 /// Write the specified type to the specified raw_ostream, making use of type
 /// names or up references to shorten the type name where possible.
 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
   switch (Ty->getTypeID()) {
   case Type::VoidTyID:      OS << "void"; return;
+  case Type::F8E4M3TyID:
+    OS << "f8e4m3";
+    return;
+  case Type::F8E5M2TyID:
+    OS << "f8e5m2";
+    return;
   case Type::HalfTyID:      OS << "half"; return;
   case Type::BFloatTyID:    OS << "bfloat"; return;
   case Type::FloatTyID:     OS << "float"; return;
   case Type::DoubleTyID:    OS << "double"; return;
   case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
   case Type::FP128TyID:     OS << "fp128"; return;
   case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
   case Type::LabelTyID:     OS << "label"; return;
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
     } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
       Out << 'H';
       Out << format_hex_no_prefix(API.getZExtValue(), 4,
                                   /*Upper=*/true);
     } else if (&APF.getSemantics() == &APFloat::BFloat()) {
       Out << 'R';
       Out << format_hex_no_prefix(API.getZExtValue(), 4,
                                   /*Upper=*/true);
+    } else if (&APF.getSemantics() == &APFloat::Float8E5M2() || 
+               &APF.getSemantics() == &APFloat::Float8E4M3FN() ) {
+      Out << 'Q';
+      Out << format_hex_no_prefix(API.getZExtValue(), 2,
+                                  /*Upper=*/true);
     } else
       llvm_unreachable("Unsupported floating point type");
     return;
   }
 
   if (isa<ConstantAggregateZero>(CV)) {
     Out << "zeroinitializer";
     return;

llvm/lib/IR/Constants.cpp

bool Constant::containsConstantExpression() const {
   return false;
 }
 
 /// Constructor to create a '0' constant of arbitrary type.
 Constant *Constant::getNullValue(Type *Ty) {
   switch (Ty->getTypeID()) {
   case Type::IntegerTyID:
     return ConstantInt::get(Ty, 0);
+  case Type::F8E4M3TyID:
+  case Type::F8E5M2TyID:
   case Type::HalfTyID:
   case Type::BFloatTyID:
   case Type::FloatTyID:
   case Type::DoubleTyID:
   case Type::X86_FP80TyID:
   case Type::FP128TyID:
   case Type::PPC_FP128TyID:
     return ConstantFP::get(Ty->getContext(),
bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
 
   // FIXME rounding mode needs to be more flexible
   case Type::HalfTyID: {
     if (&Val2.getSemantics() == &APFloat::IEEEhalf())
       return true;
     Val2.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &losesInfo);
     return !losesInfo;
   }
+  case Type::F8E4M3TyID: {
+    if (&Val2.getSemantics() == &APFloat::Float8E4M3FN())
+      return true;
+    Val2.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
+                 &losesInfo);
+    return !losesInfo;
+  }
+  case Type::F8E5M2TyID: {
+    if (&Val2.getSemantics() == &APFloat::Float8E5M2())
+      return true;
+    Val2.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
+                 &losesInfo);
+    return !losesInfo;
+  }
   case Type::BFloatTyID: {
     if (&Val2.getSemantics() == &APFloat::BFloat())
       return true;
     Val2.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
     return !losesInfo;
   }
   case Type::FloatTyID: {
     if (&Val2.getSemantics() == &APFloat::IEEEsingle())
APFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const {
 
   switch (getElementType()->getTypeID()) {
   default:
     llvm_unreachable("Accessor can only be used when element is float/double!");
   case Type::HalfTyID: {
     auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
     return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
   }
+  case Type::F8E4M3TyID: {
+    auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
+    return APFloat(APFloat::Float8E4M3FN(), APInt(8, EltVal));
+  }
+  case Type::F8E5M2TyID: {
+    auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
+    return APFloat(APFloat::Float8E5M2(), APInt(8, EltVal));
+  }
   case Type::BFloatTyID: {
     auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
     return APFloat(APFloat::BFloat(), APInt(16, EltVal));
   }
   case Type::FloatTyID: {
     auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
     return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
   }

llvm/lib/IR/Core.cpp

 /*===-- Operations on types -----------------------------------------------===*/
 
 /*--.. Operations on all types (mostly) ....................................--*/
 
 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
   switch (unwrap(Ty)->getTypeID()) {
   case Type::VoidTyID:
     return LLVMVoidTypeKind;
+  case Type::F8E5M2TyID:
+    return LLVMFloatE5M2TypeKind;
+  case Type::F8E4M3TyID:
+    return LLVMFloatE4M3TypeKind;
   case Type::HalfTyID:
     return LLVMHalfTypeKind;
   case Type::BFloatTyID:
     return LLVMBFloatTypeKind;
   case Type::FloatTyID:
     return LLVMFloatTypeKind;
   case Type::DoubleTyID:
     return LLVMDoubleTypeKind;

 }
 
 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
   return unwrap<IntegerType>(IntegerTy)->getBitWidth();
 }
 
 /*--.. Operations on real types ............................................--*/
 
+LLVMTypeRef LLVMFloatE4M3TypeInContext(LLVMContextRef C) {
+  return (LLVMTypeRef)Type::getF8E4M3Ty(*unwrap(C));
+}
+LLVMTypeRef LLVMFloatE5M2TypeInContext(LLVMContextRef C) {
+  return (LLVMTypeRef)Type::getF8E5M2Ty(*unwrap(C));
+}
 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getHalfTy(*unwrap(C));
 }
 LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getBFloatTy(*unwrap(C));
 }
 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getFloatTy(*unwrap(C));
LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C));
 }
 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C));
 }
 LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C) {
   return (LLVMTypeRef) Type::getX86_AMXTy(*unwrap(C));
 }
-
+LLVMTypeRef LLVMFloatE4M3Type(void) {
+  return LLVMFloatE4M3TypeInContext(LLVMGetGlobalContext());
+}
+LLVMTypeRef LLVMFloatE5M2Type(void) {
+  return LLVMFloatE5M2TypeInContext(LLVMGetGlobalContext());
+}
 LLVMTypeRef LLVMHalfType(void) {
   return LLVMHalfTypeInContext(LLVMGetGlobalContext());
 }
 LLVMTypeRef LLVMBFloatType(void) {
   return LLVMBFloatTypeInContext(LLVMGetGlobalContext());
 }
 LLVMTypeRef LLVMFloatType(void) {
   return LLVMFloatTypeInContext(LLVMGetGlobalContext());
long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
   return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
 }
 
 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
   ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
   Type *Ty = cFP->getType();
 
   if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||
-      Ty->isDoubleTy()) {
+      Ty->isDoubleTy() || Ty->isF8E5M2() || Ty->isF8E4M3()) {
     *LosesInfo = false;
     return cFP->getValueAPF().convertToDouble();
   }
 
   bool APFLosesInfo;
   APFloat APF = cFP->getValueAPF();
   APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
   *LosesInfo = APFLosesInfo;

llvm/lib/IR/DataLayout.cpp

case Type::StructTyID: {
     assert(AggregateAlign.AlignType == AGGREGATE_ALIGN &&
            "Aggregate alignment must be first alignment entry");
     const Align Align =
         abi_or_pref ? AggregateAlign.ABIAlign : AggregateAlign.PrefAlign;
     return std::max(Align, Layout->getAlignment());
   }
   case Type::IntegerTyID:
     return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref);
+  case Type::F8E4M3TyID:
+  case Type::F8E5M2TyID:
   case Type::HalfTyID:
   case Type::BFloatTyID:
   case Type::FloatTyID:
   case Type::DoubleTyID:
   // PPC_FP128TyID and FP128TyID have different data contents, but the
   // same size and alignment, so they look the same here.
   case Type::PPC_FP128TyID:
   case Type::FP128TyID:

llvm/lib/IR/Function.cpp

if (EC.isScalable())
       Result += "nx";
     Result += "v" + utostr(EC.getKnownMinValue()) +
               getMangledTypeStr(VTy->getElementType(), HasUnnamedType);
   } else if (Ty) {
     switch (Ty->getTypeID()) {
     default: llvm_unreachable("Unhandled type");
     case Type::VoidTyID:      Result += "isVoid";   break;
     case Type::MetadataTyID:  Result += "Metadata"; break;
+    case Type::F8E4M3TyID:
+      Result += "f8e4m3";
+      break;
+    case Type::F8E5M2TyID:
+      Result += "f8e5m2";
+      break;
     case Type::HalfTyID:      Result += "f16";      break;
     case Type::BFloatTyID:    Result += "bf16";     break;
     case Type::FloatTyID:     Result += "f32";      break;
     case Type::DoubleTyID:    Result += "f64";      break;
     case Type::X86_FP80TyID:  Result += "f80";      break;
     case Type::FP128TyID:     Result += "f128";     break;
     case Type::PPC_FP128TyID: Result += "ppcf128";  break;
     case Type::X86_MMXTyID:   Result += "x86mmx";   break;

llvm/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
 
   ConstantUniqueMap<InlineAsm> InlineAsms;
 
   ConstantInt *TheTrueVal = nullptr;
   ConstantInt *TheFalseVal = nullptr;
 
   // Basic type instances.
   Type VoidTy, LabelTy, HalfTy, BFloatTy, FloatTy, DoubleTy, MetadataTy,
-      TokenTy;
+      TokenTy, F8E5M2Ty, F8E4M3Ty;
   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, X86_AMXTy;
   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
 
   std::unique_ptr<ConstantTokenNone> TheNoneToken;
 
   BumpPtrAllocator Alloc;
   UniqueStringSaver Saver{Alloc};
 

llvm/lib/IR/LLVMContextImpl.cpp

 static cl::opt<bool>
     OpaquePointersCL("opaque-pointers", cl::desc("Use opaque pointers"),
                      cl::init(true));
 
 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
     : DiagHandler(std::make_unique<DiagnosticHandler>()),
       VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
       HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
+      F8E5M2Ty(C, Type::F8E5M2TyID), F8E4M3Ty(C, Type::F8E4M3TyID),
       FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID),
       MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
       X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
       PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_MMXTy(C, Type::X86_MMXTyID),
       X86_AMXTy(C, Type::X86_AMXTyID), Int1Ty(C, 1), Int8Ty(C, 8),
       Int16Ty(C, 16), Int32Ty(C, 32), Int64Ty(C, 64), Int128Ty(C, 128) {
   if (OpaquePointersCL.getNumOccurrences()) {
     OpaquePointers = OpaquePointersCL;

llvm/lib/IR/Type.cpp

 
 //===----------------------------------------------------------------------===//
 //                         Type Class Implementation
 //===----------------------------------------------------------------------===//
 
 Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
   switch (IDNumber) {
   case VoidTyID      : return getVoidTy(C);
   case HalfTyID      : return getHalfTy(C);
   case BFloatTyID    : return getBFloatTy(C);
   case FloatTyID     : return getFloatTy(C);
   case DoubleTyID    : return getDoubleTy(C);
   case X86_FP80TyID  : return getX86_FP80Ty(C);
   case FP128TyID     : return getFP128Ty(C);
   case PPC_FP128TyID : return getPPC_FP128Ty(C);
   case LabelTyID     : return getLabelTy(C);
   case MetadataTyID  : return getMetadataTy(C);
   case X86_MMXTyID   : return getX86_MMXTy(C);
   case X86_AMXTyID   : return getX86_AMXTy(C);
   case TokenTyID     : return getTokenTy(C);
+  case F8E4M3TyID:
+    return getF8E4M3Ty(C);
+  case F8E5M2TyID:
+    return getF8E5M2Ty(C);
   default:
     return nullptr;
   }
 }
 
 bool Type::isIntegerTy(unsigned Bitwidth) const {
   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
 }
 
 bool Type::isOpaquePointerTy() const {
   if (auto *PTy = dyn_cast<PointerType>(this))
     return PTy->isOpaque();
   return false;
 }
 
 const fltSemantics &Type::getFltSemantics() const {
   switch (getTypeID()) {
+  case F8E4M3TyID:
+    return APFloat::Float8E4M3FN();
+  case F8E5M2TyID:
+    return APFloat::Float8E5M2();
   case HalfTyID: return APFloat::IEEEhalf();
   case BFloatTyID: return APFloat::BFloat();
   case FloatTyID: return APFloat::IEEEsingle();
   case DoubleTyID: return APFloat::IEEEdouble();
   case X86_FP80TyID: return APFloat::x87DoubleExtended();
   case FP128TyID: return APFloat::IEEEquad();
   case PPC_FP128TyID: return APFloat::PPCDoubleDouble();
   default: llvm_unreachable("Invalid floating type");
   }
 }
 
 bool Type::isIEEE() const {
   return APFloat::getZero(getFltSemantics()).isIEEE();
 }
 
 Type *Type::getFloatingPointTy(LLVMContext &C, const fltSemantics &S) {
   Type *Ty;
   if (&S == &APFloat::IEEEhalf())
     Ty = Type::getHalfTy(C);
   else if (&S == &APFloat::BFloat())
     Ty = Type::getBFloatTy(C);
+  else if (&S == &APFloat::Float8E5M2())
+    Ty = Type::getF8E5M2Ty(C);
+  else if (&S == &APFloat::Float8E4M3FN())
+    Ty = Type::getF8E4M3Ty(C);
   else if (&S == &APFloat::IEEEsingle())
     Ty = Type::getFloatTy(C);
   else if (&S == &APFloat::IEEEdouble())
     Ty = Type::getDoubleTy(C);
   else if (&S == &APFloat::x87DoubleExtended())
     Ty = Type::getX86_FP80Ty(C);
   else if (&S == &APFloat::IEEEquad())
     Ty = Type::getFP128Ty(C);
if (auto *STy = dyn_cast<StructType>(this)) {
     return true;
   }
 
   return false;
 }
 
 TypeSize Type::getPrimitiveSizeInBits() const {
   switch (getTypeID()) {
+  case Type::F8E4M3TyID:
+    return TypeSize::Fixed(8);
+  case Type::F8E5M2TyID:
+    return TypeSize::Fixed(8);
   case Type::HalfTyID: return TypeSize::Fixed(16);
   case Type::BFloatTyID: return TypeSize::Fixed(16);
   case Type::FloatTyID: return TypeSize::Fixed(32);
   case Type::DoubleTyID: return TypeSize::Fixed(64);
   case Type::X86_FP80TyID: return TypeSize::Fixed(80);
   case Type::FP128TyID: return TypeSize::Fixed(128);
   case Type::PPC_FP128TyID: return TypeSize::Fixed(128);
   case Type::X86_MMXTyID: return TypeSize::Fixed(64);
unsigned Type::getScalarSizeInBits() const {
   // It is safe to assume that the scalar types have a fixed size.
   return getScalarType()->getPrimitiveSizeInBits().getFixedSize();
 }
 
 int Type::getFPMantissaWidth() const {
   if (auto *VTy = dyn_cast<VectorType>(this))
     return VTy->getElementType()->getFPMantissaWidth();
   assert(isFloatingPointTy() && "Not a floating point type!");
   if (getTypeID() == HalfTyID) return 11;
+  if (getTypeID() == F8E4M3TyID)
+    return 3;
+  if (getTypeID() == F8E5M2TyID)
+    return 2;
   if (getTypeID() == BFloatTyID) return 8;
   if (getTypeID() == FloatTyID) return 24;
   if (getTypeID() == DoubleTyID) return 53;
   if (getTypeID() == X86_FP80TyID) return 64;
   if (getTypeID() == FP128TyID) return 113;
   assert(getTypeID() == PPC_FP128TyID && "unknown fp type");
   return -1;
 }
 
 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
   if (auto *ATy = dyn_cast<ArrayType>(this))
     return ATy->getElementType()->isSized(Visited);
 
   if (auto *VTy = dyn_cast<VectorType>(this))
     return VTy->getElementType()->isSized(Visited);
 
   return cast<StructType>(this)->isSized(Visited);
 }
 
 //===----------------------------------------------------------------------===//
 //                          Primitive 'Type' data
 //===----------------------------------------------------------------------===//
 
 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
+Type *Type::getF8E5M2Ty(LLVMContext &C) { return &C.pImpl->F8E5M2Ty; }
+Type *Type::getF8E4M3Ty(LLVMContext &C) { return &C.pImpl->F8E4M3Ty; }
 Type *Type::getBFloatTy(LLVMContext &C) { return &C.pImpl->BFloatTy; }
 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }

 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
   return IntegerType::get(C, N);
 }
 
 PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
   return getHalfTy(C)->getPointerTo(AS);
 }
 
+PointerType *Type::getF8E5M2PtrTy(LLVMContext &C, unsigned AS) {
+  return getF8E5M2Ty(C)->getPointerTo(AS);
+}
+
+PointerType *Type::getF8E4M3PtrTy(LLVMContext &C, unsigned AS) {
+  return getF8E4M3Ty(C)->getPointerTo(AS);
+}
+
 PointerType *Type::getBFloatPtrTy(LLVMContext &C, unsigned AS) {
   return getBFloatTy(C)->getPointerTo(AS);
 }
 
 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
   return getFloatTy(C)->getPointerTo(AS);
 }
 

llvm/lib/Target/Hexagon/HexagonTargetObjectFile.cpp

unsigned HexagonTargetObjectFile::getSmallestAddressableSize(const Type *Ty,
   case Type::FP128TyID:
   case Type::PPC_FP128TyID:
   case Type::LabelTyID:
   case Type::MetadataTyID:
   case Type::X86_MMXTyID:
   case Type::X86_AMXTyID:
   case Type::TokenTyID:
   case Type::TypedPointerTyID:
+  case Type::F8E4M3TyID:
+  case Type::F8E5M2TyID:
     return 0;
   }
 
   return 0;
 }
 
 MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {

llvm/test/Assembler/fp8.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s --check-prefix=ASSEM-DISASS
+; RUN: opt < %s -O3 -S | FileCheck %s --check-prefix=OPT
+; RUN: verify-uselistorder %s
+; Basic smoke tests for f8e4m3 and f8e5m2 types.
+
+define f8e4m3 @check_f8e4m3(f8e4m3 %A) {
+; ASSEM-DISASS: ret f8e4m3 %A
+    ret f8e4m3 %A
+}
+
+define f8e4m3 @check_f8e4m3_literal() {
+; ASSEM-DISASS: ret f8e4m3 0x31
+    ret f8e4m3 0xQ31
+}
+
+define <4 x f8e4m3> @check_fixed_vector_f8e4m3() {
+; ASSEM-DISASS: ret <4 x f8e4m3> %tmp
+  %tmp = fadd <4 x f8e4m3> undef, undef
+  ret <4 x f8e4m3> %tmp
+}
+
+define <vscale x 4 x f8e4m3> @check_vector_f8e4m3() {
+; ASSEM-DISASS: ret <vscale x 4 x f8e4m3> %tmp
+  %tmp = fadd <vscale x 4 x f8e4m3> undef, undef
+  ret <vscale x 4 x f8e4m3> %tmp
+}
+
+define f8e4m3 @check_f8e4m3_constprop() {
+  %tmp = fadd f8e4m3 0xQ40, 0xQ40
+; OPT: 0xQ48
+  ret f8e4m3 %tmp
+}
+
+define f8e5m2 @check_f8e5m2(f8e5m2 %A) {
+; ASSEM-DISASS: ret f8e5m2 %A
+    ret f8e5m2 %A
+}
+
+define f8e5m2 @check_f8e5m2_literal() {
+; ASSEM-DISASS: ret f8e5m2 0x31
+    ret f8e5m2 0xQ31
+}
+
+define <4 x f8e5m2> @check_fixed_vector_f8e5m2() {
+; ASSEM-DISASS: ret <4 x f8e5m2> %tmp
+  %tmp = fadd <4 x f8e5m2> undef, undef
+  ret <4 x f8e5m2> %tmp
+}
+
+define <vscale x 4 x f8e5m2> @check_vector_f8e5m2() {
+; ASSEM-DISASS: ret <vscale x 4 x f8e5m2> %tmp
+  %tmp = fadd <vscale x 4 x f8e5m2> undef, undef
+  ret <vscale x 4 x f8e5m2> %tmp
+}
+
+define f8e5m2 @check_f8e5m2_constprop() {
+  %tmp = fadd f8e5m2 0xQ40, 0xQ40
+; OPT: 0xQ44
+  ret f8e5m2 %tmp
+}
+

llvm/tools/llvm-c-test/echo.cpp

LLVMTypeRef Clone(LLVMValueRef Src) {
     return Clone(LLVMTypeOf(Src));
   }
 
   LLVMTypeRef Clone(LLVMTypeRef Src) {
     LLVMTypeKind Kind = LLVMGetTypeKind(Src);
     switch (Kind) {
       case LLVMVoidTypeKind:
         return LLVMVoidTypeInContext(Ctx);
+      case LLVMFloatE4M3TypeKind:
+        return LLVMFloatE4M3TypeInContext(Ctx);
+      case LLVMFloatE5M2TypeKind:
+        return LLVMFloatE5M2TypeInContext(Ctx);
       case LLVMHalfTypeKind:
         return LLVMHalfTypeInContext(Ctx);
       case LLVMBFloatTypeKind:
         return LLVMHalfTypeInContext(Ctx);
       case LLVMFloatTypeKind:
         return LLVMFloatTypeInContext(Ctx);
       case LLVMDoubleTypeKind:
         return LLVMDoubleTypeInContext(Ctx);
       case LLVMX86_FP80TypeKind:
         return LLVMX86FP80TypeInContext(Ctx);
       case LLVMFP128TypeKind:
         return LLVMFP128TypeInContext(Ctx);