Diff 511414

llvm/include/llvm/CodeGen/ValueTypes.td

	//===- ValueTypes.td - ValueType definitions ---------------- tablegen --===//			//===- ValueTypes.td - ValueType definitions ---------------- tablegen --===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	//			//
	// Value types - These values correspond to the register types defined in the			// Value types - These values correspond to the register types defined in the
	// MachineValueTypes.h file. If you update anything here, you must update it			// MachineValueTypes.h file. If you update anything here, you must update it
	// there as well!			// there as well!
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	class ValueType<int size, int value> {			class ValueType<int size, int value> {
	string Namespace = "MVT";			string Namespace = "MVT";
				string LLVMName = NAME;
	int Size = size;			int Size = size;
	int Value = value;			int Value = value;
				int nElem = 1;
				ValueType ElementType = ?;
				int isOverloaded = false;
				int isInteger = false;
				int isFP = false;
				int isVector = false;
				int isScalable = false;
	}			}

	def OtherVT : ValueType<0, 1>; // "Other" value			class VTAny<int value> : ValueType<0, value> {
	def i1 : ValueType<1, 2>; // One bit boolean value			let isOverloaded = true;
	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			class VTInt<int size, int value>
	def i16 : ValueType<16, 6>; // 16-bit integer value			: ValueType<size, value> {
	def i32 : ValueType<32, 7>; // 32-bit integer value			let isInteger = true;
	def i64 : ValueType<64, 8>; // 64-bit integer value			}
	def i128 : ValueType<128, 9>; // 128-bit integer value
				class VTFP<int size, int value>
	def bf16 : ValueType<16, 10>; // 16-bit brain floating point value			: ValueType<size, value> {
	def f16 : ValueType<16, 11>; // 16-bit floating point value			let isFP = true;
	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			class VTVec<int nelem, ValueType elt, int value>
	def f128 : ValueType<128, 15>; // 128-bit floating point value			: ValueType<!mul(nelem, elt.Size), value> {
	def ppcf128 : ValueType<128, 16>; // PPC 128-bit floating point value			let nElem = nelem;
				let ElementType = elt;
	def v1i1 : ValueType<1, 17>; // 1 x i1 vector value			let isInteger = elt.isInteger;
	def v2i1 : ValueType<2, 18>; // 2 x i1 vector value			let isFP = elt.isFP;
	def v4i1 : ValueType<4, 19>; // 4 x i1 vector value			let isVector = true;
	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			class VTScalableVec<int nelem, ValueType elt, int value>
	def v64i1 : ValueType<64, 23>; // 64 x i1 vector value			: VTVec<nelem, elt, value> {
	def v128i1 : ValueType<128, 24>; // 128 x i1 vector value			let isScalable = true;
	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			defset list<ValueType> ValueTypes = {
	def v2048i1 : ValueType<2048, 28>; // 2048 x i1 vector value
				def OtherVT : ValueType<0, 1> { // "Other" value
	def v128i2 : ValueType<256, 29>; // 128 x i2 vector value			let LLVMName = "Other";
	def v256i2 : ValueType<512, 30>; // 256 x i2 vector value			}

	def v64i4 : ValueType<256, 31>; // 64 x i4 vector value			def i1 : VTInt<1, 2>; // One bit boolean value
	def v128i4 : ValueType<512, 32>; // 128 x i4 vector value			def i2 : VTInt<2, 3>; // 2-bit integer value
				def i4 : VTInt<4, 4>; // 4-bit integer value
	def v1i8 : ValueType<8, 33>; // 1 x i8 vector value			def i8 : VTInt<8, 5>; // 8-bit integer value
	def v2i8 : ValueType<16, 34>; // 2 x i8 vector value			def i16 : VTInt<16, 6>; // 16-bit integer value
	def v4i8 : ValueType<32, 35>; // 4 x i8 vector value			def i32 : VTInt<32, 7>; // 32-bit integer value
	def v8i8 : ValueType<64, 36>; // 8 x i8 vector value			def i64 : VTInt<64, 8>; // 64-bit integer value
	def v16i8 : ValueType<128, 37>; // 16 x i8 vector value			def i128 : VTInt<128, 9>; // 128-bit integer value
	def v32i8 : ValueType<256, 38>; // 32 x i8 vector value
	def v64i8 : ValueType<512, 39>; // 64 x i8 vector value			def bf16 : VTFP<16, 10>; // 16-bit brain floating point value
	def v128i8 : ValueType<1024, 40>; // 128 x i8 vector value			def f16 : VTFP<16, 11>; // 16-bit floating point value
	def v256i8 : ValueType<2048, 41>; // 256 x i8 vector value			def f32 : VTFP<32, 12>; // 32-bit floating point value
	def v512i8 : ValueType<4096, 42>; // 512 x i8 vector value			def f64 : VTFP<64, 13>; // 64-bit floating point value
	def v1024i8 : ValueType<8192, 43>; // 1024 x i8 vector value			def f80 : VTFP<80, 14>; // 80-bit floating point value
				def f128 : VTFP<128, 15>; // 128-bit floating point value
	def v1i16 : ValueType<16, 44>; // 1 x i16 vector value			def ppcf128 : VTFP<128, 16>; // PPC 128-bit floating point value
	def v2i16 : ValueType<32, 45>; // 2 x i16 vector value
	def v3i16 : ValueType<48, 46>; // 3 x i16 vector value			def v1i1 : VTVec<1, i1, 17>; // 1 x i1 vector value
	def v4i16 : ValueType<64, 47>; // 4 x i16 vector value			def v2i1 : VTVec<2, i1, 18>; // 2 x i1 vector value
	def v8i16 : ValueType<128, 48>; // 8 x i16 vector value			def v4i1 : VTVec<4, i1, 19>; // 4 x i1 vector value
	def v16i16 : ValueType<256, 49>; // 16 x i16 vector value			def v8i1 : VTVec<8, i1, 20>; // 8 x i1 vector value
	def v32i16 : ValueType<512, 50>; // 32 x i16 vector value			def v16i1 : VTVec<16, i1, 21>; // 16 x i1 vector value
	def v64i16 : ValueType<1024, 51>; // 64 x i16 vector value			def v32i1 : VTVec<32, i1, 22>; // 32 x i1 vector value
	def v128i16 : ValueType<2048, 52>; // 128 x i16 vector value			def v64i1 : VTVec<64, i1, 23>; // 64 x i1 vector value
	def v256i16 : ValueType<4096, 53>; // 256 x i16 vector value			def v128i1 : VTVec<128, i1, 24>; // 128 x i1 vector value
	def v512i16 : ValueType<8192, 54>; // 512 x i16 vector value			def v256i1 : VTVec<256, i1, 25>; // 256 x i1 vector value
				def v512i1 : VTVec<512, i1, 26>; // 512 x i1 vector value
	def v1i32 : ValueType<32, 55>; // 1 x i32 vector value			def v1024i1 : VTVec<1024, i1, 27>; // 1024 x i1 vector value
	def v2i32 : ValueType<64, 56>; // 2 x i32 vector value			def v2048i1 : VTVec<2048, i1, 28>; // 2048 x i1 vector value
	def v3i32 : ValueType<96, 57>; // 3 x i32 vector value
	def v4i32 : ValueType<128, 58>; // 4 x i32 vector value			def v128i2 : VTVec<128, i2, 29>; // 128 x i2 vector value
	def v5i32 : ValueType<160, 59>; // 5 x i32 vector value			def v256i2 : VTVec<256, i2, 30>; // 256 x i2 vector value
	def v6i32 : ValueType<192, 60>; // 6 x f32 vector value
	def v7i32 : ValueType<224, 61>; // 7 x f32 vector value			def v64i4 : VTVec<64, i4, 31>; // 64 x i4 vector value
	def v8i32 : ValueType<256, 62>; // 8 x i32 vector value			def v128i4 : VTVec<128, i4, 32>; // 128 x i4 vector value
	def v9i32 : ValueType<288, 63>; // 9 x i32 vector value
	def v10i32 : ValueType<320, 64>; // 10 x i32 vector value			def v1i8 : VTVec<1, i8, 33>; // 1 x i8 vector value
	def v11i32 : ValueType<352, 65>; // 11 x i32 vector value			def v2i8 : VTVec<2, i8, 34>; // 2 x i8 vector value
	def v12i32 : ValueType<384, 66>; // 12 x i32 vector value			def v4i8 : VTVec<4, i8, 35>; // 4 x i8 vector value
	def v16i32 : ValueType<512, 67>; // 16 x i32 vector value			def v8i8 : VTVec<8, i8, 36>; // 8 x i8 vector value
	def v32i32 : ValueType<1024, 68>; // 32 x i32 vector value			def v16i8 : VTVec<16, i8, 37>; // 16 x i8 vector value
	def v64i32 : ValueType<2048, 69>; // 64 x i32 vector value			def v32i8 : VTVec<32, i8, 38>; // 32 x i8 vector value
	def v128i32 : ValueType<4096, 70>; // 128 x i32 vector value			def v64i8 : VTVec<64, i8, 39>; // 64 x i8 vector value
	def v256i32 : ValueType<8192, 71>; // 256 x i32 vector value			def v128i8 : VTVec<128, i8, 40>; // 128 x i8 vector value
	def v512i32 : ValueType<16384, 72>; // 512 x i32 vector value			def v256i8 : VTVec<256, i8, 41>; // 256 x i8 vector value
	def v1024i32 : ValueType<32768, 73>; // 1024 x i32 vector value			def v512i8 : VTVec<512, i8, 42>; // 512 x i8 vector value
	def v2048i32 : ValueType<65536, 74>; // 2048 x i32 vector value			def v1024i8 : VTVec<1024, i8, 43>; // 1024 x i8 vector value

	def v1i64 : ValueType<64, 75>; // 1 x i64 vector value			def v1i16 : VTVec<1, i16, 44>; // 1 x i16 vector value
	def v2i64 : ValueType<128, 76>; // 2 x i64 vector value			def v2i16 : VTVec<2, i16, 45>; // 2 x i16 vector value
	def v3i64 : ValueType<192, 77>; // 3 x i64 vector value			def v3i16 : VTVec<3, i16, 46>; // 3 x i16 vector value
	def v4i64 : ValueType<256, 78>; // 4 x i64 vector value			def v4i16 : VTVec<4, i16, 47>; // 4 x i16 vector value
	def v8i64 : ValueType<512, 79>; // 8 x i64 vector value			def v8i16 : VTVec<8, i16, 48>; // 8 x i16 vector value
	def v16i64 : ValueType<1024, 80>; // 16 x i64 vector value			def v16i16 : VTVec<16, i16, 49>; // 16 x i16 vector value
	def v32i64 : ValueType<2048, 81>; // 32 x i64 vector value			def v32i16 : VTVec<32, i16, 50>; // 32 x i16 vector value
	def v64i64 : ValueType<4096, 82>; // 64 x i64 vector value			def v64i16 : VTVec<64, i16, 51>; // 64 x i16 vector value
	def v128i64 : ValueType<8192, 83>; // 128 x i64 vector value			def v128i16 : VTVec<128, i16, 52>; // 128 x i16 vector value
	def v256i64 : ValueType<16384, 84>; // 256 x i64 vector value			def v256i16 : VTVec<256, i16, 53>; // 256 x i16 vector value
				def v512i16 : VTVec<512, i16, 54>; // 512 x i16 vector value
	def v1i128 : ValueType<128, 85>; // 1 x i128 vector value
				def v1i32 : VTVec<1, i32, 55>; // 1 x i32 vector value
	def v1f16 : ValueType<16, 86>; // 1 x f16 vector value			def v2i32 : VTVec<2, i32, 56>; // 2 x i32 vector value
	def v2f16 : ValueType<32, 87>; // 2 x f16 vector value			def v3i32 : VTVec<3, i32, 57>; // 3 x i32 vector value
	def v3f16 : ValueType<48, 88>; // 3 x f16 vector value			def v4i32 : VTVec<4, i32, 58>; // 4 x i32 vector value
	def v4f16 : ValueType<64, 89>; // 4 x f16 vector value			def v5i32 : VTVec<5, i32, 59>; // 5 x i32 vector value
	def v8f16 : ValueType<128, 90>; // 8 x f16 vector value			def v6i32 : VTVec<6, i32, 60>; // 6 x f32 vector value
	def v16f16 : ValueType<256, 91>; // 16 x f16 vector value			def v7i32 : VTVec<7, i32, 61>; // 7 x f32 vector value
	def v32f16 : ValueType<512, 92>; // 32 x f16 vector value			def v8i32 : VTVec<8, i32, 62>; // 8 x i32 vector value
	def v64f16 : ValueType<1024, 93>; // 64 x f16 vector value			def v9i32 : VTVec<9, i32, 63>; // 9 x i32 vector value
	def v128f16 : ValueType<2048, 94>; // 128 x f16 vector value			def v10i32 : VTVec<10, i32, 64>; // 10 x i32 vector value
	def v256f16 : ValueType<4096, 95>; // 256 x f16 vector value			def v11i32 : VTVec<11, i32, 65>; // 11 x i32 vector value
	def v512f16 : ValueType<8192, 96>; // 512 x f16 vector value			def v12i32 : VTVec<12, i32, 66>; // 12 x i32 vector value
				def v16i32 : VTVec<16, i32, 67>; // 16 x i32 vector value
	def v2bf16 : ValueType<32, 97>; // 2 x bf16 vector value			def v32i32 : VTVec<32, i32, 68>; // 32 x i32 vector value
	def v3bf16 : ValueType<48, 98>; // 3 x bf16 vector value			def v64i32 : VTVec<64, i32, 69>; // 64 x i32 vector value
	def v4bf16 : ValueType<64, 99>; // 4 x bf16 vector value			def v128i32 : VTVec<128, i32, 70>; // 128 x i32 vector value
	def v8bf16 : ValueType<128, 100>; // 8 x bf16 vector value			def v256i32 : VTVec<256, i32, 71>; // 256 x i32 vector value
	def v16bf16 : ValueType<256, 101>; // 16 x bf16 vector value			def v512i32 : VTVec<512, i32, 72>; // 512 x i32 vector value
	def v32bf16 : ValueType<512, 102>; // 32 x bf16 vector value			def v1024i32 : VTVec<1024, i32, 73>; // 1024 x i32 vector value
	def v64bf16 : ValueType<1024, 103>; // 64 x bf16 vector value			def v2048i32 : VTVec<2048, i32, 74>; // 2048 x i32 vector value
	def v128bf16 : ValueType<2048, 104>; // 128 x bf16 vector value
				def v1i64 : VTVec<1, i64, 75>; // 1 x i64 vector value
	def v1f32 : ValueType<32, 105>; // 1 x f32 vector value			def v2i64 : VTVec<2, i64, 76>; // 2 x i64 vector value
	def v2f32 : ValueType<64, 106>; // 2 x f32 vector value			def v3i64 : VTVec<3, i64, 77>; // 3 x i64 vector value
	def v3f32 : ValueType<96, 107>; // 3 x f32 vector value			def v4i64 : VTVec<4, i64, 78>; // 4 x i64 vector value
	def v4f32 : ValueType<128, 108>; // 4 x f32 vector value			def v8i64 : VTVec<8, i64, 79>; // 8 x i64 vector value
	def v5f32 : ValueType<160, 109>; // 5 x f32 vector value			def v16i64 : VTVec<16, i64, 80>; // 16 x i64 vector value
	def v6f32 : ValueType<192, 110>; // 6 x f32 vector value			def v32i64 : VTVec<32, i64, 81>; // 32 x i64 vector value
	def v7f32 : ValueType<224, 111>; // 7 x f32 vector value			def v64i64 : VTVec<64, i64, 82>; // 64 x i64 vector value
	def v8f32 : ValueType<256, 112>; // 8 x f32 vector value			def v128i64 : VTVec<128, i64, 83>; // 128 x i64 vector value
	def v9f32 : ValueType<288, 113>; // 9 x f32 vector value			def v256i64 : VTVec<256, i64, 84>; // 256 x i64 vector value
	def v10f32 : ValueType<320, 114>; // 10 x f32 vector value
	def v11f32 : ValueType<352, 115>; // 11 x f32 vector value			def v1i128 : VTVec<1, i128, 85>; // 1 x i128 vector value
	def v12f32 : ValueType<384, 116>; // 12 x f32 vector value
	def v16f32 : ValueType<512, 117>; // 16 x f32 vector value			def v1f16 : VTVec<1, f16, 86>; // 1 x f16 vector value
	def v32f32 : ValueType<1024, 118>; // 32 x f32 vector value			def v2f16 : VTVec<2, f16, 87>; // 2 x f16 vector value
	def v64f32 : ValueType<2048, 119>; // 64 x f32 vector value			def v3f16 : VTVec<3, f16, 88>; // 3 x f16 vector value
	def v128f32 : ValueType<4096, 120>; // 128 x f32 vector value			def v4f16 : VTVec<4, f16, 89>; // 4 x f16 vector value
	def v256f32 : ValueType<8192, 121>; // 256 x f32 vector value			def v8f16 : VTVec<8, f16, 90>; // 8 x f16 vector value
	def v512f32 : ValueType<16384, 122>; // 512 x f32 vector value			def v16f16 : VTVec<16, f16, 91>; // 16 x f16 vector value
	def v1024f32 : ValueType<32768, 123>; // 1024 x f32 vector value			def v32f16 : VTVec<32, f16, 92>; // 32 x f16 vector value
	def v2048f32 : ValueType<65536, 124>; // 2048 x f32 vector value			def v64f16 : VTVec<64, f16, 93>; // 64 x f16 vector value
				def v128f16 : VTVec<128, f16, 94>; // 128 x f16 vector value
	def v1f64 : ValueType<64, 125>; // 1 x f64 vector value			def v256f16 : VTVec<256, f16, 95>; // 256 x f16 vector value
	def v2f64 : ValueType<128, 126>; // 2 x f64 vector value			def v512f16 : VTVec<512, f16, 96>; // 512 x f16 vector value
	def v3f64 : ValueType<192, 127>; // 3 x f64 vector value
	def v4f64 : ValueType<256, 128>; // 4 x f64 vector value			def v2bf16 : VTVec<2, bf16, 97>; // 2 x bf16 vector value
	def v8f64 : ValueType<512, 129>; // 8 x f64 vector value			def v3bf16 : VTVec<3, bf16, 98>; // 3 x bf16 vector value
	def v16f64 : ValueType<1024, 130>; // 16 x f64 vector value			def v4bf16 : VTVec<4, bf16, 99>; // 4 x bf16 vector value
	def v32f64 : ValueType<2048, 131>; // 32 x f64 vector value			def v8bf16 : VTVec<8, bf16, 100>; // 8 x bf16 vector value
	def v64f64 : ValueType<4096, 132>; // 64 x f64 vector value			def v16bf16 : VTVec<16, bf16, 101>; // 16 x bf16 vector value
	def v128f64 : ValueType<8192, 133>; // 128 x f64 vector value			def v32bf16 : VTVec<32, bf16, 102>; // 32 x bf16 vector value
	def v256f64 : ValueType<16384, 134>; // 256 x f64 vector value			def v64bf16 : VTVec<64, bf16, 103>; // 64 x bf16 vector value
				def v128bf16 : VTVec<128, bf16, 104>; // 128 x bf16 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 v1f32 : VTVec<1, f32, 105>; // 1 x f32 vector value
	def nxv4i1 : ValueType<4, 137>; // n x 4 x i1 vector value			def v2f32 : VTVec<2, f32, 106>; // 2 x f32 vector value
	def nxv8i1 : ValueType<8, 138>; // n x 8 x i1 vector value			def v3f32 : VTVec<3, f32, 107>; // 3 x f32 vector value
	def nxv16i1 : ValueType<16, 139>; // n x 16 x i1 vector value			def v4f32 : VTVec<4, f32, 108>; // 4 x f32 vector value
	def nxv32i1 : ValueType<32, 140>; // n x 32 x i1 vector value			def v5f32 : VTVec<5, f32, 109>; // 5 x f32 vector value
	def nxv64i1 : ValueType<64, 141>; // n x 64 x i1 vector value			def v6f32 : VTVec<6, f32, 110>; // 6 x f32 vector value
				def v7f32 : VTVec<7, f32, 111>; // 7 x f32 vector value
	def nxv1i8 : ValueType<8, 142>; // n x 1 x i8 vector value			def v8f32 : VTVec<8, f32, 112>; // 8 x f32 vector value
	def nxv2i8 : ValueType<16, 143>; // n x 2 x i8 vector value			def v9f32 : VTVec<9, f32, 113>; // 9 x f32 vector value
	def nxv4i8 : ValueType<32, 144>; // n x 4 x i8 vector value			def v10f32 : VTVec<10, f32, 114>; // 10 x f32 vector value
	def nxv8i8 : ValueType<64, 145>; // n x 8 x i8 vector value			def v11f32 : VTVec<11, f32, 115>; // 11 x f32 vector value
	def nxv16i8 : ValueType<128, 146>; // n x 16 x i8 vector value			def v12f32 : VTVec<12, f32, 116>; // 12 x f32 vector value
	def nxv32i8 : ValueType<256, 147>; // n x 32 x i8 vector value			def v16f32 : VTVec<16, f32, 117>; // 16 x f32 vector value
	def nxv64i8 : ValueType<512, 148>; // n x 64 x i8 vector value			def v32f32 : VTVec<32, f32, 118>; // 32 x f32 vector value
				def v64f32 : VTVec<64, f32, 119>; // 64 x f32 vector value
	def nxv1i16 : ValueType<16, 149>; // n x 1 x i16 vector value			def v128f32 : VTVec<128, f32, 120>; // 128 x f32 vector value
	def nxv2i16 : ValueType<32, 150>; // n x 2 x i16 vector value			def v256f32 : VTVec<256, f32, 121>; // 256 x f32 vector value
	def nxv4i16 : ValueType<64, 151>; // n x 4 x i16 vector value			def v512f32 : VTVec<512, f32, 122>; // 512 x f32 vector value
	def nxv8i16 : ValueType<128, 152>; // n x 8 x i16 vector value			def v1024f32 : VTVec<1024, f32, 123>; // 1024 x f32 vector value
	def nxv16i16 : ValueType<256, 153>; // n x 16 x i16 vector value			def v2048f32 : VTVec<2048, f32, 124>; // 2048 x f32 vector value
	def nxv32i16 : ValueType<512, 154>; // n x 32 x i16 vector value
				def v1f64 : VTVec<1, f64, 125>; // 1 x f64 vector value
	def nxv1i32 : ValueType<32, 155>; // n x 1 x i32 vector value			def v2f64 : VTVec<2, f64, 126>; // 2 x f64 vector value
	def nxv2i32 : ValueType<64, 156>; // n x 2 x i32 vector value			def v3f64 : VTVec<3, f64, 127>; // 3 x f64 vector value
	def nxv4i32 : ValueType<128, 157>; // n x 4 x i32 vector value			def v4f64 : VTVec<4, f64, 128>; // 4 x f64 vector value
	def nxv8i32 : ValueType<256, 158>; // n x 8 x i32 vector value			def v8f64 : VTVec<8, f64, 129>; // 8 x f64 vector value
	def nxv16i32 : ValueType<512, 159>; // n x 16 x i32 vector value			def v16f64 : VTVec<16, f64, 130>; // 16 x f64 vector value
	def nxv32i32 : ValueType<1024, 160>; // n x 32 x i32 vector value			def v32f64 : VTVec<32, f64, 131>; // 32 x f64 vector value
				def v64f64 : VTVec<64, f64, 132>; // 64 x f64 vector value
	def nxv1i64 : ValueType<64, 161>; // n x 1 x i64 vector value			def v128f64 : VTVec<128, f64, 133>; // 128 x f64 vector value
	def nxv2i64 : ValueType<128, 162>; // n x 2 x i64 vector value			def v256f64 : VTVec<256, f64, 134>; // 256 x f64 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 nxv1i1 : VTScalableVec<1, i1, 135>; // n x 1 x i1 vector value
	def nxv16i64 : ValueType<1024, 165>; // n x 16 x i64 vector value			def nxv2i1 : VTScalableVec<2, i1, 136>; // n x 2 x i1 vector value
	def nxv32i64 : ValueType<2048, 166>; // n x 32 x i64 vector value			def nxv4i1 : VTScalableVec<4, i1, 137>; // n x 4 x i1 vector value
				def nxv8i1 : VTScalableVec<8, i1, 138>; // n x 8 x i1 vector value
	def nxv1f16 : ValueType<16, 167>; // n x 1 x f16 vector value			def nxv16i1 : VTScalableVec<16, i1, 139>; // n x 16 x i1 vector value
	def nxv2f16 : ValueType<32, 168>; // n x 2 x f16 vector value			def nxv32i1 : VTScalableVec<32, i1, 140>; // n x 32 x i1 vector value
	def nxv4f16 : ValueType<64, 169>; // n x 4 x f16 vector value			def nxv64i1 : VTScalableVec<64, i1, 141>; // n x 64 x i1 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 nxv1i8 : VTScalableVec<1, i8, 142>; // n x 1 x i8 vector value
	def nxv32f16 : ValueType<512, 172>; // n x 32 x f16 vector value			def nxv2i8 : VTScalableVec<2, i8, 143>; // n x 2 x i8 vector value
				def nxv4i8 : VTScalableVec<4, i8, 144>; // n x 4 x i8 vector value
	def nxv1bf16 : ValueType<16, 173>; // n x 1 x bf16 vector value			def nxv8i8 : VTScalableVec<8, i8, 145>; // n x 8 x i8 vector value
	def nxv2bf16 : ValueType<32, 174>; // n x 2 x bf16 vector value			def nxv16i8 : VTScalableVec<16, i8, 146>; // n x 16 x i8 vector value
	def nxv4bf16 : ValueType<64, 175>; // n x 4 x bf16 vector value			def nxv32i8 : VTScalableVec<32, i8, 147>; // n x 32 x i8 vector value
	def nxv8bf16 : ValueType<128, 176>; // n x 8 x bf16 vector value			def nxv64i8 : VTScalableVec<64, i8, 148>; // n x 64 x i8 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 nxv1i16 : VTScalableVec<1, i16, 149>; // n x 1 x i16 vector value
				def nxv2i16 : VTScalableVec<2, i16, 150>; // n x 2 x i16 vector value
	def nxv1f32 : ValueType<32, 179>; // n x 1 x f32 vector value			def nxv4i16 : VTScalableVec<4, i16, 151>; // n x 4 x i16 vector value
	def nxv2f32 : ValueType<64, 180>; // n x 2 x f32 vector value			def nxv8i16 : VTScalableVec<8, i16, 152>; // n x 8 x i16 vector value
	def nxv4f32 : ValueType<128, 181>; // n x 4 x f32 vector value			def nxv16i16 : VTScalableVec<16, i16, 153>; // n x 16 x i16 vector value
	def nxv8f32 : ValueType<256, 182>; // n x 8 x f32 vector value			def nxv32i16 : VTScalableVec<32, i16, 154>; // n x 32 x i16 vector value
	def nxv16f32 : ValueType<512, 183>; // n x 16 x f32 vector value
				def nxv1i32 : VTScalableVec<1, i32, 155>; // n x 1 x i32 vector value
	def nxv1f64 : ValueType<64, 184>; // n x 1 x f64 vector value			def nxv2i32 : VTScalableVec<2, i32, 156>; // n x 2 x i32 vector value
	def nxv2f64 : ValueType<128, 185>; // n x 2 x f64 vector value			def nxv4i32 : VTScalableVec<4, i32, 157>; // n x 4 x i32 vector value
	def nxv4f64 : ValueType<256, 186>; // n x 4 x f64 vector value			def nxv8i32 : VTScalableVec<8, i32, 158>; // n x 8 x i32 vector value
	def nxv8f64 : ValueType<512, 187>; // n x 8 x f64 vector value			def nxv16i32 : VTScalableVec<16, i32, 159>; // n x 16 x i32 vector value
				def nxv32i32 : VTScalableVec<32, i32, 160>; // n x 32 x i32 vector value

				def nxv1i64 : VTScalableVec<1, i64, 161>; // n x 1 x i64 vector value
				def nxv2i64 : VTScalableVec<2, i64, 162>; // n x 2 x i64 vector value
				def nxv4i64 : VTScalableVec<4, i64, 163>; // n x 4 x i64 vector value
				def nxv8i64 : VTScalableVec<8, i64, 164>; // n x 8 x i64 vector value
				def nxv16i64 : VTScalableVec<16, i64, 165>; // n x 16 x i64 vector value
				def nxv32i64 : VTScalableVec<32, i64, 166>; // n x 32 x i64 vector value

				def nxv1f16 : VTScalableVec<1, f16, 167>; // n x 1 x f16 vector value
				def nxv2f16 : VTScalableVec<2, f16, 168>; // n x 2 x f16 vector value
				def nxv4f16 : VTScalableVec<4, f16, 169>; // n x 4 x f16 vector value
				def nxv8f16 : VTScalableVec<8, f16, 170>; // n x 8 x f16 vector value
				def nxv16f16 : VTScalableVec<16, f16, 171>; // n x 16 x f16 vector value
				def nxv32f16 : VTScalableVec<32, f16, 172>; // n x 32 x f16 vector value

				def nxv1bf16 : VTScalableVec<1, bf16, 173>; // n x 1 x bf16 vector value
				def nxv2bf16 : VTScalableVec<2, bf16, 174>; // n x 2 x bf16 vector value
				def nxv4bf16 : VTScalableVec<4, bf16, 175>; // n x 4 x bf16 vector value
				def nxv8bf16 : VTScalableVec<8, bf16, 176>; // n x 8 x bf16 vector value
				def nxv16bf16 : VTScalableVec<16, bf16, 177>; // n x 16 x bf16 vector value
				def nxv32bf16 : VTScalableVec<32, bf16, 178>; // n x 32 x bf16 vector value

				def nxv1f32 : VTScalableVec<1, f32, 179>; // n x 1 x f32 vector value
				def nxv2f32 : VTScalableVec<2, f32, 180>; // n x 2 x f32 vector value
				def nxv4f32 : VTScalableVec<4, f32, 181>; // n x 4 x f32 vector value
				def nxv8f32 : VTScalableVec<8, f32, 182>; // n x 8 x f32 vector value
				def nxv16f32 : VTScalableVec<16, f32, 183>; // n x 16 x f32 vector value

				def nxv1f64 : VTScalableVec<1, f64, 184>; // n x 1 x f64 vector value
				def nxv2f64 : VTScalableVec<2, f64, 185>; // n x 2 x f64 vector value
				def nxv4f64 : VTScalableVec<4, f64, 186>; // n x 4 x f64 vector value
				def nxv8f64 : VTScalableVec<8, f64, 187>; // n x 8 x f64 vector value

	def x86mmx : ValueType<64, 188>; // X86 MMX value			def x86mmx : ValueType<64, 188>; // X86 MMX value
	def FlagVT : ValueType<0, 189>; // Pre-RA sched glue			def FlagVT : ValueType<0, 189> { // Pre-RA sched glue
				let LLVMName = "Glue";
				}
	def isVoid : ValueType<0, 190>; // Produces no value			def isVoid : ValueType<0, 190>; // Produces no value
	def untyped : ValueType<8, 191>; // Produces an untyped value			def untyped : ValueType<8, 191> { // Produces an untyped value
				let LLVMName = "Untyped";
				}
	def funcref : ValueType<0, 192>; // WebAssembly's funcref type			def funcref : ValueType<0, 192>; // WebAssembly's funcref type
	def externref : ValueType<0, 193>; // WebAssembly's externref type			def externref : ValueType<0, 193>; // WebAssembly's externref type
	def x86amx : ValueType<8192, 194>; // X86 AMX value			def x86amx : ValueType<8192, 194>; // X86 AMX value
	def i64x8 : ValueType<512, 195>; // 8 Consecutive GPRs (AArch64)			def i64x8 : ValueType<512, 195>; // 8 Consecutive GPRs (AArch64)
	def aarch64svcount			def aarch64svcount
	: ValueType<16, 196>; // AArch64 predicate-as-counter			: ValueType<16, 196>; // AArch64 predicate-as-counter
	def spirvbuiltin : ValueType<0, 197>; // SPIR-V's builtin type			def spirvbuiltin : ValueType<0, 197>; // SPIR-V's builtin type

	def token : ValueType<0, 248>; // TokenTy			def token : ValueType<0, 248>; // TokenTy
	def MetadataVT : ValueType<0, 249>; // Metadata			def MetadataVT : ValueType<0, 249> { // Metadata
				let LLVMName = "Metadata";
				}

	// Pseudo valuetype mapped to the current pointer size to any address space.			// Pseudo valuetype mapped to the current pointer size to any address space.
	// Should only be used in TableGen.			// Should only be used in TableGen.
	def iPTRAny : ValueType<0, 250>;			def iPTRAny : VTAny<250>;

	// Pseudo valuetype to represent "vector of any size"			// Pseudo valuetype to represent "vector of any size"
	def vAny : ValueType<0, 251>;			def vAny : VTAny<251>;

	// Pseudo valuetype to represent "float of any format"			// Pseudo valuetype to represent "float of any format"
	def fAny : ValueType<0, 252>;			def fAny : VTAny<252>;

	// Pseudo valuetype to represent "integer of any bit width"			// Pseudo valuetype to represent "integer of any bit width"
	def iAny : ValueType<0, 253>;			def iAny : VTAny<253>;

	// Pseudo valuetype mapped to the current pointer size.			// Pseudo valuetype mapped to the current pointer size.
	def iPTR : ValueType<0, 254>;			def iPTR : ValueType<0, 254>;

	// Pseudo valuetype to represent "any type of any size".			// Pseudo valuetype to represent "any type of any size".
	def Any : ValueType<0, 255>;			def Any : VTAny<255>;

				} // end defset ValueTypes

	/// This class is for targets that want to use pointer types in patterns			/// This class is for targets that want to use pointer types in patterns
	/// with the GlobalISelEmitter. Targets must define their own pointer			/// with the GlobalISelEmitter. Targets must define their own pointer
	/// derived from this class. The scalar argument should be an			/// derived from this class. The scalar argument should be an
	/// integer type with the same bit size as the pointer.			/// integer type with the same bit size as the pointer.
	/// e.g. def p0 : PtrValueType <i64, 0>;			/// e.g. def p0 : PtrValueType <i64, 0>;

	class PtrValueType <ValueType scalar, int addrspace> :			class PtrValueType <ValueType scalar, int addrspace> :
	ValueType<scalar.Size, scalar.Value> {			ValueType<scalar.Size, scalar.Value> {
	int AddrSpace = addrspace;			int AddrSpace = addrspace;
	}			}

