[llvm] DAGCombiner::visitBITCAST: CastLoad strip AssertNoFPClass (PR #184952)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 5 21:53:42 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-selectiondag
@llvm/pr-subscribers-backend-mips
Author: YunQiang Su (wzssyqa)
<details>
<summary>Changes</summary>
If N0 is wrapped with AssertNoFPClass, let's strip it,
so that ISD::isNormalLoad can recognize it as Load.
---
Patch is 39.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/184952.diff
6 Files Affected:
- (modified) llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp (+2)
- (modified) llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp (+61)
- (modified) llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.bf16.ll (+16-34)
- (modified) llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.f16.ll (+4-9)
- (modified) llvm/test/CodeGen/Mips/is_fpclass.ll (+524-141)
- (modified) llvm/test/CodeGen/X86/is_fpclass.ll (+250)
``````````diff
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 02490587330fd..173c519b0c17b 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -17209,6 +17209,8 @@ SDValue DAGCombiner::visitBITCAST(SDNode *N) {
// fold (conv (freeze (load x))) -> (freeze (load (conv*)x))
// If the resultant load doesn't need a higher alignment than the original!
auto CastLoad = [this, &VT](SDValue N0, const SDLoc &DL) {
+ if (N0.getOpcode() == ISD::AssertNoFPClass)
+ N0 = N0.getOperand(0);
if (!ISD::isNormalLoad(N0.getNode()) || !N0.hasOneUse())
return SDValue();
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 088e6726fea58..71275d61e7fc1 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -9306,6 +9306,67 @@ SDValue TargetLowering::expandIS_FPCLASS(EVT ResultVT, SDValue Op,
// Tests that involve more than one class should be processed first.
SDValue PartialRes;
+ // Handle sign bit tests first (fcPositive/fcNegative).
+ // These test only the sign bit, if not NaN.
+ // On 32-bit platforms with 64-bit floats, we need to be careful about
+ // integer comparisons. We use FP_ROUND to convert to a smaller float type
+ // that matches ResultVT's size, then compare with 0.
+ if (Test == fcPositive || Test == fcNegative) {
+ SDValue SignBitResult;
+ unsigned MaxLegalIntBits = 32;
+ if (isTypeLegal(MVT::i64))
+ MaxLegalIntBits = 64;
+
+ unsigned IntVTBits = IntVT.getScalarSizeInBits();
+ bool NeedFPCompare = IntVTBits > MaxLegalIntBits;
+
+ if (NeedFPCompare) {
+ // Truncate to the largest legal float type.
+ EVT TruncFloatEltVT = EVT::getFloatingPointVT(MaxLegalIntBits);
+
+ EVT TruncFloatVT = TruncFloatEltVT;
+ if (ResultVT.isVector() && TruncFloatEltVT != MVT::Other) {
+ TruncFloatVT = EVT::getVectorVT(*DAG.getContext(), TruncFloatEltVT,
+ ResultVT.getVectorElementCount());
+ }
+ if (TruncFloatVT != MVT::Other &&
+ isOperationLegalOrCustom(ISD::FP_ROUND, TruncFloatVT)) {
+ // Round to smaller float type, then bitcast to integer for sign check.
+ // Use TargetConstant for the truncation flag.
+ EVT PointerVT = getPointerTy(DAG.getDataLayout());
+ SDValue OpTrunc = DAG.getNode(ISD::FP_ROUND, DL, TruncFloatVT, Op,
+ DAG.getTargetConstant(0, DL, PointerVT));
+ EVT TruncIntVT = TruncFloatVT.changeTypeToInteger();
+ SDValue OpTruncInt = DAG.getBitcast(TruncIntVT, OpTrunc);
+ SignBitResult =
+ DAG.getSetCC(DL, ResultVT, OpTruncInt,
+ DAG.getConstant(0, DL, TruncIntVT), ISD::SETLT);
+ } else {
+ // Fall back to original integer comparison.
+ SignBitResult = SignV;
+ }
+ } else {
+ SignBitResult = SignV;
+ }
+
+ if (!DAG.isKnownNeverNaN(Op)) {
+ SDValue NotNaN = DAG.getSetCC(DL, ResultVT, Op, Op, ISD::SETO);
+ SignBitResult =
+ DAG.getNode(ISD::AND, DL, ResultVT, NotNaN, SignBitResult);
+ }
+
+ bool IsICmpImmLegal =
+ isLegalICmpImmediate(APInt::getAllOnes(IntVTBits).getZExtValue());
+ if (!NeedFPCompare && (!DAG.isKnownNeverNaN(Op) || IsICmpImmLegal) &&
+ Test == fcPositive) {
+ ; // (fcPosInf | fcFinite) has better performance.
+ } else if (Test == fcNegative)
+ return SignBitResult;
+ else
+ return DAG.getNode(ISD::XOR, DL, ResultVT, SignBitResult,
+ ResultInversionMask);
+ }
+
if (IsF80)
; // Detect finite numbers of f80 by checking individual classes because
// they have different settings of the explicit integer bit.
diff --git a/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.bf16.ll b/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.bf16.ll
index d80fb6d8ea108..80ec6fa104b31 100644
--- a/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.bf16.ll
+++ b/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.bf16.ll
@@ -2123,80 +2123,62 @@ define i1 @isnegative_bf16(bfloat %x) {
; GFX7CHECK-LABEL: isnegative_bf16:
; GFX7CHECK: ; %bb.0:
; GFX7CHECK-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX7CHECK-NEXT: v_and_b32_e32 v1, 0xffff, v0
-; GFX7CHECK-NEXT: v_lshlrev_b32_e32 v2, 16, v0
-; GFX7CHECK-NEXT: v_and_b32_e32 v0, 0x7fff, v0
-; GFX7CHECK-NEXT: s_movk_i32 s4, 0x7f80
-; GFX7CHECK-NEXT: v_cmp_gt_i32_e32 vcc, 0, v2
-; GFX7CHECK-NEXT: v_cmp_gt_i32_e64 s[4:5], s4, v0
-; GFX7CHECK-NEXT: s_mov_b32 s6, 0xff80
+; GFX7CHECK-NEXT: v_lshlrev_b32_e32 v0, 16, v0
+; GFX7CHECK-NEXT: v_cmp_gt_i32_e32 vcc, 0, v0
+; GFX7CHECK-NEXT: v_cmp_o_f32_e64 s[4:5], v0, v0
; GFX7CHECK-NEXT: s_and_b64 s[4:5], s[4:5], vcc
-; GFX7CHECK-NEXT: v_cmp_eq_u32_e32 vcc, s6, v1
-; GFX7CHECK-NEXT: s_or_b64 s[4:5], s[4:5], vcc
; GFX7CHECK-NEXT: v_cndmask_b32_e64 v0, 0, 1, s[4:5]
; GFX7CHECK-NEXT: s_setpc_b64 s[30:31]
;
; GFX8CHECK-LABEL: isnegative_bf16:
; GFX8CHECK: ; %bb.0:
; GFX8CHECK-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX8CHECK-NEXT: v_and_b32_e32 v1, 0x7fff, v0
-; GFX8CHECK-NEXT: s_movk_i32 s4, 0x7f80
; GFX8CHECK-NEXT: v_cmp_gt_i16_e32 vcc, 0, v0
-; GFX8CHECK-NEXT: v_cmp_gt_i16_e64 s[4:5], s4, v1
-; GFX8CHECK-NEXT: s_movk_i32 s6, 0xff80
+; GFX8CHECK-NEXT: v_lshlrev_b32_e32 v0, 16, v0
+; GFX8CHECK-NEXT: v_cmp_o_f32_e64 s[4:5], v0, v0
; GFX8CHECK-NEXT: s_and_b64 s[4:5], s[4:5], vcc
-; GFX8CHECK-NEXT: v_cmp_eq_u16_e32 vcc, s6, v0
-; GFX8CHECK-NEXT: s_or_b64 s[4:5], s[4:5], vcc
; GFX8CHECK-NEXT: v_cndmask_b32_e64 v0, 0, 1, s[4:5]
; GFX8CHECK-NEXT: s_setpc_b64 s[30:31]
;
; GFX9CHECK-LABEL: isnegative_bf16:
; GFX9CHECK: ; %bb.0:
; GFX9CHECK-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX9CHECK-NEXT: v_and_b32_e32 v1, 0x7fff, v0
-; GFX9CHECK-NEXT: s_movk_i32 s4, 0x7f80
; GFX9CHECK-NEXT: v_cmp_gt_i16_e32 vcc, 0, v0
-; GFX9CHECK-NEXT: v_cmp_gt_i16_e64 s[4:5], s4, v1
-; GFX9CHECK-NEXT: s_movk_i32 s6, 0xff80
+; GFX9CHECK-NEXT: v_lshlrev_b32_e32 v0, 16, v0
+; GFX9CHECK-NEXT: v_cmp_o_f32_e64 s[4:5], v0, v0
; GFX9CHECK-NEXT: s_and_b64 s[4:5], s[4:5], vcc
-; GFX9CHECK-NEXT: v_cmp_eq_u16_e32 vcc, s6, v0
-; GFX9CHECK-NEXT: s_or_b64 s[4:5], s[4:5], vcc
; GFX9CHECK-NEXT: v_cndmask_b32_e64 v0, 0, 1, s[4:5]
; GFX9CHECK-NEXT: s_setpc_b64 s[30:31]
;
; GFX10CHECK-LABEL: isnegative_bf16:
; GFX10CHECK: ; %bb.0:
; GFX10CHECK-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX10CHECK-NEXT: v_and_b32_e32 v1, 0x7fff, v0
+; GFX10CHECK-NEXT: v_lshlrev_b32_e32 v1, 16, v0
; GFX10CHECK-NEXT: v_cmp_gt_i16_e32 vcc_lo, 0, v0
-; GFX10CHECK-NEXT: v_cmp_eq_u16_e64 s5, 0xff80, v0
-; GFX10CHECK-NEXT: v_cmp_gt_i16_e64 s4, 0x7f80, v1
+; GFX10CHECK-NEXT: v_cmp_o_f32_e64 s4, v1, v1
; GFX10CHECK-NEXT: s_and_b32 s4, s4, vcc_lo
-; GFX10CHECK-NEXT: s_or_b32 s4, s4, s5
; GFX10CHECK-NEXT: v_cndmask_b32_e64 v0, 0, 1, s4
; GFX10CHECK-NEXT: s_setpc_b64 s[30:31]
;
; GFX11SELDAG-TRUE16-LABEL: isnegative_bf16:
; GFX11SELDAG-TRUE16: ; %bb.0:
; GFX11SELDAG-TRUE16-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX11SELDAG-TRUE16-NEXT: v_and_b16 v0.h, 0x7fff, v0.l
-; GFX11SELDAG-TRUE16-NEXT: v_cmp_gt_i16_e32 vcc_lo, 0, v0.l
-; GFX11SELDAG-TRUE16-NEXT: v_cmp_eq_u16_e64 s1, 0xff80, v0.l
-; GFX11SELDAG-TRUE16-NEXT: v_cmp_gt_i16_e64 s0, 0x7f80, v0.h
+; GFX11SELDAG-TRUE16-NEXT: v_mov_b16_e32 v2.l, 0
+; GFX11SELDAG-TRUE16-NEXT: v_mov_b16_e32 v1.l, v0.l
+; GFX11SELDAG-TRUE16-NEXT: v_mov_b16_e32 v2.h, v0.l
+; GFX11SELDAG-TRUE16-NEXT: v_cmp_gt_i16_e32 vcc_lo, 0, v1.l
+; GFX11SELDAG-TRUE16-NEXT: v_cmp_o_f32_e64 s0, v2, v2
; GFX11SELDAG-TRUE16-NEXT: s_and_b32 s0, s0, vcc_lo
-; GFX11SELDAG-TRUE16-NEXT: s_or_b32 s0, s0, s1
; GFX11SELDAG-TRUE16-NEXT: v_cndmask_b32_e64 v0, 0, 1, s0
; GFX11SELDAG-TRUE16-NEXT: s_setpc_b64 s[30:31]
;
; GFX11SELDAG-FAKE16-LABEL: isnegative_bf16:
; GFX11SELDAG-FAKE16: ; %bb.0:
; GFX11SELDAG-FAKE16-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX11SELDAG-FAKE16-NEXT: v_and_b32_e32 v1, 0x7fff, v0
+; GFX11SELDAG-FAKE16-NEXT: v_lshlrev_b32_e32 v1, 16, v0
; GFX11SELDAG-FAKE16-NEXT: v_cmp_gt_i16_e32 vcc_lo, 0, v0
-; GFX11SELDAG-FAKE16-NEXT: v_cmp_eq_u16_e64 s1, 0xff80, v0
-; GFX11SELDAG-FAKE16-NEXT: v_cmp_gt_i16_e64 s0, 0x7f80, v1
+; GFX11SELDAG-FAKE16-NEXT: v_cmp_o_f32_e64 s0, v1, v1
; GFX11SELDAG-FAKE16-NEXT: s_and_b32 s0, s0, vcc_lo
-; GFX11SELDAG-FAKE16-NEXT: s_or_b32 s0, s0, s1
; GFX11SELDAG-FAKE16-NEXT: v_cndmask_b32_e64 v0, 0, 1, s0
; GFX11SELDAG-FAKE16-NEXT: s_setpc_b64 s[30:31]
%class = tail call i1 @llvm.is.fpclass.bf16(bfloat %x, i32 60) ; fcNegative
diff --git a/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.f16.ll b/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.f16.ll
index 76958e63d36c9..1b3527a0b5d49 100644
--- a/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.f16.ll
+++ b/llvm/test/CodeGen/AMDGPU/llvm.is.fpclass.f16.ll
@@ -3053,16 +3053,11 @@ define i1 @isnegative_f16(half %x) {
; GFX7SELDAG-LABEL: isnegative_f16:
; GFX7SELDAG: ; %bb.0:
; GFX7SELDAG-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
-; GFX7SELDAG-NEXT: v_and_b32_e32 v1, 0xffff, v0
-; GFX7SELDAG-NEXT: v_lshlrev_b32_e32 v2, 16, v0
-; GFX7SELDAG-NEXT: v_and_b32_e32 v0, 0x7fff, v0
-; GFX7SELDAG-NEXT: s_movk_i32 s4, 0x7c00
-; GFX7SELDAG-NEXT: v_cmp_gt_i32_e32 vcc, 0, v2
-; GFX7SELDAG-NEXT: v_cmp_gt_i32_e64 s[4:5], s4, v0
-; GFX7SELDAG-NEXT: s_mov_b32 s6, 0xfc00
+; GFX7SELDAG-NEXT: v_cvt_f32_f16_e32 v1, v0
+; GFX7SELDAG-NEXT: v_lshlrev_b32_e32 v0, 16, v0
+; GFX7SELDAG-NEXT: v_cmp_gt_i32_e32 vcc, 0, v0
+; GFX7SELDAG-NEXT: v_cmp_o_f32_e64 s[4:5], v1, v1
; GFX7SELDAG-NEXT: s_and_b64 s[4:5], s[4:5], vcc
-; GFX7SELDAG-NEXT: v_cmp_eq_u32_e32 vcc, s6, v1
-; GFX7SELDAG-NEXT: s_or_b64 s[4:5], s[4:5], vcc
; GFX7SELDAG-NEXT: v_cndmask_b32_e64 v0, 0, 1, s[4:5]
; GFX7SELDAG-NEXT: s_setpc_b64 s[30:31]
;
diff --git a/llvm/test/CodeGen/Mips/is_fpclass.ll b/llvm/test/CodeGen/Mips/is_fpclass.ll
index 9454a064c5312..66c3e3bee09a2 100644
--- a/llvm/test/CodeGen/Mips/is_fpclass.ll
+++ b/llvm/test/CodeGen/Mips/is_fpclass.ll
@@ -1,246 +1,629 @@
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc -mtriple=mipsisa32r6-unknown-linux-gnu -verify-machineinstrs -o - %s | FileCheck %s
+; RUN: llc -mtriple=mipsisa32r6-unknown-linux-gnu -o - %s | FileCheck %s --check-prefix=R6
+; RUN: llc -mtriple=mipsel-unknown-linux-gnu -o - %s | FileCheck %s --check-prefix=R2
define i1 @isnan_float(float %x) nounwind {
-; CHECK-LABEL: isnan_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 3
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isnan_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 3
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isnan_float:
+; R2: # %bb.0:
+; R2-NEXT: addiu $2, $zero, 1
+; R2-NEXT: c.un.s $f12, $f12
+; R2-NEXT: jr $ra
+; R2-NEXT: movf $2, $zero, $fcc0
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 3) ; nan
ret i1 %1
}
define i1 @isnan_double(double %x) nounwind {
-; CHECK-LABEL: isnan_double:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.d $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 3
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isnan_double:
+; R6: # %bb.0:
+; R6-NEXT: class.d $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 3
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isnan_double:
+; R2: # %bb.0:
+; R2-NEXT: addiu $2, $zero, 1
+; R2-NEXT: c.un.d $f12, $f12
+; R2-NEXT: jr $ra
+; R2-NEXT: movf $2, $zero, $fcc0
%1 = call i1 @llvm.is.fpclass.f64(double %x, i32 3) ; nan
ret i1 %1
}
define i1 @isnan_float_strictfp(float %x) strictfp nounwind {
-; CHECK-LABEL: isnan_float_strictfp:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 3
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isnan_float_strictfp:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 3
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isnan_float_strictfp:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 32640
+; R2-NEXT: jr $ra
+; R2-NEXT: slt $2, $2, $1
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 3) strictfp ; nan
ret i1 %1
}
define i1 @isnan_double_strictfp(double %x) strictfp nounwind {
-; CHECK-LABEL: isnan_double_strictfp:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.d $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 3
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isnan_double_strictfp:
+; R6: # %bb.0:
+; R6-NEXT: class.d $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 3
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isnan_double_strictfp:
+; R2: # %bb.0:
+; R2-NEXT: addiu $sp, $sp, -8
+; R2-NEXT: sdc1 $f12, 0($sp)
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: lw $2, 4($sp)
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $3, 32752
+; R2-NEXT: slt $2, $3, $1
+; R2-NEXT: xor $1, $1, $3
+; R2-NEXT: lw $3, 0($sp)
+; R2-NEXT: sltu $3, $zero, $3
+; R2-NEXT: movz $2, $3, $1
+; R2-NEXT: jr $ra
+; R2-NEXT: addiu $sp, $sp, 8
%1 = call i1 @llvm.is.fpclass.f64(double %x, i32 3) strictfp ; nan
ret i1 %1
}
define i1 @isinf_float(float %x) nounwind {
-; CHECK-LABEL: isinf_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 68
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isinf_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 68
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isinf_float:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 32640
+; R2-NEXT: xor $1, $1, $2
+; R2-NEXT: jr $ra
+; R2-NEXT: sltiu $2, $1, 1
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 516) ; 0x204 = "inf"
ret i1 %1
}
define i1 @isfinite_float(float %x) nounwind {
-; CHECK-LABEL: isfinite_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 952
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isfinite_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 952
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isfinite_float:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 32640
+; R2-NEXT: jr $ra
+; R2-NEXT: slt $2, $1, $2
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 504) ; 0x1f8 = "finite"
ret i1 %1
}
define i1 @isnormal_float(float %x) nounwind {
-; CHECK-LABEL: isnormal_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 136
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: isnormal_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 136
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: isnormal_float:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 65408
+; R2-NEXT: addu $1, $1, $2
+; R2-NEXT: srl $1, $1, 24
+; R2-NEXT: jr $ra
+; R2-NEXT: sltiu $2, $1, 127
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 264) ; 0x108 = "normal"
ret i1 %1
}
define i1 @issubnormal_float(float %x) nounwind {
-; CHECK-LABEL: issubnormal_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 272
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: issubnormal_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 272
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: issubnormal_float:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: addiu $1, $1, -1
+; R2-NEXT: lui $2, 127
+; R2-NEXT: ori $2, $2, 65535
+; R2-NEXT: jr $ra
+; R2-NEXT: sltu $2, $1, $2
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 144) ; 0x90 = "subnormal"
ret i1 %1
}
define i1 @iszero_float(float %x) nounwind {
-; CHECK-LABEL: iszero_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 544
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: iszero_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 544
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: iszero_float:
+; R2: # %bb.0:
+; R2-NEXT: mtc1 $zero, $f0
+; R2-NEXT: addiu $2, $zero, 1
+; R2-NEXT: c.eq.s $f12, $f0
+; R2-NEXT: jr $ra
+; R2-NEXT: movf $2, $zero, $fcc0
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 96) ; 0x60 = "zero"
ret i1 %1
}
define i1 @issnan_float(float %x) nounwind {
-; CHECK-LABEL: issnan_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.s $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 1
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: issnan_float:
+; R6: # %bb.0:
+; R6-NEXT: class.s $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 1
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: issnan_float:
+; R2: # %bb.0:
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: mfc1 $2, $f12
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 32704
+; R2-NEXT: slt $2, $1, $2
+; R2-NEXT: lui $3, 32640
+; R2-NEXT: slt $1, $3, $1
+; R2-NEXT: jr $ra
+; R2-NEXT: and $2, $1, $2
%1 = call i1 @llvm.is.fpclass.f32(float %x, i32 1)
ret i1 %1
}
define i1 @issnan_double(double %x) nounwind {
-; CHECK-LABEL: issnan_double:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class.d $f0, $f12
-; CHECK-NEXT: mfc1 $1, $f0
-; CHECK-NEXT: andi $1, $1, 1
-; CHECK-NEXT: jr $ra
-; CHECK-NEXT: sltu $2, $zero, $1
+; R6-LABEL: issnan_double:
+; R6: # %bb.0:
+; R6-NEXT: class.d $f0, $f12
+; R6-NEXT: mfc1 $1, $f0
+; R6-NEXT: andi $1, $1, 1
+; R6-NEXT: jr $ra
+; R6-NEXT: sltu $2, $zero, $1
+;
+; R2-LABEL: issnan_double:
+; R2: # %bb.0:
+; R2-NEXT: addiu $sp, $sp, -8
+; R2-NEXT: sdc1 $f12, 0($sp)
+; R2-NEXT: lui $1, 32767
+; R2-NEXT: ori $1, $1, 65535
+; R2-NEXT: lw $2, 4($sp)
+; R2-NEXT: and $1, $2, $1
+; R2-NEXT: lui $2, 32752
+; R2-NEXT: slt $3, $2, $1
+; R2-NEXT: xor $2, $1, $2
+; R2-NEXT: lw $4, 0($sp)
+; R2-NEXT: sltu $4, $zero, $4
+; R2-NEXT: movz $3, $4, $2
+; R2-NEXT: lui $2, 32760
+; R2-NEXT: slt $1, $1, $2
+; R2-NEXT: and $2, $3, $1
+; R2-NEXT: jr $ra
+; R2-NEXT: addiu $sp, $sp, 8
%1 = call i1 @llvm.is.fpclass.f64(double %x, i32 1)
ret i1 %1
}
define i1 @isqnan_float(float %x) nounwind {
-; CHECK-LABEL: isqnan_float:
-; CHECK: # %bb.0:
-; CHECK-NEXT: class...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/184952
More information about the llvm-commits
mailing list