[llvm] [DirectX][DXIL] Align type spec of TableGen DXIL Op mapping with that of LLVM Intrinsic (PR #86311)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Mar 22 10:00:06 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
Author: S. Bharadwaj Yadavalli (bharadwajy)
<details>
<summary>Changes</summary>
Align specification of return type and parameter type fields of DXIL Op mapping with those of TableGan class Intrinsic.
A `void` return type of LLVM Intrinsic is represented as `[]` in its TableGen description record. Currently, a `void` return type of DXIL Operation is represented as `[llvm_void_ty]`. In addition, return and parameter types are recorded as a single list with an understanding that element at index `0` is the return type.
These changes leverage and align DXIL Op type specification with the type specification of the LLVM Intrinsic. As a result, return and parameter types are now specified as two separate lists no longer requiring a different representation for `void` return type. Additionally, type specification would be more succinct yet equally informative for DXIL Op records for which the same LLVM Intrinsics types are also valid.
Added a test to verify lowering of LLVM intrinsic with `void` return.
Barrier intrinsic has a `void` return type. Specification of its DXIL Op can inherit the types of this intrinsic. The test verifies the changes.
Move OverloadKind to DXILABI.h.
Fixes #<!-- -->86229
---
Patch is 22.49 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/86311.diff
6 Files Affected:
- (modified) llvm/include/llvm/IR/IntrinsicsDirectX.td (+1)
- (modified) llvm/include/llvm/Support/DXILABI.h (+15)
- (modified) llvm/lib/Target/DirectX/DXIL.td (+19-12)
- (modified) llvm/lib/Target/DirectX/DXILOpBuilder.cpp (+4-19)
- (added) llvm/test/CodeGen/DirectX/barrier.ll (+11)
- (modified) llvm/utils/TableGen/DXILEmitter.cpp (+173-114)
``````````diff
diff --git a/llvm/include/llvm/IR/IntrinsicsDirectX.td b/llvm/include/llvm/IR/IntrinsicsDirectX.td
index 1164b241ba7b0d..292aa4497916f1 100644
--- a/llvm/include/llvm/IR/IntrinsicsDirectX.td
+++ b/llvm/include/llvm/IR/IntrinsicsDirectX.td
@@ -16,6 +16,7 @@ def int_dx_thread_id : Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem, IntrW
def int_dx_group_id : Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem, IntrWillReturn]>;
def int_dx_thread_id_in_group : Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem, IntrWillReturn]>;
def int_dx_flattened_thread_id_in_group : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrWillReturn]>;
+def int_dx_barrier : Intrinsic<[], [llvm_i32_ty], [IntrNoDuplicate, IntrWillReturn]>;
def int_dx_create_handle : ClangBuiltin<"__builtin_hlsl_create_handle">,
Intrinsic<[ llvm_ptr_ty ], [llvm_i8_ty], [IntrWillReturn]>;
diff --git a/llvm/include/llvm/Support/DXILABI.h b/llvm/include/llvm/Support/DXILABI.h
index c1d81775b6711e..75cc17bad992d9 100644
--- a/llvm/include/llvm/Support/DXILABI.h
+++ b/llvm/include/llvm/Support/DXILABI.h
@@ -39,6 +39,21 @@ enum class ParameterKind : uint8_t {
DXIL_HANDLE,
};
+enum OverloadKind : uint16_t {
+ INVALID = 0,
+ VOID = 1,
+ HALF = 1 << 1,
+ FLOAT = 1 << 2,
+ DOUBLE = 1 << 3,
+ I1 = 1 << 4,
+ I8 = 1 << 5,
+ I16 = 1 << 6,
+ I32 = 1 << 7,
+ I64 = 1 << 8,
+ UserDefineType = 1 << 9,
+ ObjectType = 1 << 10,
+};
+
/// The kind of resource for an SRV or UAV resource. Sometimes referred to as
/// "Shape" in the DXIL docs.
enum class ResourceKind : uint32_t {
diff --git a/llvm/lib/Target/DirectX/DXIL.td b/llvm/lib/Target/DirectX/DXIL.td
index f7e69ebae15b6c..aa98b74c1ffe56 100644
--- a/llvm/lib/Target/DirectX/DXIL.td
+++ b/llvm/lib/Target/DirectX/DXIL.td
@@ -240,18 +240,23 @@ class DXILOpMappingBase {
DXILOpClass OpClass = UnknownOpClass;// Class of DXIL Operation.
Intrinsic LLVMIntrinsic = ?; // LLVM Intrinsic DXIL Operation maps to
string Doc = ""; // A short description of the operation
- list<LLVMType> OpTypes = ?; // Valid types of DXIL Operation in the
- // format [returnTy, param1ty, ...]
+ // The following fields denote the same semantics as those of Intrinsic class
+ // and are initialized with the same values as those of LLVMIntrinsic unless
+ // overridden in the definition of a record.
+ list<LLVMType> OpRetTypes = ?; // Valid return types of DXIL Operation
+ list<LLVMType> OpParamTypes = ?; // Valid parameter types of DXIL Operation
}
class DXILOpMapping<int opCode, DXILOpClass opClass,
Intrinsic intrinsic, string doc,
- list<LLVMType> opTys = []> : DXILOpMappingBase {
+ list<LLVMType> retTys = [],
+ list<LLVMType> paramTys = []> : DXILOpMappingBase {
int OpCode = opCode; // Opcode corresponding to DXIL Operation
DXILOpClass OpClass = opClass; // Class of DXIL Operation.
Intrinsic LLVMIntrinsic = intrinsic; // LLVM Intrinsic the DXIL Operation maps
string Doc = doc; // to a short description of the operation
- list<LLVMType> OpTypes = !if(!eq(!size(opTys), 0), LLVMIntrinsic.Types, opTys);
+ list<LLVMType> OpRetTypes = !if(!eq(!size(retTys), 0), LLVMIntrinsic.RetTypes, retTys);
+ list<LLVMType> OpParamTypes = !if(!eq(!size(paramTys), 0), LLVMIntrinsic.ParamTypes, paramTys);
}
// Concrete definition of DXIL Operation mapping to corresponding LLVM intrinsic
@@ -259,32 +264,32 @@ def Abs : DXILOpMapping<6, unary, int_fabs,
"Returns the absolute value of the input.">;
def IsInf : DXILOpMapping<9, isSpecialFloat, int_dx_isinf,
"Determines if the specified value is infinite.",
- [llvm_i1_ty, llvm_halforfloat_ty]>;
+ [llvm_i1_ty], [llvm_halforfloat_ty]>;
def Cos : DXILOpMapping<12, unary, int_cos,
"Returns cosine(theta) for theta in radians.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def Sin : DXILOpMapping<13, unary, int_sin,
"Returns sine(theta) for theta in radians.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def Exp2 : DXILOpMapping<21, unary, int_exp2,
"Returns the base 2 exponential, or 2**x, of the specified value."
"exp2(x) = 2**x.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def Frac : DXILOpMapping<22, unary, int_dx_frac,
"Returns a fraction from 0 to 1 that represents the "
"decimal part of the input.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def RSqrt : DXILOpMapping<25, unary, int_dx_rsqrt,
"Returns the reciprocal of the square root of the specified value."
"rsqrt(x) = 1 / sqrt(x).",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def Round : DXILOpMapping<26, unary, int_round,
"Returns the input rounded to the nearest integer"
"within a floating-point type.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def Floor : DXILOpMapping<27, unary, int_floor,
"Returns the largest integer that is less than or equal to the input.",
- [llvm_halforfloat_ty, LLVMMatchType<0>]>;
+ [llvm_halforfloat_ty], [LLVMMatchType<0>]>;
def FMax : DXILOpMapping<35, binary, int_maxnum,
"Float maximum. FMax(a,b) = a > b ? a : b">;
def FMin : DXILOpMapping<36, binary, int_minnum,
@@ -303,6 +308,8 @@ def IMad : DXILOpMapping<48, tertiary, int_dx_imad,
"Signed integer arithmetic multiply/add operation. imad(m,a,b) = m * a + b.">;
def UMad : DXILOpMapping<49, tertiary, int_dx_umad,
"Unsigned integer arithmetic multiply/add operation. umad(m,a,b) = m * a + b.">;
+def Barrier : DXILOpMapping<80, barrier, int_dx_barrier,
+ "Inserts a memory barrier in the shader">;
def ThreadId : DXILOpMapping<93, threadId, int_dx_thread_id,
"Reads the thread ID">;
def GroupId : DXILOpMapping<94, groupId, int_dx_group_id,
diff --git a/llvm/lib/Target/DirectX/DXILOpBuilder.cpp b/llvm/lib/Target/DirectX/DXILOpBuilder.cpp
index a1eacc2d48009c..f56155312aee50 100644
--- a/llvm/lib/Target/DirectX/DXILOpBuilder.cpp
+++ b/llvm/lib/Target/DirectX/DXILOpBuilder.cpp
@@ -21,24 +21,6 @@ using namespace llvm::dxil;
constexpr StringLiteral DXILOpNamePrefix = "dx.op.";
-namespace {
-
-enum OverloadKind : uint16_t {
- VOID = 1,
- HALF = 1 << 1,
- FLOAT = 1 << 2,
- DOUBLE = 1 << 3,
- I1 = 1 << 4,
- I8 = 1 << 5,
- I16 = 1 << 6,
- I32 = 1 << 7,
- I64 = 1 << 8,
- UserDefineType = 1 << 9,
- ObjectType = 1 << 10,
-};
-
-} // namespace
-
static const char *getOverloadTypeName(OverloadKind Kind) {
switch (Kind) {
case OverloadKind::HALF:
@@ -61,8 +43,11 @@ static const char *getOverloadTypeName(OverloadKind Kind) {
case OverloadKind::ObjectType:
case OverloadKind::UserDefineType:
break;
+ case OverloadKind::INVALID:
+ report_fatal_error("Invalid Overload Type for type name lookup",
+ /* gen_crash_diag=*/false);
}
- llvm_unreachable("invalid overload type for name");
+ llvm_unreachable("Unhandled Overload Type specified for type name lookup");
return "void";
}
diff --git a/llvm/test/CodeGen/DirectX/barrier.ll b/llvm/test/CodeGen/DirectX/barrier.ll
new file mode 100644
index 00000000000000..8be4aac1f782b5
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/barrier.ll
@@ -0,0 +1,11 @@
+; RUN: opt -S -dxil-op-lower < %s | FileCheck %s
+
+; Argument of llvm.dx.barrier is expected to be a mask of
+; DXIL::BarrierMode values. Chose an int value for testing.
+
+define void @test_barrier() #0 {
+entry:
+ ; CHECK: call void @dx.op.barrier.i32(i32 80, i32 9)
+ call void @llvm.dx.barrier(i32 noundef 9)
+ ret void
+}
diff --git a/llvm/utils/TableGen/DXILEmitter.cpp b/llvm/utils/TableGen/DXILEmitter.cpp
index af1efb8aa99f73..5f678a527381ca 100644
--- a/llvm/utils/TableGen/DXILEmitter.cpp
+++ b/llvm/utils/TableGen/DXILEmitter.cpp
@@ -39,8 +39,8 @@ struct DXILOperationDesc {
int OpCode; // ID of DXIL operation
StringRef OpClass; // name of the opcode class
StringRef Doc; // the documentation description of this instruction
- SmallVector<Record *> OpTypes; // Vector of operand type records -
- // return type is at index 0
+ SmallVector<OverloadKind> OpOverloadTys; // Vector of operand overload types -
+ // return type is at index 0
SmallVector<std::string>
OpAttributes; // operation attribute represented as strings
StringRef Intrinsic; // The llvm intrinsic map to OpName. Default is "" which
@@ -65,41 +65,167 @@ struct DXILOperationDesc {
};
} // end anonymous namespace
-/// Return dxil::ParameterKind corresponding to input LLVMType record
+/// Return dxil::ParameterKind corresponding to input Overload Kind
///
-/// \param R TableGen def record of class LLVMType
+/// \param OLKind Overload Kind
/// \return ParameterKind As defined in llvm/Support/DXILABI.h
-static ParameterKind getParameterKind(const Record *R) {
+static ParameterKind getParameterKind(const dxil::OverloadKind OLKind) {
+ switch (OLKind) {
+ case OverloadKind::VOID:
+ return ParameterKind::VOID;
+ case OverloadKind::HALF:
+ return ParameterKind::HALF;
+ case OverloadKind::FLOAT:
+ return ParameterKind::FLOAT;
+ case OverloadKind::DOUBLE:
+ return ParameterKind::DOUBLE;
+ case OverloadKind::I1:
+ return ParameterKind::I1;
+ case OverloadKind::I8:
+ return ParameterKind::I8;
+ case OverloadKind::I16:
+ return ParameterKind::I16;
+ case OverloadKind::I32:
+ return ParameterKind::I32;
+ case OverloadKind::I64:
+ return ParameterKind::I64;
+ default:
+ if ((OLKind ==
+ (OverloadKind::HALF | OverloadKind::FLOAT | OverloadKind::DOUBLE)) ||
+ (OLKind == (OverloadKind::HALF | OverloadKind::FLOAT)) ||
+ (OLKind == (OverloadKind::I1 | OverloadKind::I8 | OverloadKind::I16 |
+ OverloadKind::I32 | OverloadKind::I64)) ||
+ (OLKind == (OverloadKind::I16 | OverloadKind::I32))) {
+ return ParameterKind::OVERLOAD;
+ } else {
+ report_fatal_error("Unsupported Overload Type encountered",
+ /* gen_crash_diag=*/false);
+ }
+ }
+}
+
+/// Return a string representation of ParameterKind enum
+/// \param Kind Parameter Kind enum value
+/// \return std::string string representation of input Kind
+static std::string getParameterKindStr(ParameterKind Kind) {
+ switch (Kind) {
+ case ParameterKind::INVALID:
+ return "INVALID";
+ case ParameterKind::VOID:
+ return "VOID";
+ case ParameterKind::HALF:
+ return "HALF";
+ case ParameterKind::FLOAT:
+ return "FLOAT";
+ case ParameterKind::DOUBLE:
+ return "DOUBLE";
+ case ParameterKind::I1:
+ return "I1";
+ case ParameterKind::I8:
+ return "I8";
+ case ParameterKind::I16:
+ return "I16";
+ case ParameterKind::I32:
+ return "I32";
+ case ParameterKind::I64:
+ return "I64";
+ case ParameterKind::OVERLOAD:
+ return "OVERLOAD";
+ case ParameterKind::CBUFFER_RET:
+ return "CBUFFER_RET";
+ case ParameterKind::RESOURCE_RET:
+ return "RESOURCE_RET";
+ case ParameterKind::DXIL_HANDLE:
+ return "DXIL_HANDLE";
+ }
+ llvm_unreachable("Unknown llvm::dxil::ParameterKind enum");
+}
+
+static dxil::OverloadKind getOverloadKind(const Record *R) {
auto VTRec = R->getValueAsDef("VT");
switch (getValueType(VTRec)) {
case MVT::isVoid:
- return ParameterKind::VOID;
+ return OverloadKind::VOID;
case MVT::f16:
- return ParameterKind::HALF;
+ return OverloadKind::HALF;
case MVT::f32:
- return ParameterKind::FLOAT;
+ return OverloadKind::FLOAT;
case MVT::f64:
- return ParameterKind::DOUBLE;
+ return OverloadKind::DOUBLE;
case MVT::i1:
- return ParameterKind::I1;
+ return OverloadKind::I1;
case MVT::i8:
- return ParameterKind::I8;
+ return OverloadKind::I8;
case MVT::i16:
- return ParameterKind::I16;
+ return OverloadKind::I16;
case MVT::i32:
- return ParameterKind::I32;
- case MVT::fAny:
+ return OverloadKind::I32;
+ case MVT::i64:
+ return OverloadKind::I64;
case MVT::iAny:
- return ParameterKind::OVERLOAD;
+ return static_cast<dxil::OverloadKind>(
+ OverloadKind::I16 | OverloadKind::I32 | OverloadKind::I64);
+ case MVT::fAny:
+ return static_cast<dxil::OverloadKind>(
+ OverloadKind::HALF | OverloadKind::FLOAT | OverloadKind::DOUBLE);
case MVT::Other:
// Handle DXIL-specific overload types
- if (R->getValueAsInt("isHalfOrFloat") || R->getValueAsInt("isI16OrI32")) {
- return ParameterKind::OVERLOAD;
+ {
+ if (R->getValueAsInt("isHalfOrFloat")) {
+ return static_cast<dxil::OverloadKind>(OverloadKind::HALF |
+ OverloadKind::FLOAT);
+ } else if (R->getValueAsInt("isI16OrI32")) {
+ return static_cast<dxil::OverloadKind>(OverloadKind::I16 |
+ OverloadKind::I32);
+ }
}
LLVM_FALLTHROUGH;
default:
- llvm_unreachable("Support for specified DXIL Type not yet implemented");
+ report_fatal_error(
+ "Support for specified parameter OverloadKind not yet implemented",
+ /* gen_crash_diag=*/false);
+ }
+}
+
+/// Return a string representation of OverloadKind enum
+/// \param OLKind Overload Kind
+/// \return std::string string representation of OverloadKind
+
+static std::string getOverloadKindStr(const dxil::OverloadKind OLKind) {
+ switch (OLKind) {
+ case OverloadKind::VOID:
+ return "OverloadKind::VOID";
+ case OverloadKind::HALF:
+ return "OverloadKind::HALF";
+ case OverloadKind::FLOAT:
+ return "OverloadKind::FLOAT";
+ case OverloadKind::DOUBLE:
+ return "OverloadKind::DOUBLE";
+ case OverloadKind::I1:
+ return "OverloadKind::I1";
+ case OverloadKind::I8:
+ return "OverloadKind::I8";
+ case OverloadKind::I16:
+ return "OverloadKind::I16";
+ case OverloadKind::I32:
+ return "OverloadKind::I32";
+ case OverloadKind::I64:
+ return "OverloadKind::I64";
+ default:
+ if (OLKind == (OverloadKind::I16 | OverloadKind::I32 | OverloadKind::I64)) {
+ return "OverloadKind::I16 | OverloadKind::I32 | OverloadKind::I64";
+ } else if (OLKind == (OverloadKind::HALF | OverloadKind::FLOAT |
+ OverloadKind::DOUBLE)) {
+ return "OverloadKind::HALF | OverloadKind::FLOAT | OverloadKind::DOUBLE";
+ } else if (OLKind == (OverloadKind::HALF | OverloadKind::FLOAT)) {
+ return "OverloadKind::HALF | OverloadKind::FLOAT";
+ } else if (OLKind == (OverloadKind::I16 | OverloadKind::I32)) {
+ return "OverloadKind::I16 | OverloadKind::I32";
+ } else {
+ report_fatal_error("Unsupported OverloadKind specified",
+ /* gen_crash_diag=*/false);
+ }
}
}
@@ -114,9 +240,25 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
Doc = R->getValueAsString("Doc");
- auto TypeRecs = R->getValueAsListOfDefs("OpTypes");
+ // Populate OpOverloadTys with return type and parameter types
+ auto RetTypeRecs = R->getValueAsListOfDefs("OpRetTypes");
+ auto ParamTypeRecs = R->getValueAsListOfDefs("OpParamTypes");
+ unsigned RetTypeRecSize = RetTypeRecs.size();
+ unsigned ParamTypeRecSize = ParamTypeRecs.size();
+ // A vector with return type and parameter type records
+ std::vector<Record *> TypeRecs;
+ TypeRecs.reserve(RetTypeRecSize + ParamTypeRecSize);
+ // If return type lust is empty, the return type is void
+ if (RetTypeRecSize == 0) {
+ OpOverloadTys.emplace_back(OverloadKind::VOID);
+ } else {
+ // Append RetTypeRecs to TypeRecs
+ TypeRecs.insert(TypeRecs.end(), RetTypeRecs.begin(), RetTypeRecs.end());
+ }
+ // Append RetTypeRecs to TypeRecs
+ TypeRecs.insert(TypeRecs.end(), ParamTypeRecs.begin(), ParamTypeRecs.end());
+
unsigned TypeRecsSize = TypeRecs.size();
- // Populate OpTypes with return type and parameter types
// Parameter indices of overloaded parameters.
// This vector contains overload parameters in the order used to
@@ -146,13 +288,13 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
if (!knownType) {
report_fatal_error("Specification of multiple differing overload "
"parameter types not yet supported",
- false);
+ /* gen_crash_diag=*/false);
}
} else {
OverloadParamIndices.push_back(i);
}
}
- // Populate OpTypes array according to the type specification
+ // Populate OpOverloadTys array according to the type specification
if (TR->isAnonymous()) {
// Check prior overload types exist
assert(!OverloadParamIndices.empty() &&
@@ -160,10 +302,10 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
// Get the parameter index of anonymous type, TR, references
auto OLParamIndex = TR->getValueAsInt("Number");
// Resolve and insert the type to that at OLParamIndex
- OpTypes.emplace_back(TypeRecs[OLParamIndex]);
+ OpOverloadTys.emplace_back(getOverloadKind(TypeRecs[OLParamIndex]));
} else {
- // A non-anonymous type. Just record it in OpTypes
- OpTypes.emplace_back(TR);
+ // A non-anonymous type. Just record it in OpOverloadTys
+ OpOverloadTys.emplace_back(getOverloadKind(TR));
}
}
@@ -172,7 +314,7 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
if (!OverloadParamIndices.empty()) {
if (OverloadParamIndices.size() > 1)
report_fatal_error("Multiple overload type specification not supported",
- false);
+ /* gen_crash_diag=*/false);
OverloadParamIndex = OverloadParamIndices[0];
}
// Get the operation class
@@ -196,89 +338,6 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
}
}
-/// Return a string representation of ParameterKind enum
-/// \param Kind Parameter Kind enum value
-/// \return std::string string representation of input Kind
-static std::string getParameterKindStr(ParameterKind Kind) {
- switch (Kind) {
- case ParameterKind::INVALID:
- return "INVALID";
- case ParameterKind::VOID:
- return "VOID";
- case ParameterKind::HALF:
- return "HALF";
- case ParameterKind::FLOAT:
- return "FLOAT";
- case ParameterKind::DOUBLE:
- return "DOUBLE";
- case ParameterKind::I1:
- return "I1";
- case ParameterKind::I8:
- return "I8";
- case ParameterKind::I16:
- return "I16";
- case ParameterKind::I32:
- return "I32";
- case ParameterKind::I64:
- return "I64";
- case ParameterKind::OVERLOAD:
- return "OVERLOAD";
- case ParameterKind::CBUFFER_RET:
- return "CBUFFER_RET";
- case ParameterKind::RESOURCE_RET:
- return "RESOURCE_RET";
- case ParameterKind::DXIL_HANDLE:
- return "DXIL_HANDLE";
- }
- llvm_unreachable("Unknown llvm::dxil::ParameterKind enum");
-}
-
-/// Return a string representation of OverloadKind enum that maps to
-/// input LLVMType record
-/// \param R TableGen def record of class LLVMType
-/// \return std::string string representation of OverloadKind
-
-static std::string getOverloadKindStr(const Record *R) {
- auto VTRec = R->getValueAsDef("VT");
- switch (getValueType(VTRec)) {
- case MVT::isVoid:
- return "OverloadKind::VOID";
- case MVT::f16:
- return "OverloadKind::HALF";
- case MVT::f32:
- return "OverloadKind::FLOAT";
- case MVT::f64:
- return "OverloadKin...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/86311
More information about the llvm-commits
mailing list