llvm/include/llvm/IR/Intrinsics.td

	Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
	def IntrHasSideEffects : IntrinsicProperty;			def IntrHasSideEffects : IntrinsicProperty;

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	// Types used by intrinsics.			// Types used by intrinsics.
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	class LLVMType<ValueType vt> {			class LLVMType<ValueType vt> {
	ValueType VT = vt;			ValueType VT = vt;
	int isAny = false;			int isAny = vt.isOverloaded;
	}			}

	class LLVMQualPointerType<LLVMType elty, int addrspace>			class LLVMQualPointerType<LLVMType elty, int addrspace>
	: LLVMType<iPTR>{			: LLVMType<iPTR>{
	LLVMType ElTy = elty;			LLVMType ElTy = elty;
	int AddrSpace = addrspace;			int AddrSpace = addrspace;
	}			}

	class LLVMPointerType<LLVMType elty>			class LLVMPointerType<LLVMType elty>
	: LLVMQualPointerType<elty, 0>;			: LLVMQualPointerType<elty, 0>;

	class LLVMAnyPointerType<LLVMType elty>			class LLVMAnyPointerType<LLVMType elty>
	: LLVMType<iPTRAny>{			: LLVMType<iPTRAny>{
	LLVMType ElTy = elty;			LLVMType ElTy = elty;

	let isAny = true;			assert isAny, "iPTRAny should have isOverloaded";
				arsenmUnsubmitted Not Done Reply Inline Actions I didn't know tablegen had assertions arsenm: I didn't know tablegen had assertions
				chapuniAuthorUnsubmitted Done Reply Inline Actions I didn't know it was not older functionality. (Introduced in D93911) chapuni: I didn't know it was not older functionality. (Introduced in D93911)
	}			}

	// Match the type of another intrinsic parameter. Number is an index into the			// Match the type of another intrinsic parameter. Number is an index into the
	// list of overloaded types for the intrinsic, excluding all the fixed types.			// list of overloaded types for the intrinsic, excluding all the fixed types.
	// The Number value must refer to a previously listed type. For example:			// The Number value must refer to a previously listed type. For example:
	// Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_anyfloat_ty, LLVMMatchType<0>]>			// Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_anyfloat_ty, LLVMMatchType<0>]>
	// has two overloaded types, the 2nd and 3rd arguments. LLVMMatchType<0>			// has two overloaded types, the 2nd and 3rd arguments. LLVMMatchType<0>
	// refers to the first overloaded type, which is the 2nd argument.			// refers to the first overloaded type, which is the 2nd argument.
	Show All 33 Lines
	class LLVMSubdivide2VectorType<int num> : LLVMMatchType<num>;			class LLVMSubdivide2VectorType<int num> : LLVMMatchType<num>;
	class LLVMSubdivide4VectorType<int num> : LLVMMatchType<num>;			class LLVMSubdivide4VectorType<int num> : LLVMMatchType<num>;

	// Match the element count and bit width of another intrinsic parameter, but			// Match the element count and bit width of another intrinsic parameter, but
	// change the element type to an integer.			// change the element type to an integer.
	class LLVMVectorOfBitcastsToInt<int num> : LLVMMatchType<num>;			class LLVMVectorOfBitcastsToInt<int num> : LLVMMatchType<num>;

	def llvm_void_ty : LLVMType<isVoid>;			def llvm_void_ty : LLVMType<isVoid>;
	let isAny = true in {
	def llvm_any_ty : LLVMType<Any>;			def llvm_any_ty : LLVMType<Any>;
	def llvm_anyint_ty : LLVMType<iAny>;			def llvm_anyint_ty : LLVMType<iAny>;
	def llvm_anyfloat_ty : LLVMType<fAny>;			def llvm_anyfloat_ty : LLVMType<fAny>;
	def llvm_anyvector_ty : LLVMType<vAny>;			def llvm_anyvector_ty : LLVMType<vAny>;
	}
	def llvm_i1_ty : LLVMType<i1>;			def llvm_i1_ty : LLVMType<i1>;
	def llvm_i8_ty : LLVMType<i8>;			def llvm_i8_ty : LLVMType<i8>;
	def llvm_i16_ty : LLVMType<i16>;			def llvm_i16_ty : LLVMType<i16>;
	def llvm_i32_ty : LLVMType<i32>;			def llvm_i32_ty : LLVMType<i32>;
	def llvm_i64_ty : LLVMType<i64>;			def llvm_i64_ty : LLVMType<i64>;
	def llvm_i128_ty : LLVMType<i128>;			def llvm_i128_ty : LLVMType<i128>;
	def llvm_half_ty : LLVMType<f16>;			def llvm_half_ty : LLVMType<f16>;
	def llvm_bfloat_ty : LLVMType<bf16>;			def llvm_bfloat_ty : LLVMType<bf16>;
	▲ Show 20 Lines • Show All 1,953 Lines • Show Last 20 Lines

