[llvm] Add support for intrinsic @llvm.frexp (PR #135774)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 15 03:21:06 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-spir-v
Author: VISHAKH PRAKASH (VishMCW)
<details>
<summary>Changes</summary>
Add conversion for intrinsic @<!-- -->llvm.frexp
Add necessary test file for the same
---
Full diff: https://github.com/llvm/llvm-project/pull/135774.diff
3 Files Affected:
- (modified) llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp (+87)
- (modified) llvm/lib/Target/SPIRV/SPIRVLegalizerInfo.cpp (+4)
- (added) llvm/test/CodeGen/SPIRV/llvm-intrinsics/frexp.ll (+147)
``````````diff
diff --git a/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp b/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
index 79f6b43f3aded..e7882d1435634 100644
--- a/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVInstructionSelector.cpp
@@ -276,6 +276,13 @@ class SPIRVInstructionSelector : public InstructionSelector {
bool selectExtInst(Register ResVReg, const SPIRVType *ResType,
MachineInstr &I, const ExtInstList &ExtInsts) const;
+ bool selectExtInstFREXP(Register ResVReg, const SPIRVType *ResType,
+ MachineInstr &I, CL::OpenCLExtInst CLInst,
+ GL::GLSLExtInst GLInst) const;
+
+ bool selectExtInstFREXP(Register ResVReg, const SPIRVType *ResType,
+ MachineInstr &I, const ExtInstList &ExtInsts) const;
+
bool selectLog10(Register ResVReg, const SPIRVType *ResType,
MachineInstr &I) const;
@@ -547,6 +554,18 @@ bool SPIRVInstructionSelector::select(MachineInstr &I) {
bool HasDefs = I.getNumDefs() > 0;
Register ResVReg = HasDefs ? I.getOperand(0).getReg() : Register(0);
SPIRVType *ResType = HasDefs ? GR.getSPIRVTypeForVReg(ResVReg) : nullptr;
+ if (!ResType) {
+ unsigned Opc = I.getOpcode();
+ switch (Opc) {
+ case TargetOpcode::G_FFREXP:
+ case TargetOpcode::G_SADDO:
+ case TargetOpcode::G_UADDO:
+ ResType = GR.assignIntTypeToVReg(32, ResVReg, I, TII);
+ break;
+ default:
+ break;
+ }
+ }
assert(!HasDefs || ResType || I.getOpcode() == TargetOpcode::G_GLOBAL_VALUE ||
I.getOpcode() == TargetOpcode::G_IMPLICIT_DEF);
if (spvSelect(ResVReg, ResType, I)) {
@@ -765,6 +784,9 @@ bool SPIRVInstructionSelector::spvSelect(Register ResVReg,
case TargetOpcode::G_FNEARBYINT:
return selectExtInst(ResVReg, ResType, I, CL::rint, GL::RoundEven);
+ case TargetOpcode::G_FFREXP:
+ return selectExtInstFREXP(ResVReg, ResType, I, CL::frexp, GL::Frexp);
+
case TargetOpcode::G_SMULH:
return selectExtInst(ResVReg, ResType, I, CL::s_mul_hi);
case TargetOpcode::G_UMULH:
@@ -1017,6 +1039,71 @@ bool SPIRVInstructionSelector::selectExtInst(Register ResVReg,
}
return false;
}
+bool SPIRVInstructionSelector::selectExtInstFREXP(
+ Register ResVReg, const SPIRVType *ResType, MachineInstr &I,
+ CL::OpenCLExtInst CLInst, GL::GLSLExtInst GLInst) const {
+ ExtInstList ExtInsts = {{SPIRV::InstructionSet::OpenCL_std, CLInst},
+ {SPIRV::InstructionSet::GLSL_std_450, GLInst}};
+ return selectExtInstFREXP(ResVReg, ResType, I, ExtInsts);
+}
+
+bool SPIRVInstructionSelector::selectExtInstFREXP(
+ Register ResVReg, const SPIRVType *ResType, MachineInstr &I,
+ const ExtInstList &ExtInsts) const {
+
+ for (const auto &Ex : ExtInsts) {
+ SPIRV::InstructionSet::InstructionSet Set = Ex.first;
+ uint32_t Opcode = Ex.second;
+ if (STI.canUseExtInstSet(Set)) {
+ Type *ResTy = nullptr;
+ StringRef ResName;
+ if (!GR.findValueAttrs(&I, ResTy, ResName))
+ report_fatal_error("Not enough info to select the frexp instruction");
+ if (!ResTy || !ResTy->isStructTy())
+ report_fatal_error("Expect struct type result for frexp instruction");
+
+ MachineIRBuilder MIRBuilder(I);
+
+ SPIRVType *IntType = GR.getOrCreateSPIRVIntegerType(32, I, TII);
+ const SPIRVType *PointerType = GR.getOrCreateSPIRVPointerType(
+ IntType, MIRBuilder, SPIRV::StorageClass::Function);
+ Register PointerVReg =
+ createVirtualRegister(PointerType, &GR, MRI, MRI->getMF());
+
+ auto It = getOpVariableMBBIt(I);
+ bool MIB =
+ BuildMI(*It->getParent(), It, It->getDebugLoc(),
+ TII.get(SPIRV::OpVariable))
+ .addDef(PointerVReg)
+ .addUse(GR.getSPIRVTypeID(PointerType))
+ .addImm(static_cast<uint32_t>(SPIRV::StorageClass::Function))
+ .constrainAllUses(TII, TRI, RBI);
+
+ MRI->setRegClass(I.getOperand(0).getReg(), &SPIRV::fIDRegClass);
+ MRI->setRegClass(I.getOperand(1).getReg(), &SPIRV::IDRegClass);
+ MIB = MIB & BuildMI(*It->getParent(), I, I.getDebugLoc(),
+ TII.get(SPIRV::OpExtInst))
+ .addDef(I.getOperand(0).getReg())
+ .addUse(GR.getSPIRVTypeID(
+ GR.getSPIRVTypeForVReg(I.getOperand(2).getReg())))
+ .addImm(static_cast<uint32_t>(Ex.first))
+ .addImm(Opcode)
+ .add(I.getOperand(2))
+ .addUse(PointerVReg)
+ .constrainAllUses(TII, TRI, RBI);
+
+ MIB = MIB & BuildMI(*It->getParent(), I, I.getDebugLoc(),
+ TII.get(SPIRV::OpLoad))
+ .addDef(I.getOperand(1).getReg())
+ .addUse(GR.getSPIRVTypeID(IntType))
+ .addUse(PointerVReg)
+ .constrainAllUses(TII, TRI, RBI);
+
+ return MIB;
+ }
+ }
+ return false;
+}
bool SPIRVInstructionSelector::selectOpWithSrcs(Register ResVReg,
const SPIRVType *ResType,
diff --git a/llvm/lib/Target/SPIRV/SPIRVLegalizerInfo.cpp b/llvm/lib/Target/SPIRV/SPIRVLegalizerInfo.cpp
index 578e82881f6e8..7467266cceab4 100644
--- a/llvm/lib/Target/SPIRV/SPIRVLegalizerInfo.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVLegalizerInfo.cpp
@@ -209,6 +209,10 @@ SPIRVLegalizerInfo::SPIRVLegalizerInfo(const SPIRVSubtarget &ST) {
.legalForCartesianProduct(allIntScalarsAndVectors)
.legalIf(extendedScalarsAndVectorsProduct);
+ getActionDefinitionsBuilder(G_FFREXP)
+ .legalForCartesianProduct(allFloatScalarsAndVectors,
+ allIntScalarsAndVectors);
+
// Extensions.
getActionDefinitionsBuilder({G_TRUNC, G_ZEXT, G_SEXT, G_ANYEXT})
.legalForCartesianProduct(allScalarsAndVectors)
diff --git a/llvm/test/CodeGen/SPIRV/llvm-intrinsics/frexp.ll b/llvm/test/CodeGen/SPIRV/llvm-intrinsics/frexp.ll
new file mode 100644
index 0000000000000..44c9617a5b970
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/llvm-intrinsics/frexp.ll
@@ -0,0 +1,147 @@
+; RUN: llc -verify-machineinstrs -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+; CHECK: %[[#extinst_id:]] = OpExtInstImport "OpenCL.std"
+declare { float, i32 } @llvm.frexp.f32.i32(float)
+declare { double, i32 } @llvm.frexp.f64.i32(double)
+declare { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float>)
+declare { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float>)
+declare { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double>)
+
+; CHECK: %[[#float_32_type:]] = OpTypeFloat 32
+; CHECK: %[[#int_32_type:]] = OpTypeInt 32 0
+; CHECK: %[[#fn_ptr_type1:]] = OpTypePointer Function %[[#int_32_type]]
+; CHECK: %[[#const_negzero:]] = OpConstant %[[#float_32_type]] -0
+; CHECK: %[[#float_64_type:]] = OpTypeFloat 64
+; CHECK: %[[#undef_double:]] = OpUndef %[[#float_64_type]]
+; CHECK: %[[#vec2_float_type:]] = OpTypeVector %[[#float_32_type]] 2
+; CHECK: %[[#vec2_int_type:]] = OpTypeVector %[[#int_32_type]] 2
+; CHECK: %[[#fn_ptr_type2:]] = OpTypePointer Function %[[#vec2_int_type]]
+; CHECK: %[[#vec2_null:]] = OpConstantNull %[[#vec2_float_type]]
+; CHECK: %[[#vec2_null2:]] = OpConstantNull %[[#float_32_type]]
+; CHECK: %[[#const_composite1:]] = OpConstantComposite %[[#vec2_float_type]] %[[#vec2_null2]] %[[#const_negzero]]
+; CHECK: %[[#vec4_float_type:]] = OpTypeVector %[[#float_32_type]] 4
+; CHECK: %[[#vec4_int_type:]] = OpTypeVector %[[#int_32_type]] 4
+; CHECK: %[[#fn_ptr_type3:]] = OpTypePointer Function %[[#vec4_int_type]]
+; CHECK: %[[#undef_float:]] = OpUndef %[[#float_32_type]]
+; CHECK: %[[#spec_const_op:]] = OpSpecConstantOp %[[#float_32_type]] 124 %[[#undef_float]]
+; CHECK: %[[#const_composite2:]] = OpConstantComposite %[[#vec4_float_type]] %[[#const_16:]] %[[#const_neg32:]] %[[#spec_const_op]] %[[#const_9999:]]
+; CHECK: %[[#vec2_double_type:]] = OpTypeVector %[[#float_64_type]] 2
+
+define i32 @frexp_negzero(float %x) {
+ ; CHECK: %[[#]] = OpFunction %[[#int_32_type]] None %[[#]]
+ ; CHECK: %[[#]] = OpFunctionParameter %[[#float_32_type]]
+ ; CHECK: %[[#var1:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#extinst1:]] = OpExtInst %[[#float_32_type]] %[[#extinst_id]] frexp %[[#const_negzero]] %[[#var1]]
+ ; CHECK: %[[#exp_part_var:]] = OpLoad %[[#int_32_type]] %[[#var1]]
+ ; CHECK: OpReturnValue %[[#exp_part_var]]
+ ; CHECK: OpFunctionEnd
+ %ret = call { float, i32 } @llvm.frexp.f32.i32(float -0.0)
+ %exp_part = extractvalue { float, i32 } %ret, 1
+ ret i32 %exp_part
+}
+
+define double @frexp_undef() {
+ ; CHECK: %[[#]] = OpFunction %[[#float_64_type]] None %[[#]]
+ ; CHECK: %[[#var2:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#extinst2:]] = OpExtInst %[[#float_64_type]] %[[#extinst_id]] frexp %[[#undef_double]] %[[#var2]]
+ ; CHECK: %[[#f_part_var:]] = OpLoad %[[#int_32_type]] %[[#var2]]
+ ; CHECK: OpReturnValue %[[#extinst2]]
+ ; CHECK: OpFunctionEnd
+
+ %ret = call { double, i32 } @llvm.frexp.f64.i32(double undef)
+ %f_part = extractvalue { double, i32 } %ret, 0
+ ret double %f_part
+}
+
+define <2 x float> @frexp_zero_vector() {
+ ; CHECK: %[[#]] = OpFunction %[[#vec2_float_type]] None %[[#]]
+ ; CHECK: %[[#var3:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#bitcast1:]] = OpBitcast %[[#fn_ptr_type2]] %[[#var3]]
+ ; CHECK: %[[#extinst3:]] = OpExtInst %[[#vec2_float_type]] %[[#extinst_id]] frexp %[[#vec2_null]] %[[#bitcast1]]
+ ; CHECK: %[[#f_part_var2:]] = OpLoad %[[#int_32_type]] %[[#var3]]
+ ; CHECK: OpReturnValue %[[#extinst3]]
+ ; CHECK: OpFunctionEnd
+
+ %ret = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> zeroinitializer)
+ %f_part = extractvalue { <2 x float>, <2 x i32> } %ret, 0
+ ret <2 x float> %f_part
+}
+
+define <2 x float> @frexp_zero_negzero_vector() {
+ ; CHECK: %[[#]] = OpFunction %[[#vec2_float_type]] None %[[#]]
+ ; CHECK: %[[#var4:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#bitcast2:]] = OpBitcast %[[#fn_ptr_type2]] %[[#var4]]
+ ; CHECK: %[[#extinst4:]] = OpExtInst %[[#vec2_float_type]] %[[#extinst_id]] frexp %[[#const_composite1]] %[[#bitcast2]]
+ ; CHECK: %[[#f_part_var3:]] = OpLoad %[[#int_32_type]] %[[#var4]]
+ ; CHECK: OpReturnValue %[[#extinst4]]
+ ; CHECK: OpFunctionEnd
+ %ret = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> <float 0.0, float -0.0>)
+ %f_part = extractvalue { <2 x float>, <2 x i32> } %ret, 0
+ ret <2 x float> %f_part
+}
+
+define <4 x float> @frexp_nonsplat_vector() {
+ ; CHECK: %[[#]] = OpFunction %[[#vec4_float_type]] None %[[#]]
+ ; CHECK: %[[#var5:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#bitcast3:]] = OpBitcast %[[#fn_ptr_type3]] %[[#var5]]
+ ; CHECK: %[[#extinst5:]] = OpExtInst %[[#vec4_float_type]] %[[#extinst_id]] frexp %[[#const_composite2]] %[[#bitcast3]]
+ ; CHECK: %[[#f_part_var4:]] = OpLoad %[[#int_32_type]] %[[#var5]]
+ ; CHECK: OpReturnValue %[[#extinst5]]
+ ; CHECK: OpFunctionEnd
+
+ %ret = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> <float 16.0, float -32.0, float undef, float 9999.0>)
+ %f_part = extractvalue { <4 x float>, <4 x i32> } %ret, 0
+ ret <4 x float> %f_part
+}
+
+define float @frexp_frexp(float %x) {
+ ; CHECK: %[[#]] = OpFunction %[[#float_32_type]] None %[[#]]
+ ; CHECK: %[[#x_var2:]] = OpFunctionParameter %[[#float_32_type]]
+ ; CHECK: %[[#var6:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#var7:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#extinst6:]] = OpExtInst %[[#float_32_type]] %[[#extinst_id]] frexp %[[#x_var2]] %[[#var6]]
+ ; CHECK: %[[#load1:]] = OpLoad %[[#int_32_type]] %[[#var6]]
+ ; CHECK: %[[#extinst7:]] = OpExtInst %[[#float_32_type]] %[[#extinst_id]] frexp %[[#extinst6]] %[[#var7]]
+ ; CHECK: %[[#f_part_var5:]] = OpLoad %[[#int_32_type]] %[[#var7]]
+ ; CHECK: OpReturnValue %[[#extinst7]]
+ ; CHECK: OpFunctionEnd
+ %frexp0 = call { float, i32 } @llvm.frexp.f32.i32(float %x)
+ %frexp0_0 = extractvalue { float, i32 } %frexp0, 0
+ %frexp1 = call { float, i32 } @llvm.frexp.f32.i32(float %frexp0_0)
+ %f_part = extractvalue { float, i32 } %frexp1, 0
+ ret float %f_part
+}
+
+define <2 x double> @frexp_frexp_vector(<2 x double> %x) {
+ ; CHECK: %[[#]] = OpFunction %[[#vec2_double_type]] None %[[#]]
+ ; CHECK: %[[#x_var3:]] = OpFunctionParameter %[[#vec2_double_type]]
+ ; CHECK: %[[#var8:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#var9:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#bitcast4:]] = OpBitcast %[[#fn_ptr_type2]] %[[#var8]]
+ ; CHECK: %[[#extinst8:]] = OpExtInst %[[#vec2_double_type]] %[[#extinst_id]] frexp %[[#x_var3]] %[[#bitcast4]]
+ ; CHECK: %[[#load2:]] = OpLoad %[[#int_32_type]] %[[#var8]]
+ ; CHECK: %[[#bitcast5:]] = OpBitcast %[[#fn_ptr_type2]] %[[#var9]]
+ ; CHECK: %[[#extinst9:]] = OpExtInst %[[#vec2_double_type]] %[[#extinst_id]] frexp %[[#extinst8]] %[[#bitcast5]]
+ ; CHECK: %[[#f_part_var6:]] = OpLoad %[[#int_32_type]] %[[#var9]]
+ ; CHECK: OpReturnValue %[[#extinst9]]
+ ; CHECK: OpFunctionEnd
+ %frexp0 = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %x)
+ %frexp0_0 = extractvalue { <2 x double>, <2 x i32> } %frexp0, 0
+ %frexp1 = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %frexp0_0)
+ %f_part = extractvalue { <2 x double>, <2 x i32> } %frexp1, 0
+ ret <2 x double> %f_part
+}
+
+define i32 @frexp_frexp_get_int(float %x) {
+ ; CHECK: %[[#]] = OpFunction %[[#int_32_type]] None %[[#]]
+ ; CHECK: %[[#x_var4:]] = OpFunctionParameter %[[#float_32_type]]
+ ; CHECK: %[[#var10:]] = OpVariable %[[#fn_ptr_type1]] Function
+ ; CHECK: %[[#extinst10:]] = OpExtInst %[[#float_32_type]] %[[#extinst_id]] frexp %[[#x_var4]] %[[#var10]]
+ ; CHECK: %[[#exp_part_var2:]] = OpLoad %[[#int_32_type]] %[[#var10]]
+ ; CHECK: OpReturnValue %[[#exp_part_var2]]
+ ; CHECK: OpFunctionEnd
+ %frexp0 = call { float, i32 } @llvm.frexp.f32.i32(float %x)
+ %exp_part = extractvalue { float, i32 } %frexp0, 1
+ ret i32 %exp_part
+}
+
+
``````````
</details>
https://github.com/llvm/llvm-project/pull/135774
More information about the llvm-commits
mailing list