[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