llvm/unittests/Support/MachineValueType.h

//===- MachineValueType.h - Machine-Level types ------------------ C++ --===//		//===- MachineValueType.h - Machine-Level types ------------------ C++ --===//
		Lint: Lint Inline Actions clang-format not found in user’s local PATH; not linting file. Lint: Lint: clang-format not found in user’s local PATH; not linting file.
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
//		//
Show All 24 Lines	namespace llvm::tmp {
/// type can be represented by an MVT.		/// type can be represented by an MVT.
class MVT {		class MVT {
public:		public:
enum SimpleValueType : uint8_t {		enum SimpleValueType : uint8_t {
// Simple value types that aren't explicitly part of this enumeration		// Simple value types that aren't explicitly part of this enumeration
// are considered extended value types.		// are considered extended value types.
INVALID_SIMPLE_VALUE_TYPE = 0,		INVALID_SIMPLE_VALUE_TYPE = 0,

#define GET_VT_ATTR(Ty, n, sz) Ty = n,		#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) Ty = n,
#define GET_VT_RANGES		#define GET_VT_RANGES
#include "GenVT.inc"		#include "GenVT.inc"
#undef GET_VT_ATTR		#undef GET_VT_ATTR
#undef GET_VT_RANGES		#undef GET_VT_RANGES

FIRST_INTEGER_VALUETYPE = i1,
LAST_INTEGER_VALUETYPE = i128,

FIRST_FP_VALUETYPE = bf16,
LAST_FP_VALUETYPE = ppcf128,

FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,

FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v1f16,
LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,

FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,

FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,

FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,

FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,

FIRST_VECTOR_VALUETYPE = v1i1,
LAST_VECTOR_VALUETYPE = nxv8f64,

VALUETYPE_SIZE = LAST_VALUETYPE + 1,		VALUETYPE_SIZE = LAST_VALUETYPE + 1,

// This is the current maximum for LAST_VALUETYPE.		// This is the current maximum for LAST_VALUETYPE.
// MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors		// MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
// This value must be a multiple of 32.		// This value must be a multiple of 32.
MAX_ALLOWED_VALUETYPE = 224,		MAX_ALLOWED_VALUETYPE = 224,
};		};

Show All 20 Lines	#undef GET_VT_RANGES

/// Return true if this is a valid simple valuetype.		/// Return true if this is a valid simple valuetype.
bool isValid() const {		bool isValid() const {
return (SimpleTy >= MVT::FIRST_VALUETYPE &&		return (SimpleTy >= MVT::FIRST_VALUETYPE &&
SimpleTy <= MVT::LAST_VALUETYPE);		SimpleTy <= MVT::LAST_VALUETYPE);
}		}

/// Return true if this is a FP or a vector FP type.		/// Return true if this is a FP or a vector FP type.
bool isFloatingPoint() const {		bool isFloatingPoint() const {
return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&		return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
SimpleTy <= MVT::LAST_FP_VALUETYPE) \|\|		SimpleTy <= MVT::LAST_FP_VALUETYPE) \|\|
(SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&		(SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) \|\|		SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) \|\|
(SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&		(SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&
		arsenmUnsubmitted Not Done Reply Inline Actions Have you measured compile time changes? Seems unfortunate to move from range checks to generated switches arsenm: Have you measured compile time changes? Seems unfortunate to move from range checks to…
		chapuniAuthorUnsubmitted Done Reply Inline Actions I over-expected compiler's optimizations easily. Re. range checks, I have rethought I could rewind them. Emission of ranges (FIRST/LAST_VALUES) was my latest implementation in `VTEmitter`. After it, ranges have become credible values provided by `ValueTypes.td`, since `UpdateVTRange` (D146906) checks also discontinuous gap. Re. other generated switches, I will measure impact to compile time and I consider emitting range set expressions instead of generated switches. chapuni: I over-expected compiler's optimizations easily. Re. range checks, I have rethought I could…
		chapuniAuthorUnsubmitted Done Reply Inline Actions I am certain I wouldn't introduce significant degressions since I rewound expansions of ranges (except for `isOverloaded()` chapuni: I am certain I wouldn't introduce significant degressions since I rewound expansions of ranges…
SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));		SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));
}		}

/// Return true if this is an integer or a vector integer type.		/// Return true if this is an integer or a vector integer type.
		kparzyszUnsubmitted Not Done Reply Inline Actions All of the `x ? true : false` are equivalent to just `x`. kparzysz: All of the `x ? true : false` are equivalent to just `x`.
		chapuniAuthorUnsubmitted Done Reply Inline Actions I will fix them. I was afraid of int=>bool conversion for no reason. (Guessing comes from restriction of other language) chapuni: I will fix them. I was afraid of int=>bool conversion for no reason. (Guessing comes from…
bool isInteger() const {		bool isInteger() const {
return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&		return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) \|\|		SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) \|\|
(SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&		(SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) \|\|		SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) \|\|
(SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&		(SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));		SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));
}		}
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	#undef GET_VT_RANGES

/// Return true if this is a 2048-bit vector type.		/// Return true if this is a 2048-bit vector type.
bool is2048BitVector() const {		bool is2048BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 2048);		return (isFixedLengthVector() && getFixedSizeInBits() == 2048);
}		}

/// Return true if this is an overloaded type for TableGen.		/// Return true if this is an overloaded type for TableGen.
bool isOverloaded() const {		bool isOverloaded() const {
return (SimpleTy == MVT::Any \|\| SimpleTy == MVT::iAny \|\|		switch (SimpleTy) {
SimpleTy == MVT::fAny \|\| SimpleTy == MVT::vAny \|\|		#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
SimpleTy == MVT::iPTRAny);		case Ty: \
		return Any;
		#include "GenVT.inc"
		#undef GET_VT_ATTR
		default:
		return false;
		}
}		}

/// Return a vector with the same number of elements as this vector, but		/// Return a vector with the same number of elements as this vector, but
/// with the element type converted to an integer type with the same		/// with the element type converted to an integer type with the same
/// bitwidth.		/// bitwidth.
MVT changeVectorElementTypeToInteger() const {		MVT changeVectorElementTypeToInteger() const {
MVT EltTy = getVectorElementType();		MVT EltTy = getVectorElementType();
MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());		MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines	#undef GET_VT_ATTR
}		}

/// If this is a vector, return the element type, otherwise return this.		/// If this is a vector, return the element type, otherwise return this.
MVT getScalarType() const {		MVT getScalarType() const {
return isVector() ? getVectorElementType() : *this;		return isVector() ? getVectorElementType() : *this;
}		}

MVT getVectorElementType() const {		MVT getVectorElementType() const {
// clang-format off
switch (SimpleTy) {		switch (SimpleTy) {
default:		default:
llvm_unreachable("Not a vector MVT!");		llvm_unreachable("Not a vector MVT!");
case v1i1:
case v2i1:		#define GET_VT_VECATTR(Ty, nElem, ElTy, ElSz, Sc) \
case v4i1:		case Ty: \
case v8i1:		return ElTy;
case v16i1:		#include "GenVT.inc"
case v32i1:		#undef GET_VT_VECATTR
case v64i1:
case v128i1:
case v256i1:
case v512i1:
case v1024i1:
case v2048i1:
case nxv1i1:
case nxv2i1:
case nxv4i1:
case nxv8i1:
case nxv16i1:
case nxv32i1:
case nxv64i1: return i1;
case v128i2:
case v256i2: return i2;
case v64i4:
case v128i4: return i4;
case v1i8:
case v2i8:
case v4i8:
case v8i8:
case v16i8:
case v32i8:
case v64i8:
case v128i8:
case v256i8:
case v512i8:
case v1024i8:
case nxv1i8:
case nxv2i8:
case nxv4i8:
case nxv8i8:
case nxv16i8:
case nxv32i8:
case nxv64i8: return i8;
case v1i16:
case v2i16:
case v3i16:
case v4i16:
case v8i16:
case v16i16:
case v32i16:
case v64i16:
case v128i16:
case v256i16:
case v512i16:
case nxv1i16:
case nxv2i16:
case nxv4i16:
case nxv8i16:
case nxv16i16:
case nxv32i16: return i16;
case v1i32:
case v2i32:
case v3i32:
case v4i32:
case v5i32:
case v6i32:
case v7i32:
case v8i32:
case v9i32:
case v10i32:
case v11i32:
case v12i32:
case v16i32:
case v32i32:
case v64i32:
case v128i32:
case v256i32:
case v512i32:
case v1024i32:
case v2048i32:
case nxv1i32:
case nxv2i32:
case nxv4i32:
case nxv8i32:
case nxv16i32:
case nxv32i32: return i32;
case v1i64:
case v2i64:
case v3i64:
case v4i64:
case v8i64:
case v16i64:
case v32i64:
case v64i64:
case v128i64:
case v256i64:
case nxv1i64:
case nxv2i64:
case nxv4i64:
case nxv8i64:
case nxv16i64:
case nxv32i64: return i64;
case v1i128: return i128;
case v1f16:
case v2f16:
case v3f16:
case v4f16:
case v8f16:
case v16f16:
case v32f16:
case v64f16:
case v128f16:
case v256f16:
case v512f16:
case nxv1f16:
case nxv2f16:
case nxv4f16:
case nxv8f16:
case nxv16f16:
case nxv32f16: return f16;
case v2bf16:
case v3bf16:
case v4bf16:
case v8bf16:
case v16bf16:
case v32bf16:
case v64bf16:
case v128bf16:
case nxv1bf16:
case nxv2bf16:
case nxv4bf16:
case nxv8bf16:
case nxv16bf16:
case nxv32bf16: return bf16;
case v1f32:
case v2f32:
case v3f32:
case v4f32:
case v5f32:
case v6f32:
case v7f32:
case v8f32:
case v9f32:
case v10f32:
case v11f32:
case v12f32:
case v16f32:
case v32f32:
case v64f32:
case v128f32:
case v256f32:
case v512f32:
case v1024f32:
case v2048f32:
case nxv1f32:
case nxv2f32:
case nxv4f32:
case nxv8f32:
case nxv16f32: return f32;
case v1f64:
case v2f64:
case v3f64:
case v4f64:
case v8f64:
case v16f64:
case v32f64:
case v64f64:
case v128f64:
case v256f64:
case nxv1f64:
case nxv2f64:
case nxv4f64:
case nxv8f64: return f64;
}		}
// clang-format on
}		}

/// Given a vector type, return the minimum number of elements it contains.		/// Given a vector type, return the minimum number of elements it contains.
unsigned getVectorMinNumElements() const {		unsigned getVectorMinNumElements() const {
switch (SimpleTy) {		switch (SimpleTy) {
default:		default:
llvm_unreachable("Not a vector MVT!");		llvm_unreachable("Not a vector MVT!");
case v2048i1:
case v2048i32:		#define GET_VT_VECATTR(Ty, nElem, ElTy, ElSz, Sc) \
case v2048f32: return 2048;		case Ty: \
case v1024i1:		return nElem;
case v1024i8:		#include "GenVT.inc"
case v1024i32:		#undef GET_VT_VECATTR
case v1024f32: return 1024;
case v512i1:
case v512i8:
case v512i16:
case v512i32:
case v512f16:
case v512f32: return 512;
case v256i1:
case v256i2:
case v256i8:
case v256i16:
case v256f16:
case v256i32:
case v256i64:
case v256f32:
case v256f64: return 256;
case v128i1:
case v128i2:
case v128i4:
case v128i8:
case v128i16:
case v128i32:
case v128i64:
case v128f16:
case v128bf16:
case v128f32:
case v128f64: return 128;
case v64i1:
case v64i4:
case v64i8:
case v64i16:
case v64i32:
case v64i64:
case v64f16:
case v64bf16:
case v64f32:
case v64f64:
case nxv64i1:
case nxv64i8: return 64;
case v32i1:
case v32i8:
case v32i16:
case v32i32:
case v32i64:
case v32f16:
case v32bf16:
case v32f32:
case v32f64:
case nxv32i1:
case nxv32i8:
case nxv32i16:
case nxv32i32:
case nxv32i64:
case nxv32f16:
case nxv32bf16: return 32;
case v16i1:
case v16i8:
case v16i16:
case v16i32:
case v16i64:
case v16f16:
case v16bf16:
case v16f32:
case v16f64:
case nxv16i1:
case nxv16i8:
case nxv16i16:
case nxv16i32:
case nxv16i64:
case nxv16f16:
case nxv16bf16:
case nxv16f32: return 16;
case v12i32:
case v12f32: return 12;
case v11i32:
case v11f32: return 11;
case v10i32:
case v10f32: return 10;
case v9i32:
case v9f32: return 9;
case v8i1:
case v8i8:
case v8i16:
case v8i32:
case v8i64:
case v8f16:
case v8bf16:
case v8f32:
case v8f64:
case nxv8i1:
case nxv8i8:
case nxv8i16:
case nxv8i32:
case nxv8i64:
case nxv8f16:
case nxv8bf16:
case nxv8f32:
case nxv8f64: return 8;
case v7i32:
case v7f32: return 7;
case v6i32:
case v6f32: return 6;
case v5i32:
case v5f32: return 5;
case v4i1:
case v4i8:
case v4i16:
case v4i32:
case v4i64:
case v4f16:
case v4bf16:
case v4f32:
case v4f64:
case nxv4i1:
case nxv4i8:
case nxv4i16:
case nxv4i32:
case nxv4i64:
case nxv4f16:
case nxv4bf16:
case nxv4f32:
case nxv4f64: return 4;
case v3i16:
case v3i32:
case v3i64:
case v3f16:
case v3bf16:
case v3f32:
case v3f64: return 3;
case v2i1:
case v2i8:
case v2i16:
case v2i32:
case v2i64:
case v2f16:
case v2bf16:
case v2f32:
case v2f64:
case nxv2i1:
case nxv2i8:
case nxv2i16:
case nxv2i32:
case nxv2i64:
case nxv2f16:
case nxv2bf16:
case nxv2f32:
case nxv2f64: return 2;
case v1i1:
case v1i8:
case v1i16:
case v1i32:
case v1i64:
case v1i128:
case v1f16:
case v1f32:
case v1f64:
case nxv1i1:
case nxv1i8:
case nxv1i16:
case nxv1i32:
case nxv1i64:
case nxv1f16:
case nxv1bf16:
case nxv1f32:
case nxv1f64: return 1;
}		}
}		}

ElementCount getVectorElementCount() const {		ElementCount getVectorElementCount() const {
return ElementCount::get(getVectorMinNumElements(), isScalableVector());		return ElementCount::get(getVectorMinNumElements(), isScalableVector());
}		}

unsigned getVectorNumElements() const {		unsigned getVectorNumElements() const {
Show All 12 Lines	#undef GET_VT_VECATTR
/// base size.		/// base size.
TypeSize getSizeInBits() const {		TypeSize getSizeInBits() const {
switch (SimpleTy) {		switch (SimpleTy) {
default:		default:
switch (SimpleTy) {		switch (SimpleTy) {
default:		default:
llvm_unreachable("getSizeInBits called on extended MVT.");		llvm_unreachable("getSizeInBits called on extended MVT.");

#define GET_VT_ATTR(Ty, N, Sz) \		#define GET_VT_ATTR(Ty, N, Sz, Any, Int, FP, Vec, Sc) \
case Ty: \		case Ty: \
return (MVT(Ty).isScalableVector() ? TypeSize::Scalable(Sz) \		return (Sc ? TypeSize::Scalable(Sz) : TypeSize::Fixed(Sz));
: TypeSize::Fixed(Sz));
#include "GenVT.inc"		#include "GenVT.inc"
#undef GET_VT_ATTR		#undef GET_VT_ATTR
}		}
case Other:		case Other:
llvm_unreachable("Value type is non-standard value, Other.");		llvm_unreachable("Value type is non-standard value, Other.");
case iPTR:		case iPTR:
llvm_unreachable("Value type size is target-dependent. Ask TLI.");		llvm_unreachable("Value type size is target-dependent. Ask TLI.");
case iPTRAny:		case iPTRAny:
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines	#undef GET_VT_ATTR
/// Return true if this has no more bits than VT.		/// Return true if this has no more bits than VT.
bool bitsLE(MVT VT) const {		bool bitsLE(MVT VT) const {
assert(isScalableVector() == VT.isScalableVector() &&		assert(isScalableVector() == VT.isScalableVector() &&
"Comparison between scalable and fixed types");		"Comparison between scalable and fixed types");
return knownBitsLE(VT);		return knownBitsLE(VT);
}		}

static MVT getFloatingPointVT(unsigned BitWidth) {		static MVT getFloatingPointVT(unsigned BitWidth) {
switch (BitWidth) {		#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
default:		if (FP == 3 && sz == BitWidth) \
		return Ty;
		#include "GenVT.inc"
		#undef GET_VT_ATTR

llvm_unreachable("Bad bit width!");		llvm_unreachable("Bad bit width!");
case 16:
return MVT::f16;
case 32:
return MVT::f32;
case 64:
return MVT::f64;
case 80:
return MVT::f80;
case 128:
return MVT::f128;
}
}		}

static MVT getIntegerVT(unsigned BitWidth) {		static MVT getIntegerVT(unsigned BitWidth) {
switch (BitWidth) {		#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
default:		if (Int == 3 && sz == BitWidth) \
		return Ty;
		#include "GenVT.inc"
		#undef GET_VT_ATTR

return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);		return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
case 1:
return MVT::i1;
case 2:
return MVT::i2;
case 4:
return MVT::i4;
case 8:
return MVT::i8;
case 16:
return MVT::i16;
case 32:
return MVT::i32;
case 64:
return MVT::i64;
case 128:
return MVT::i128;
}
}		}

static MVT getVectorVT(MVT VT, unsigned NumElements) {		static MVT getVectorVT(MVT VT, unsigned NumElements) {
// clang-format off		#define GET_VT_VECATTR(Ty, nElem, ElTy, ElSz, Sc) \
switch (VT.SimpleTy) {		if (!Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
default:		return Ty;
break;		#include "GenVT.inc"
case MVT::i1:		#undef GET_VT_VECATTR
if (NumElements == 1) return MVT::v1i1;
if (NumElements == 2) return MVT::v2i1;
if (NumElements == 4) return MVT::v4i1;
if (NumElements == 8) return MVT::v8i1;
if (NumElements == 16) return MVT::v16i1;
if (NumElements == 32) return MVT::v32i1;
if (NumElements == 64) return MVT::v64i1;
if (NumElements == 128) return MVT::v128i1;
if (NumElements == 256) return MVT::v256i1;
if (NumElements == 512) return MVT::v512i1;
if (NumElements == 1024) return MVT::v1024i1;
if (NumElements == 2048) return MVT::v2048i1;
break;
case MVT::i2:
if (NumElements == 128) return MVT::v128i2;
if (NumElements == 256) return MVT::v256i2;
break;
case MVT::i4:
if (NumElements == 64) return MVT::v64i4;
if (NumElements == 128) return MVT::v128i4;
break;
case MVT::i8:
if (NumElements == 1) return MVT::v1i8;
if (NumElements == 2) return MVT::v2i8;
if (NumElements == 4) return MVT::v4i8;
if (NumElements == 8) return MVT::v8i8;
if (NumElements == 16) return MVT::v16i8;
if (NumElements == 32) return MVT::v32i8;
if (NumElements == 64) return MVT::v64i8;
if (NumElements == 128) return MVT::v128i8;
if (NumElements == 256) return MVT::v256i8;
if (NumElements == 512) return MVT::v512i8;
if (NumElements == 1024) return MVT::v1024i8;
break;
case MVT::i16:
if (NumElements == 1) return MVT::v1i16;
if (NumElements == 2) return MVT::v2i16;
if (NumElements == 3) return MVT::v3i16;
if (NumElements == 4) return MVT::v4i16;
if (NumElements == 8) return MVT::v8i16;
if (NumElements == 16) return MVT::v16i16;
if (NumElements == 32) return MVT::v32i16;
if (NumElements == 64) return MVT::v64i16;
if (NumElements == 128) return MVT::v128i16;
if (NumElements == 256) return MVT::v256i16;
if (NumElements == 512) return MVT::v512i16;
break;
case MVT::i32:
if (NumElements == 1) return MVT::v1i32;
if (NumElements == 2) return MVT::v2i32;
if (NumElements == 3) return MVT::v3i32;
if (NumElements == 4) return MVT::v4i32;
if (NumElements == 5) return MVT::v5i32;
if (NumElements == 6) return MVT::v6i32;
if (NumElements == 7) return MVT::v7i32;
if (NumElements == 8) return MVT::v8i32;
if (NumElements == 9) return MVT::v9i32;
if (NumElements == 10) return MVT::v10i32;
if (NumElements == 11) return MVT::v11i32;
if (NumElements == 12) return MVT::v12i32;
if (NumElements == 16) return MVT::v16i32;
if (NumElements == 32) return MVT::v32i32;
if (NumElements == 64) return MVT::v64i32;
if (NumElements == 128) return MVT::v128i32;
if (NumElements == 256) return MVT::v256i32;
if (NumElements == 512) return MVT::v512i32;
if (NumElements == 1024) return MVT::v1024i32;
if (NumElements == 2048) return MVT::v2048i32;
break;
case MVT::i64:
if (NumElements == 1) return MVT::v1i64;
if (NumElements == 2) return MVT::v2i64;
if (NumElements == 3) return MVT::v3i64;
if (NumElements == 4) return MVT::v4i64;
if (NumElements == 8) return MVT::v8i64;
if (NumElements == 16) return MVT::v16i64;
if (NumElements == 32) return MVT::v32i64;
if (NumElements == 64) return MVT::v64i64;
if (NumElements == 128) return MVT::v128i64;
if (NumElements == 256) return MVT::v256i64;
break;
case MVT::i128:
if (NumElements == 1) return MVT::v1i128;
break;
case MVT::f16:
if (NumElements == 1) return MVT::v1f16;
if (NumElements == 2) return MVT::v2f16;
if (NumElements == 3) return MVT::v3f16;
if (NumElements == 4) return MVT::v4f16;
if (NumElements == 8) return MVT::v8f16;
if (NumElements == 16) return MVT::v16f16;
if (NumElements == 32) return MVT::v32f16;
if (NumElements == 64) return MVT::v64f16;
if (NumElements == 128) return MVT::v128f16;
if (NumElements == 256) return MVT::v256f16;
if (NumElements == 512) return MVT::v512f16;
break;
case MVT::bf16:
if (NumElements == 2) return MVT::v2bf16;
if (NumElements == 3) return MVT::v3bf16;
if (NumElements == 4) return MVT::v4bf16;
if (NumElements == 8) return MVT::v8bf16;
if (NumElements == 16) return MVT::v16bf16;
if (NumElements == 32) return MVT::v32bf16;
if (NumElements == 64) return MVT::v64bf16;
if (NumElements == 128) return MVT::v128bf16;
break;
case MVT::f32:
if (NumElements == 1) return MVT::v1f32;
if (NumElements == 2) return MVT::v2f32;
if (NumElements == 3) return MVT::v3f32;
if (NumElements == 4) return MVT::v4f32;
if (NumElements == 5) return MVT::v5f32;
if (NumElements == 6) return MVT::v6f32;
if (NumElements == 7) return MVT::v7f32;
if (NumElements == 8) return MVT::v8f32;
if (NumElements == 9) return MVT::v9f32;
if (NumElements == 10) return MVT::v10f32;
if (NumElements == 11) return MVT::v11f32;
if (NumElements == 12) return MVT::v12f32;
if (NumElements == 16) return MVT::v16f32;
if (NumElements == 32) return MVT::v32f32;
if (NumElements == 64) return MVT::v64f32;
if (NumElements == 128) return MVT::v128f32;
if (NumElements == 256) return MVT::v256f32;
if (NumElements == 512) return MVT::v512f32;
if (NumElements == 1024) return MVT::v1024f32;
if (NumElements == 2048) return MVT::v2048f32;
break;
case MVT::f64:
if (NumElements == 1) return MVT::v1f64;
if (NumElements == 2) return MVT::v2f64;
if (NumElements == 3) return MVT::v3f64;
if (NumElements == 4) return MVT::v4f64;
if (NumElements == 8) return MVT::v8f64;
if (NumElements == 16) return MVT::v16f64;
if (NumElements == 32) return MVT::v32f64;
if (NumElements == 64) return MVT::v64f64;
if (NumElements == 128) return MVT::v128f64;
if (NumElements == 256) return MVT::v256f64;
break;
}
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);		return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
// clang-format on
}		}

static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {		static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
switch(VT.SimpleTy) {		#define GET_VT_VECATTR(Ty, nElem, ElTy, ElSz, Sc) \
default:		if (Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
break;		return Ty;
case MVT::i1:		#include "GenVT.inc"
if (NumElements == 1) return MVT::nxv1i1;		#undef GET_VT_VECATTR
if (NumElements == 2) return MVT::nxv2i1;
if (NumElements == 4) return MVT::nxv4i1;
if (NumElements == 8) return MVT::nxv8i1;
if (NumElements == 16) return MVT::nxv16i1;
if (NumElements == 32) return MVT::nxv32i1;
if (NumElements == 64) return MVT::nxv64i1;
break;
case MVT::i8:
if (NumElements == 1) return MVT::nxv1i8;
if (NumElements == 2) return MVT::nxv2i8;
if (NumElements == 4) return MVT::nxv4i8;
if (NumElements == 8) return MVT::nxv8i8;
if (NumElements == 16) return MVT::nxv16i8;
if (NumElements == 32) return MVT::nxv32i8;
if (NumElements == 64) return MVT::nxv64i8;
break;
case MVT::i16:
if (NumElements == 1) return MVT::nxv1i16;
if (NumElements == 2) return MVT::nxv2i16;
if (NumElements == 4) return MVT::nxv4i16;
if (NumElements == 8) return MVT::nxv8i16;
if (NumElements == 16) return MVT::nxv16i16;
if (NumElements == 32) return MVT::nxv32i16;
break;
case MVT::i32:
if (NumElements == 1) return MVT::nxv1i32;
if (NumElements == 2) return MVT::nxv2i32;
if (NumElements == 4) return MVT::nxv4i32;
if (NumElements == 8) return MVT::nxv8i32;
if (NumElements == 16) return MVT::nxv16i32;
if (NumElements == 32) return MVT::nxv32i32;
break;
case MVT::i64:
if (NumElements == 1) return MVT::nxv1i64;
if (NumElements == 2) return MVT::nxv2i64;
if (NumElements == 4) return MVT::nxv4i64;
if (NumElements == 8) return MVT::nxv8i64;
if (NumElements == 16) return MVT::nxv16i64;
if (NumElements == 32) return MVT::nxv32i64;
break;
case MVT::f16:
if (NumElements == 1) return MVT::nxv1f16;
if (NumElements == 2) return MVT::nxv2f16;
if (NumElements == 4) return MVT::nxv4f16;
if (NumElements == 8) return MVT::nxv8f16;
if (NumElements == 16) return MVT::nxv16f16;
if (NumElements == 32) return MVT::nxv32f16;
break;
case MVT::bf16:
if (NumElements == 1) return MVT::nxv1bf16;
if (NumElements == 2) return MVT::nxv2bf16;
if (NumElements == 4) return MVT::nxv4bf16;
if (NumElements == 8) return MVT::nxv8bf16;
if (NumElements == 16) return MVT::nxv16bf16;
if (NumElements == 32) return MVT::nxv32bf16;
break;
case MVT::f32:
if (NumElements == 1) return MVT::nxv1f32;
if (NumElements == 2) return MVT::nxv2f32;
if (NumElements == 4) return MVT::nxv4f32;
if (NumElements == 8) return MVT::nxv8f32;
if (NumElements == 16) return MVT::nxv16f32;
break;
case MVT::f64:
if (NumElements == 1) return MVT::nxv1f64;
if (NumElements == 2) return MVT::nxv2f64;
if (NumElements == 4) return MVT::nxv4f64;
if (NumElements == 8) return MVT::nxv8f64;
break;
}
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);		return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}		}

static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {		static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
if (IsScalable)		if (IsScalable)
return getScalableVectorVT(VT, NumElements);		return getScalableVectorVT(VT, NumElements);
return getVectorVT(VT, NumElements);		return getVectorVT(VT, NumElements);
}		}
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/utils/TableGen/VTEmitter.cpp

//===- VTEmitter.cpp - Generate properties from ValueTypes.td -------------===//		//===- VTEmitter.cpp - Generate properties from ValueTypes.td -------------===//
		Lint: Lint Inline Actions clang-format not found in user’s local PATH; not linting file. Lint: Lint: clang-format not found in user’s local PATH; not linting file.
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "llvm/ADT/StringRef.h"		#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Record.h"		#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h"		#include "llvm/TableGen/TableGenBackend.h"
#include <array>		#include <array>
#include <cassert>		#include <cassert>
#include <map>		#include <map>
using namespace llvm;		using namespace llvm;

▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	if (Valid) {
VTRanges[Key].First = Name;		VTRanges[Key].First = Name;
assert(!VTRanges[Key].Closed && "Gap detected!");		assert(!VTRanges[Key].Closed && "Gap detected!");
VTRanges[Key].Last = Name;		VTRanges[Key].Last = Name;
} else if (VTRanges.count(Key)) {		} else if (VTRanges.count(Key)) {
VTRanges[Key].Closed = true;		VTRanges[Key].Closed = true;
}		}
};		};

OS << "#ifdef GET_VT_ATTR // (Ty, n, sz)\n";		OS << "#ifdef GET_VT_ATTR // (Ty, n, sz, Any, Int, FP, Ba, Vec, Sc)\n";
for (const auto *VT : VTsByNumber) {		for (const auto *VT : VTsByNumber) {
if (!VT)		if (!VT)
continue;		continue;
auto Name = VT->getName();		auto Name = VT->getValueAsString("LLVMName");
Name = StringSwitch<StringRef>(Name)
.Case("OtherVT", "Other")
.Case("FlagVT", "Glue")
.Case("untyped", "Untyped")
.Case("MetadataVT", "Metadata")
.Default(Name);
auto Value = VT->getValueAsInt("Value");		auto Value = VT->getValueAsInt("Value");
		bool IsInteger = VT->getValueAsInt("isInteger");
		bool IsFP = VT->getValueAsInt("isFP");
		bool IsVector = VT->getValueAsInt("isVector");
		bool IsScalable = VT->getValueAsInt("isScalable");

		UpdateVTRange("INTEGER_FIXEDLEN_VECTOR_VALUETYPE", Name,
		IsInteger && IsVector && !IsScalable);
		UpdateVTRange("INTEGER_SCALABLE_VECTOR_VALUETYPE", Name,
		IsInteger && IsScalable);
		UpdateVTRange("FP_FIXEDLEN_VECTOR_VALUETYPE", Name,
		IsFP && IsVector && !IsScalable);
		UpdateVTRange("FP_SCALABLE_VECTOR_VALUETYPE", Name, IsFP && IsScalable);
		UpdateVTRange("FIXEDLEN_VECTOR_VALUETYPE", Name, IsVector && !IsScalable);
		UpdateVTRange("SCALABLE_VECTOR_VALUETYPE", Name, IsScalable);
		UpdateVTRange("VECTOR_VALUETYPE", Name, IsVector);
		UpdateVTRange("INTEGER_VALUETYPE", Name, IsInteger && !IsVector);
		UpdateVTRange("FP_VALUETYPE", Name, IsFP && !IsVector);
		craig.topperUnsubmitted Not Done Reply Inline Actions Capitalize variable names craig.topper: Capitalize variable names
		chapuniAuthorUnsubmitted Done Reply Inline Actions Will fix. Excuse my bad habit. chapuni: Will fix. Excuse my bad habit.
UpdateVTRange("VALUETYPE", Name, Value < 224);		UpdateVTRange("VALUETYPE", Name, Value < 224);

// clang-format off		// clang-format off
OS << " GET_VT_ATTR("		OS << " GET_VT_ATTR("
<< Name << ", "		<< Name << ", "
<< Value << ", "		<< Value << ", "
<< VT->getValueAsInt("Size") << ")\n";		<< VT->getValueAsInt("Size") << ", "
		<< VT->getValueAsInt("isOverloaded")
		<< ", " << (IsInteger ? Name[0] == 'i' ? 3 : 1 : 0) << ", "
		<< (IsFP ? Name[0] == 'f' ? 3 : 1 : 0) << ", "
		<< IsVector << ", "
		<< IsScalable << ")\n";
// clang-format on		// clang-format on
}		}
OS << "#endif\n\n";		OS << "#endif\n\n";

OS << "#ifdef GET_VT_RANGES\n";		OS << "#ifdef GET_VT_RANGES\n";
for (const auto &KV : VTRanges) {		for (const auto &KV : VTRanges) {
assert(KV.second.Closed);		assert(KV.second.Closed);
OS << " FIRST_" << KV.first << " = " << KV.second.First << ",\n"		OS << " FIRST_" << KV.first << " = " << KV.second.First << ",\n"
<< " LAST_" << KV.first << " = " << KV.second.Last << ",\n";		<< " LAST_" << KV.first << " = " << KV.second.Last << ",\n";
}		}
OS << "#endif\n\n";		OS << "#endif\n\n";

		OS << "#ifdef GET_VT_VECATTR // (Ty, nElem, ElTy, ElSz, Sc)\n";
		for (const auto *VT : VTsByNumber) {
		if (!VT \|\| !VT->getValueAsInt("isVector"))
		continue;
		const auto *ElTy = VT->getValueAsDef("ElementType");
		assert(ElTy);
		// clang-format off
		OS << " GET_VT_VECATTR("
		<< VT->getValueAsString("LLVMName") << ", "
		<< VT->getValueAsInt("nElem") << ", "
		<< ElTy->getName() << ", "
		<< ElTy->getValueAsInt("Size") << ", "
		<< VT->getValueAsInt("isScalable") << ")\n";
		// clang-format on
		}
		OS << "#endif\n\n";
}		}

static TableGen::Emitter::OptClass<VTEmitter> X("gen-vt", "Generate ValueType");		static TableGen::Emitter::OptClass<VTEmitter> X("gen-vt", "Generate ValueType");

This is an archive of the discontinued LLVM Phabricator instance.

ValueTypes.td: Reorganize ValueType to generate `MachineValueType.h`
ClosedPublic

Details

Diff Detail

Unit TestsFailed

Event Timeline

Revision Contents

Diff 511414

llvm/include/llvm/CodeGen/ValueTypes.td

llvm/include/llvm/IR/Intrinsics.td

llvm/unittests/Support/MachineValueType.h

llvm/utils/TableGen/VTEmitter.cpp

This is an archive of the discontinued LLVM Phabricator instance.

ValueTypes.td: Reorganize ValueType to generate `MachineValueType.h`ClosedPublic

Details

Diff Detail

Unit TestsFailed

Event Timeline

Revision Contents

Diff 511414

llvm/include/llvm/CodeGen/ValueTypes.td

llvm/include/llvm/IR/Intrinsics.td

llvm/unittests/Support/MachineValueType.h

llvm/utils/TableGen/VTEmitter.cpp

ValueTypes.td: Reorganize ValueType to generate `MachineValueType.h`
ClosedPublic