[SelectionDAG] Add FP_TO_UINT_SAT/FP_TO_SINT_SAT to computeKnownBits/computeNumSignBits.

[craig.topper]

Summary

These nodes should saturate to their saturating VT. We can use this
information to know the bits past the VT are all zeros or all sign bits.

I think we might only have test coverage for the unsigned case. I'll
verify and add tests.

[craig.topper]

Rebase after adding more tests including tests for sign bits.

[nikic]

LGTM

[foad]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3588

"UINT"

[foad]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3588

Could you also update the comments for FP_TO_[US]INT_SAT in include/llvm/CodeGen/ISDOpcodes.h to document the properties you are relying on here? Currently it says nothing about the value of the bits between the saturating type and the result type.

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3588

Added in 9ef2175f812a9308cbcefc4729f6a6c9e75c2b6f

[foad]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3588

Thanks!

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

case ISD::SMAX: {
     Known = computeKnownBits(Op.getOperand(0), DemandedElts, Depth + 1);
     Known2 = computeKnownBits(Op.getOperand(1), DemandedElts, Depth + 1);
     if (IsMax)
       Known = KnownBits::smax(Known, Known2);
     else
       Known = KnownBits::smin(Known, Known2);
     break;
   }
+  case ISD::FP_TO_UINT_SAT: {
+    // FP_TO_UINT_SAT produces an unsigned value that fits in the saturating VT.
+    EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
+    Known.Zero |= APInt::getBitsSetFrom(BitWidth, VT.getScalarSizeInBits());
+    break;
+  }
   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
     if (Op.getResNo() == 1) {
       // The boolean result conforms to getBooleanContents.
       // If we know the result of a setcc has the top bits zero, use this info.
       // We know that we have an integer-based boolean since these operations
       // are only available for integer.
       if (TLI->getBooleanContents(Op.getValueType().isVector(), false) ==
               TargetLowering::ZeroOrOneBooleanContent &&
if ((SrcBits % VTBits) == 0) {
             return 1;
           Tmp2 = std::min(Tmp2, Tmp - SubOffset);
         }
       return Tmp2;
     }
     break;
   }
 
+  case ISD::FP_TO_SINT_SAT:
+    // FP_TO_SINT_SAT produces a signed value that fits in the saturating VT.
+    Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getScalarSizeInBits();
+    return VTBits - Tmp + 1;
   case ISD::SIGN_EXTEND:
     Tmp = VTBits - Op.getOperand(0).getScalarValueSizeInBits();
     return ComputeNumSignBits(Op.getOperand(0), DemandedElts, Depth+1) + Tmp;
   case ISD::SIGN_EXTEND_INREG:
     // Max of the input and what this extends.
     Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getScalarSizeInBits();
     Tmp = VTBits-Tmp+1;
     Tmp2 = ComputeNumSignBits(Op.getOperand(0), DemandedElts, Depth+1);

llvm/test/CodeGen/AArch64/fcvt_combine.ll

 }
 
 define <4 x i32> @test_extrasat(<4 x float> %f) {
 ; CHECK-LABEL: test_extrasat:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    movi v1.2d, #0xffffff00ffffff
 ; CHECK-NEXT:    fcvtzu v0.4s, v0.4s, #3
 ; CHECK-NEXT:    umin v0.4s, v0.4s, v1.4s
-; CHECK-NEXT:    bic v0.4s, #255, lsl #24
 ; CHECK-NEXT:    ret
   %mul.i = fmul <4 x float> %f, <float 8.000000e+00, float 8.000000e+00, float 8.000000e+00, float 8.000000e+00>
   %vcvt.i = call <4 x i24> @llvm.fptoui.sat.v4i24.v4f32(<4 x float> %mul.i)
   %t = zext <4 x i24> %vcvt.i to <4 x i32>
   ret <4 x i32> %t
 }

llvm/test/CodeGen/AArch64/fptoui-sat-scalar.ll

 declare i100 @llvm.fptoui.sat.i100.f32(float)
 declare i128 @llvm.fptoui.sat.i128.f32(float)
 
 define i1 @test_unsigned_i1_f32(float %f) nounwind {
 ; CHECK-LABEL: test_unsigned_i1_f32:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    fcvtzu w8, s0
 ; CHECK-NEXT:    cmp w8, #1
-; CHECK-NEXT:    csinc w8, w8, wzr, lo
-; CHECK-NEXT:    and w0, w8, #0x1
+; CHECK-NEXT:    csinc w0, w8, wzr, lo
 ; CHECK-NEXT:    ret
     %x = call i1 @llvm.fptoui.sat.i1.f32(float %f)
     ret i1 %x
 }
 
 define i8 @test_unsigned_i8_f32(float %f) nounwind {
 ; CHECK-LABEL: test_unsigned_i8_f32:
 ; CHECK:       // %bb.0:

 declare i100 @llvm.fptoui.sat.i100.f64(double)
 declare i128 @llvm.fptoui.sat.i128.f64(double)
 
 define i1 @test_unsigned_i1_f64(double %f) nounwind {
 ; CHECK-LABEL: test_unsigned_i1_f64:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    fcvtzu w8, d0
 ; CHECK-NEXT:    cmp w8, #1
-; CHECK-NEXT:    csinc w8, w8, wzr, lo
-; CHECK-NEXT:    and w0, w8, #0x1
+; CHECK-NEXT:    csinc w0, w8, wzr, lo
 ; CHECK-NEXT:    ret
     %x = call i1 @llvm.fptoui.sat.i1.f64(double %f)
     ret i1 %x
 }
 
 define i8 @test_unsigned_i8_f64(double %f) nounwind {
 ; CHECK-LABEL: test_unsigned_i8_f64:
 ; CHECK:       // %bb.0:

 declare i128 @llvm.fptoui.sat.i128.f16(half)
 
 define i1 @test_unsigned_i1_f16(half %f) nounwind {
 ; CHECK-CVT-LABEL: test_unsigned_i1_f16:
 ; CHECK-CVT:       // %bb.0:
 ; CHECK-CVT-NEXT:    fcvt s0, h0
 ; CHECK-CVT-NEXT:    fcvtzu w8, s0
 ; CHECK-CVT-NEXT:    cmp w8, #1
-; CHECK-CVT-NEXT:    csinc w8, w8, wzr, lo
-; CHECK-CVT-NEXT:    and w0, w8, #0x1
+; CHECK-CVT-NEXT:    csinc w0, w8, wzr, lo
 ; CHECK-CVT-NEXT:    ret
 ;
 ; CHECK-FP16-LABEL: test_unsigned_i1_f16:
 ; CHECK-FP16:       // %bb.0:
 ; CHECK-FP16-NEXT:    fcvtzu w8, h0
 ; CHECK-FP16-NEXT:    cmp w8, #1
-; CHECK-FP16-NEXT:    csinc w8, w8, wzr, lo
-; CHECK-FP16-NEXT:    and w0, w8, #0x1
+; CHECK-FP16-NEXT:    csinc w0, w8, wzr, lo
 ; CHECK-FP16-NEXT:    ret
     %x = call i1 @llvm.fptoui.sat.i1.f16(half %f)
     ret i1 %x
 }
 
 define i8 @test_unsigned_i8_f16(half %f) nounwind {
 ; CHECK-CVT-LABEL: test_unsigned_i8_f16:
 ; CHECK-CVT:       // %bb.0:

llvm/test/CodeGen/RISCV/double-convert.ll

 ; RV32IFD-NEXT:    addi sp, sp, -16
 ; RV32IFD-NEXT:    sw a0, 8(sp)
 ; RV32IFD-NEXT:    sw a1, 12(sp)
 ; RV32IFD-NEXT:    fld ft0, 8(sp)
 ; RV32IFD-NEXT:    feq.d a0, ft0, ft0
 ; RV32IFD-NEXT:    bnez a0, .LBB26_2
 ; RV32IFD-NEXT:  # %bb.1: # %start
 ; RV32IFD-NEXT:    li a0, 0
-; RV32IFD-NEXT:    j .LBB26_3
+; RV32IFD-NEXT:    addi sp, sp, 16
+; RV32IFD-NEXT:    ret
 ; RV32IFD-NEXT:  .LBB26_2:
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI26_0)
 ; RV32IFD-NEXT:    fld ft1, %lo(.LCPI26_0)(a0)
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI26_1)
 ; RV32IFD-NEXT:    fld ft2, %lo(.LCPI26_1)(a0)
 ; RV32IFD-NEXT:    fmax.d ft0, ft0, ft1
 ; RV32IFD-NEXT:    fmin.d ft0, ft0, ft2
 ; RV32IFD-NEXT:    fcvt.w.d a0, ft0, rtz
-; RV32IFD-NEXT:  .LBB26_3: # %start
-; RV32IFD-NEXT:    slli a0, a0, 16
-; RV32IFD-NEXT:    srai a0, a0, 16
 ; RV32IFD-NEXT:    addi sp, sp, 16
 ; RV32IFD-NEXT:    ret
 ;
 ; RV64IFD-LABEL: fcvt_w_s_sat_i16:
 ; RV64IFD:       # %bb.0: # %start
 ; RV64IFD-NEXT:    fmv.d.x ft0, a0
 ; RV64IFD-NEXT:    feq.d a0, ft0, ft0
 ; RV64IFD-NEXT:    bnez a0, .LBB26_2
 ; RV64IFD-NEXT:  # %bb.1: # %start
 ; RV64IFD-NEXT:    li a0, 0
-; RV64IFD-NEXT:    j .LBB26_3
+; RV64IFD-NEXT:    ret
 ; RV64IFD-NEXT:  .LBB26_2:
 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI26_0)
 ; RV64IFD-NEXT:    fld ft1, %lo(.LCPI26_0)(a0)
 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI26_1)
 ; RV64IFD-NEXT:    fld ft2, %lo(.LCPI26_1)(a0)
 ; RV64IFD-NEXT:    fmax.d ft0, ft0, ft1
 ; RV64IFD-NEXT:    fmin.d ft0, ft0, ft2
 ; RV64IFD-NEXT:    fcvt.l.d a0, ft0, rtz
-; RV64IFD-NEXT:  .LBB26_3: # %start
-; RV64IFD-NEXT:    slli a0, a0, 48
-; RV64IFD-NEXT:    srai a0, a0, 48
 ; RV64IFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IFD-NEXT:    sw a1, 12(sp)
 ; RV32IFD-NEXT:    fld ft0, 8(sp)
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI28_0)
 ; RV32IFD-NEXT:    fld ft1, %lo(.LCPI28_0)(a0)
 ; RV32IFD-NEXT:    fcvt.d.w ft2, zero
 ; RV32IFD-NEXT:    fmax.d ft0, ft0, ft2
 ; RV32IFD-NEXT:    fmin.d ft0, ft0, ft1
 ; RV32IFD-NEXT:    fcvt.wu.d a0, ft0, rtz
-; RV32IFD-NEXT:    lui a1, 16
-; RV32IFD-NEXT:    addi a1, a1, -1
-; RV32IFD-NEXT:    and a0, a0, a1
 ; RV32IFD-NEXT:    addi sp, sp, 16
 ; RV32IFD-NEXT:    ret
 ;
 ; RV64IFD-LABEL: fcvt_wu_s_sat_i16:
 ; RV64IFD:       # %bb.0: # %start
 ; RV64IFD-NEXT:    lui a1, %hi(.LCPI28_0)
 ; RV64IFD-NEXT:    fld ft0, %lo(.LCPI28_0)(a1)
 ; RV64IFD-NEXT:    fmv.d.x ft1, a0
 ; RV64IFD-NEXT:    fmv.d.x ft2, zero
 ; RV64IFD-NEXT:    fmax.d ft1, ft1, ft2
 ; RV64IFD-NEXT:    fmin.d ft0, ft1, ft0
 ; RV64IFD-NEXT:    fcvt.lu.d a0, ft0, rtz
-; RV64IFD-NEXT:    lui a1, 16
-; RV64IFD-NEXT:    addiw a1, a1, -1
-; RV64IFD-NEXT:    and a0, a0, a1
 ; RV64IFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IFD-NEXT:    addi sp, sp, -16
 ; RV32IFD-NEXT:    sw a0, 8(sp)
 ; RV32IFD-NEXT:    sw a1, 12(sp)
 ; RV32IFD-NEXT:    fld ft0, 8(sp)
 ; RV32IFD-NEXT:    feq.d a0, ft0, ft0
 ; RV32IFD-NEXT:    bnez a0, .LBB30_2
 ; RV32IFD-NEXT:  # %bb.1: # %start
 ; RV32IFD-NEXT:    li a0, 0
-; RV32IFD-NEXT:    j .LBB30_3
+; RV32IFD-NEXT:    addi sp, sp, 16
+; RV32IFD-NEXT:    ret
 ; RV32IFD-NEXT:  .LBB30_2:
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI30_0)
 ; RV32IFD-NEXT:    fld ft1, %lo(.LCPI30_0)(a0)
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI30_1)
 ; RV32IFD-NEXT:    fld ft2, %lo(.LCPI30_1)(a0)
 ; RV32IFD-NEXT:    fmax.d ft0, ft0, ft1
 ; RV32IFD-NEXT:    fmin.d ft0, ft0, ft2
 ; RV32IFD-NEXT:    fcvt.w.d a0, ft0, rtz
-; RV32IFD-NEXT:  .LBB30_3: # %start
-; RV32IFD-NEXT:    slli a0, a0, 24
-; RV32IFD-NEXT:    srai a0, a0, 24
 ; RV32IFD-NEXT:    addi sp, sp, 16
 ; RV32IFD-NEXT:    ret
 ;
 ; RV64IFD-LABEL: fcvt_w_s_sat_i8:
 ; RV64IFD:       # %bb.0: # %start
 ; RV64IFD-NEXT:    fmv.d.x ft0, a0
 ; RV64IFD-NEXT:    feq.d a0, ft0, ft0
 ; RV64IFD-NEXT:    bnez a0, .LBB30_2
 ; RV64IFD-NEXT:  # %bb.1: # %start
 ; RV64IFD-NEXT:    li a0, 0
-; RV64IFD-NEXT:    j .LBB30_3
+; RV64IFD-NEXT:    ret
 ; RV64IFD-NEXT:  .LBB30_2:
 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI30_0)
 ; RV64IFD-NEXT:    fld ft1, %lo(.LCPI30_0)(a0)
 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI30_1)
 ; RV64IFD-NEXT:    fld ft2, %lo(.LCPI30_1)(a0)
 ; RV64IFD-NEXT:    fmax.d ft0, ft0, ft1
 ; RV64IFD-NEXT:    fmin.d ft0, ft0, ft2
 ; RV64IFD-NEXT:    fcvt.l.d a0, ft0, rtz
-; RV64IFD-NEXT:  .LBB30_3: # %start
-; RV64IFD-NEXT:    slli a0, a0, 56
-; RV64IFD-NEXT:    srai a0, a0, 56
 ; RV64IFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IFD-NEXT:    sw a1, 12(sp)
 ; RV32IFD-NEXT:    fld ft0, 8(sp)
 ; RV32IFD-NEXT:    lui a0, %hi(.LCPI32_0)
 ; RV32IFD-NEXT:    fld ft1, %lo(.LCPI32_0)(a0)
 ; RV32IFD-NEXT:    fcvt.d.w ft2, zero
 ; RV32IFD-NEXT:    fmax.d ft0, ft0, ft2
 ; RV32IFD-NEXT:    fmin.d ft0, ft0, ft1
 ; RV32IFD-NEXT:    fcvt.wu.d a0, ft0, rtz
-; RV32IFD-NEXT:    andi a0, a0, 255
 ; RV32IFD-NEXT:    addi sp, sp, 16
 ; RV32IFD-NEXT:    ret
 ;
 ; RV64IFD-LABEL: fcvt_wu_s_sat_i8:
 ; RV64IFD:       # %bb.0: # %start
 ; RV64IFD-NEXT:    lui a1, %hi(.LCPI32_0)
 ; RV64IFD-NEXT:    fld ft0, %lo(.LCPI32_0)(a1)
 ; RV64IFD-NEXT:    fmv.d.x ft1, a0
 ; RV64IFD-NEXT:    fmv.d.x ft2, zero
 ; RV64IFD-NEXT:    fmax.d ft1, ft1, ft2
 ; RV64IFD-NEXT:    fmin.d ft0, ft1, ft0
 ; RV64IFD-NEXT:    fcvt.lu.d a0, ft0, rtz
-; RV64IFD-NEXT:    andi a0, a0, 255
 ; RV64IFD-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

llvm/test/CodeGen/RISCV/float-convert.ll

 define signext i16 @fcvt_w_s_sat_i16(float %a) nounwind {
 ; RV32IF-LABEL: fcvt_w_s_sat_i16:
 ; RV32IF:       # %bb.0: # %start
 ; RV32IF-NEXT:    fmv.w.x ft0, a0
 ; RV32IF-NEXT:    feq.s a0, ft0, ft0
 ; RV32IF-NEXT:    bnez a0, .LBB24_2
 ; RV32IF-NEXT:  # %bb.1: # %start
 ; RV32IF-NEXT:    li a0, 0
-; RV32IF-NEXT:    j .LBB24_3
+; RV32IF-NEXT:    ret
 ; RV32IF-NEXT:  .LBB24_2:
 ; RV32IF-NEXT:    lui a0, %hi(.LCPI24_0)
 ; RV32IF-NEXT:    flw ft1, %lo(.LCPI24_0)(a0)
 ; RV32IF-NEXT:    lui a0, %hi(.LCPI24_1)
 ; RV32IF-NEXT:    flw ft2, %lo(.LCPI24_1)(a0)
 ; RV32IF-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IF-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IF-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IF-NEXT:  .LBB24_3: # %start
-; RV32IF-NEXT:    slli a0, a0, 16
-; RV32IF-NEXT:    srai a0, a0, 16
 ; RV32IF-NEXT:    ret
 ;
 ; RV64IF-LABEL: fcvt_w_s_sat_i16:
 ; RV64IF:       # %bb.0: # %start
 ; RV64IF-NEXT:    fmv.w.x ft0, a0
 ; RV64IF-NEXT:    feq.s a0, ft0, ft0
 ; RV64IF-NEXT:    bnez a0, .LBB24_2
 ; RV64IF-NEXT:  # %bb.1: # %start
 ; RV64IF-NEXT:    li a0, 0
-; RV64IF-NEXT:    j .LBB24_3
+; RV64IF-NEXT:    ret
 ; RV64IF-NEXT:  .LBB24_2:
 ; RV64IF-NEXT:    lui a0, %hi(.LCPI24_0)
 ; RV64IF-NEXT:    flw ft1, %lo(.LCPI24_0)(a0)
 ; RV64IF-NEXT:    lui a0, %hi(.LCPI24_1)
 ; RV64IF-NEXT:    flw ft2, %lo(.LCPI24_1)(a0)
 ; RV64IF-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IF-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IF-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IF-NEXT:  .LBB24_3: # %start
-; RV64IF-NEXT:    slli a0, a0, 48
-; RV64IF-NEXT:    srai a0, a0, 48
 ; RV64IF-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IF:       # %bb.0: # %start
 ; RV32IF-NEXT:    lui a1, %hi(.LCPI26_0)
 ; RV32IF-NEXT:    flw ft0, %lo(.LCPI26_0)(a1)
 ; RV32IF-NEXT:    fmv.w.x ft1, a0
 ; RV32IF-NEXT:    fmv.w.x ft2, zero
 ; RV32IF-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IF-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IF-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IF-NEXT:    lui a1, 16
-; RV32IF-NEXT:    addi a1, a1, -1
-; RV32IF-NEXT:    and a0, a0, a1
 ; RV32IF-NEXT:    ret
 ;
 ; RV64IF-LABEL: fcvt_wu_s_sat_i16:
 ; RV64IF:       # %bb.0: # %start
 ; RV64IF-NEXT:    lui a1, %hi(.LCPI26_0)
 ; RV64IF-NEXT:    flw ft0, %lo(.LCPI26_0)(a1)
 ; RV64IF-NEXT:    fmv.w.x ft1, a0
 ; RV64IF-NEXT:    fmv.w.x ft2, zero
 ; RV64IF-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IF-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IF-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IF-NEXT:    lui a1, 16
-; RV64IF-NEXT:    addiw a1, a1, -1
-; RV64IF-NEXT:    and a0, a0, a1
 ; RV64IF-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -16
 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill

 define signext i8 @fcvt_w_s_sat_i8(float %a) nounwind {
 ; RV32IF-LABEL: fcvt_w_s_sat_i8:
 ; RV32IF:       # %bb.0: # %start
 ; RV32IF-NEXT:    fmv.w.x ft0, a0
 ; RV32IF-NEXT:    feq.s a0, ft0, ft0
 ; RV32IF-NEXT:    bnez a0, .LBB28_2
 ; RV32IF-NEXT:  # %bb.1: # %start
 ; RV32IF-NEXT:    li a0, 0
-; RV32IF-NEXT:    j .LBB28_3
+; RV32IF-NEXT:    ret
 ; RV32IF-NEXT:  .LBB28_2:
 ; RV32IF-NEXT:    lui a0, %hi(.LCPI28_0)
 ; RV32IF-NEXT:    flw ft1, %lo(.LCPI28_0)(a0)
 ; RV32IF-NEXT:    lui a0, %hi(.LCPI28_1)
 ; RV32IF-NEXT:    flw ft2, %lo(.LCPI28_1)(a0)
 ; RV32IF-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IF-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IF-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IF-NEXT:  .LBB28_3: # %start
-; RV32IF-NEXT:    slli a0, a0, 24
-; RV32IF-NEXT:    srai a0, a0, 24
 ; RV32IF-NEXT:    ret
 ;
 ; RV64IF-LABEL: fcvt_w_s_sat_i8:
 ; RV64IF:       # %bb.0: # %start
 ; RV64IF-NEXT:    fmv.w.x ft0, a0
 ; RV64IF-NEXT:    feq.s a0, ft0, ft0
 ; RV64IF-NEXT:    bnez a0, .LBB28_2
 ; RV64IF-NEXT:  # %bb.1: # %start
 ; RV64IF-NEXT:    li a0, 0
-; RV64IF-NEXT:    j .LBB28_3
+; RV64IF-NEXT:    ret
 ; RV64IF-NEXT:  .LBB28_2:
 ; RV64IF-NEXT:    lui a0, %hi(.LCPI28_0)
 ; RV64IF-NEXT:    flw ft1, %lo(.LCPI28_0)(a0)
 ; RV64IF-NEXT:    lui a0, %hi(.LCPI28_1)
 ; RV64IF-NEXT:    flw ft2, %lo(.LCPI28_1)(a0)
 ; RV64IF-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IF-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IF-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IF-NEXT:  .LBB28_3: # %start
-; RV64IF-NEXT:    slli a0, a0, 56
-; RV64IF-NEXT:    srai a0, a0, 56
 ; RV64IF-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IF:       # %bb.0: # %start
 ; RV32IF-NEXT:    lui a1, %hi(.LCPI30_0)
 ; RV32IF-NEXT:    flw ft0, %lo(.LCPI30_0)(a1)
 ; RV32IF-NEXT:    fmv.w.x ft1, a0
 ; RV32IF-NEXT:    fmv.w.x ft2, zero
 ; RV32IF-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IF-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IF-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IF-NEXT:    andi a0, a0, 255
 ; RV32IF-NEXT:    ret
 ;
 ; RV64IF-LABEL: fcvt_wu_s_sat_i8:
 ; RV64IF:       # %bb.0: # %start
 ; RV64IF-NEXT:    lui a1, %hi(.LCPI30_0)
 ; RV64IF-NEXT:    flw ft0, %lo(.LCPI30_0)(a1)
 ; RV64IF-NEXT:    fmv.w.x ft1, a0
 ; RV64IF-NEXT:    fmv.w.x ft2, zero
 ; RV64IF-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IF-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IF-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IF-NEXT:    andi a0, a0, 255
 ; RV64IF-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -16
 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill

llvm/test/CodeGen/RISCV/half-convert.ll

 define signext i16 @fcvt_w_s_sat_i16(half %a) nounwind {
 ; RV32IZFH-LABEL: fcvt_w_s_sat_i16:
 ; RV32IZFH:       # %bb.0: # %start
 ; RV32IZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV32IZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV32IZFH-NEXT:    bnez a0, .LBB32_2
 ; RV32IZFH-NEXT:  # %bb.1: # %start
 ; RV32IZFH-NEXT:    li a0, 0
-; RV32IZFH-NEXT:    j .LBB32_3
+; RV32IZFH-NEXT:    ret
 ; RV32IZFH-NEXT:  .LBB32_2:
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI32_0)
 ; RV32IZFH-NEXT:    flw ft1, %lo(.LCPI32_0)(a0)
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI32_1)
 ; RV32IZFH-NEXT:    flw ft2, %lo(.LCPI32_1)(a0)
 ; RV32IZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IZFH-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IZFH-NEXT:  .LBB32_3: # %start
-; RV32IZFH-NEXT:    slli a0, a0, 16
-; RV32IZFH-NEXT:    srai a0, a0, 16
 ; RV32IZFH-NEXT:    ret
 ;
 ; RV64IZFH-LABEL: fcvt_w_s_sat_i16:
 ; RV64IZFH:       # %bb.0: # %start
 ; RV64IZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV64IZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV64IZFH-NEXT:    bnez a0, .LBB32_2
 ; RV64IZFH-NEXT:  # %bb.1: # %start
 ; RV64IZFH-NEXT:    li a0, 0
-; RV64IZFH-NEXT:    j .LBB32_3
+; RV64IZFH-NEXT:    ret
 ; RV64IZFH-NEXT:  .LBB32_2:
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI32_0)
 ; RV64IZFH-NEXT:    flw ft1, %lo(.LCPI32_0)(a0)
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI32_1)
 ; RV64IZFH-NEXT:    flw ft2, %lo(.LCPI32_1)(a0)
 ; RV64IZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IZFH-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IZFH-NEXT:  .LBB32_3: # %start
-; RV64IZFH-NEXT:    slli a0, a0, 48
-; RV64IZFH-NEXT:    srai a0, a0, 48
 ; RV64IZFH-NEXT:    ret
 ;
 ; RV32IDZFH-LABEL: fcvt_w_s_sat_i16:
 ; RV32IDZFH:       # %bb.0: # %start
 ; RV32IDZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV32IDZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV32IDZFH-NEXT:    bnez a0, .LBB32_2
 ; RV32IDZFH-NEXT:  # %bb.1: # %start
 ; RV32IDZFH-NEXT:    li a0, 0
-; RV32IDZFH-NEXT:    j .LBB32_3
+; RV32IDZFH-NEXT:    ret
 ; RV32IDZFH-NEXT:  .LBB32_2:
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI32_0)
 ; RV32IDZFH-NEXT:    flw ft1, %lo(.LCPI32_0)(a0)
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI32_1)
 ; RV32IDZFH-NEXT:    flw ft2, %lo(.LCPI32_1)(a0)
 ; RV32IDZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IDZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IDZFH-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IDZFH-NEXT:  .LBB32_3: # %start
-; RV32IDZFH-NEXT:    slli a0, a0, 16
-; RV32IDZFH-NEXT:    srai a0, a0, 16
 ; RV32IDZFH-NEXT:    ret
 ;
 ; RV64IDZFH-LABEL: fcvt_w_s_sat_i16:
 ; RV64IDZFH:       # %bb.0: # %start
 ; RV64IDZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV64IDZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV64IDZFH-NEXT:    bnez a0, .LBB32_2
 ; RV64IDZFH-NEXT:  # %bb.1: # %start
 ; RV64IDZFH-NEXT:    li a0, 0
-; RV64IDZFH-NEXT:    j .LBB32_3
+; RV64IDZFH-NEXT:    ret
 ; RV64IDZFH-NEXT:  .LBB32_2:
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI32_0)
 ; RV64IDZFH-NEXT:    flw ft1, %lo(.LCPI32_0)(a0)
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI32_1)
 ; RV64IDZFH-NEXT:    flw ft2, %lo(.LCPI32_1)(a0)
 ; RV64IDZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IDZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IDZFH-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IDZFH-NEXT:  .LBB32_3: # %start
-; RV64IDZFH-NEXT:    slli a0, a0, 48
-; RV64IDZFH-NEXT:    srai a0, a0, 48
 ; RV64IDZFH-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IZFH:       # %bb.0: # %start
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI34_0)
 ; RV32IZFH-NEXT:    flw ft0, %lo(.LCPI34_0)(a0)
 ; RV32IZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV32IZFH-NEXT:    fmv.w.x ft2, zero
 ; RV32IZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IZFH-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IZFH-NEXT:    lui a1, 16
-; RV32IZFH-NEXT:    addi a1, a1, -1
-; RV32IZFH-NEXT:    and a0, a0, a1
 ; RV32IZFH-NEXT:    ret
 ;
 ; RV64IZFH-LABEL: fcvt_wu_s_sat_i16:
 ; RV64IZFH:       # %bb.0: # %start
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI34_0)
 ; RV64IZFH-NEXT:    flw ft0, %lo(.LCPI34_0)(a0)
 ; RV64IZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV64IZFH-NEXT:    fmv.w.x ft2, zero
 ; RV64IZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IZFH-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IZFH-NEXT:    lui a1, 16
-; RV64IZFH-NEXT:    addiw a1, a1, -1
-; RV64IZFH-NEXT:    and a0, a0, a1
 ; RV64IZFH-NEXT:    ret
 ;
 ; RV32IDZFH-LABEL: fcvt_wu_s_sat_i16:
 ; RV32IDZFH:       # %bb.0: # %start
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI34_0)
 ; RV32IDZFH-NEXT:    flw ft0, %lo(.LCPI34_0)(a0)
 ; RV32IDZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV32IDZFH-NEXT:    fmv.w.x ft2, zero
 ; RV32IDZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IDZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IDZFH-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IDZFH-NEXT:    lui a1, 16
-; RV32IDZFH-NEXT:    addi a1, a1, -1
-; RV32IDZFH-NEXT:    and a0, a0, a1
 ; RV32IDZFH-NEXT:    ret
 ;
 ; RV64IDZFH-LABEL: fcvt_wu_s_sat_i16:
 ; RV64IDZFH:       # %bb.0: # %start
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI34_0)
 ; RV64IDZFH-NEXT:    flw ft0, %lo(.LCPI34_0)(a0)
 ; RV64IDZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV64IDZFH-NEXT:    fmv.w.x ft2, zero
 ; RV64IDZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IDZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IDZFH-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IDZFH-NEXT:    lui a1, 16
-; RV64IDZFH-NEXT:    addiw a1, a1, -1
-; RV64IDZFH-NEXT:    and a0, a0, a1
 ; RV64IDZFH-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i16:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 define signext i8 @fcvt_w_s_sat_i8(half %a) nounwind {
 ; RV32IZFH-LABEL: fcvt_w_s_sat_i8:
 ; RV32IZFH:       # %bb.0: # %start
 ; RV32IZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV32IZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV32IZFH-NEXT:    bnez a0, .LBB36_2
 ; RV32IZFH-NEXT:  # %bb.1: # %start
 ; RV32IZFH-NEXT:    li a0, 0
-; RV32IZFH-NEXT:    j .LBB36_3
+; RV32IZFH-NEXT:    ret
 ; RV32IZFH-NEXT:  .LBB36_2:
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI36_0)
 ; RV32IZFH-NEXT:    flw ft1, %lo(.LCPI36_0)(a0)
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI36_1)
 ; RV32IZFH-NEXT:    flw ft2, %lo(.LCPI36_1)(a0)
 ; RV32IZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IZFH-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IZFH-NEXT:  .LBB36_3: # %start
-; RV32IZFH-NEXT:    slli a0, a0, 24
-; RV32IZFH-NEXT:    srai a0, a0, 24
 ; RV32IZFH-NEXT:    ret
 ;
 ; RV64IZFH-LABEL: fcvt_w_s_sat_i8:
 ; RV64IZFH:       # %bb.0: # %start
 ; RV64IZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV64IZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV64IZFH-NEXT:    bnez a0, .LBB36_2
 ; RV64IZFH-NEXT:  # %bb.1: # %start
 ; RV64IZFH-NEXT:    li a0, 0
-; RV64IZFH-NEXT:    j .LBB36_3
+; RV64IZFH-NEXT:    ret
 ; RV64IZFH-NEXT:  .LBB36_2:
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI36_0)
 ; RV64IZFH-NEXT:    flw ft1, %lo(.LCPI36_0)(a0)
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI36_1)
 ; RV64IZFH-NEXT:    flw ft2, %lo(.LCPI36_1)(a0)
 ; RV64IZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IZFH-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IZFH-NEXT:  .LBB36_3: # %start
-; RV64IZFH-NEXT:    slli a0, a0, 56
-; RV64IZFH-NEXT:    srai a0, a0, 56
 ; RV64IZFH-NEXT:    ret
 ;
 ; RV32IDZFH-LABEL: fcvt_w_s_sat_i8:
 ; RV32IDZFH:       # %bb.0: # %start
 ; RV32IDZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV32IDZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV32IDZFH-NEXT:    bnez a0, .LBB36_2
 ; RV32IDZFH-NEXT:  # %bb.1: # %start
 ; RV32IDZFH-NEXT:    li a0, 0
-; RV32IDZFH-NEXT:    j .LBB36_3
+; RV32IDZFH-NEXT:    ret
 ; RV32IDZFH-NEXT:  .LBB36_2:
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI36_0)
 ; RV32IDZFH-NEXT:    flw ft1, %lo(.LCPI36_0)(a0)
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI36_1)
 ; RV32IDZFH-NEXT:    flw ft2, %lo(.LCPI36_1)(a0)
 ; RV32IDZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV32IDZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV32IDZFH-NEXT:    fcvt.w.s a0, ft0, rtz
-; RV32IDZFH-NEXT:  .LBB36_3: # %start
-; RV32IDZFH-NEXT:    slli a0, a0, 24
-; RV32IDZFH-NEXT:    srai a0, a0, 24
 ; RV32IDZFH-NEXT:    ret
 ;
 ; RV64IDZFH-LABEL: fcvt_w_s_sat_i8:
 ; RV64IDZFH:       # %bb.0: # %start
 ; RV64IDZFH-NEXT:    fcvt.s.h ft0, fa0
 ; RV64IDZFH-NEXT:    feq.s a0, ft0, ft0
 ; RV64IDZFH-NEXT:    bnez a0, .LBB36_2
 ; RV64IDZFH-NEXT:  # %bb.1: # %start
 ; RV64IDZFH-NEXT:    li a0, 0
-; RV64IDZFH-NEXT:    j .LBB36_3
+; RV64IDZFH-NEXT:    ret
 ; RV64IDZFH-NEXT:  .LBB36_2:
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI36_0)
 ; RV64IDZFH-NEXT:    flw ft1, %lo(.LCPI36_0)(a0)
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI36_1)
 ; RV64IDZFH-NEXT:    flw ft2, %lo(.LCPI36_1)(a0)
 ; RV64IDZFH-NEXT:    fmax.s ft0, ft0, ft1
 ; RV64IDZFH-NEXT:    fmin.s ft0, ft0, ft2
 ; RV64IDZFH-NEXT:    fcvt.l.s a0, ft0, rtz
-; RV64IDZFH-NEXT:  .LBB36_3: # %start
-; RV64IDZFH-NEXT:    slli a0, a0, 56
-; RV64IDZFH-NEXT:    srai a0, a0, 56
 ; RV64IDZFH-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_w_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -32
 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill

 ; RV32IZFH:       # %bb.0: # %start
 ; RV32IZFH-NEXT:    lui a0, %hi(.LCPI38_0)
 ; RV32IZFH-NEXT:    flw ft0, %lo(.LCPI38_0)(a0)
 ; RV32IZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV32IZFH-NEXT:    fmv.w.x ft2, zero
 ; RV32IZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IZFH-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IZFH-NEXT:    andi a0, a0, 255
 ; RV32IZFH-NEXT:    ret
 ;
 ; RV64IZFH-LABEL: fcvt_wu_s_sat_i8:
 ; RV64IZFH:       # %bb.0: # %start
 ; RV64IZFH-NEXT:    lui a0, %hi(.LCPI38_0)
 ; RV64IZFH-NEXT:    flw ft0, %lo(.LCPI38_0)(a0)
 ; RV64IZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV64IZFH-NEXT:    fmv.w.x ft2, zero
 ; RV64IZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IZFH-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IZFH-NEXT:    andi a0, a0, 255
 ; RV64IZFH-NEXT:    ret
 ;
 ; RV32IDZFH-LABEL: fcvt_wu_s_sat_i8:
 ; RV32IDZFH:       # %bb.0: # %start
 ; RV32IDZFH-NEXT:    lui a0, %hi(.LCPI38_0)
 ; RV32IDZFH-NEXT:    flw ft0, %lo(.LCPI38_0)(a0)
 ; RV32IDZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV32IDZFH-NEXT:    fmv.w.x ft2, zero
 ; RV32IDZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV32IDZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV32IDZFH-NEXT:    fcvt.wu.s a0, ft0, rtz
-; RV32IDZFH-NEXT:    andi a0, a0, 255
 ; RV32IDZFH-NEXT:    ret
 ;
 ; RV64IDZFH-LABEL: fcvt_wu_s_sat_i8:
 ; RV64IDZFH:       # %bb.0: # %start
 ; RV64IDZFH-NEXT:    lui a0, %hi(.LCPI38_0)
 ; RV64IDZFH-NEXT:    flw ft0, %lo(.LCPI38_0)(a0)
 ; RV64IDZFH-NEXT:    fcvt.s.h ft1, fa0
 ; RV64IDZFH-NEXT:    fmv.w.x ft2, zero
 ; RV64IDZFH-NEXT:    fmax.s ft1, ft1, ft2
 ; RV64IDZFH-NEXT:    fmin.s ft0, ft1, ft0
 ; RV64IDZFH-NEXT:    fcvt.lu.s a0, ft0, rtz
-; RV64IDZFH-NEXT:    andi a0, a0, 255
 ; RV64IDZFH-NEXT:    ret
 ;
 ; RV32I-LABEL: fcvt_wu_s_sat_i8:
 ; RV32I:       # %bb.0: # %start
 ; RV32I-NEXT:    addi sp, sp, -16
 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
 ; RV32I-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill

llvm/test/CodeGen/Thumb2/mve-fptoui-sat-vector.ll

 ; CHECK-MVEFP-NEXT:    bx lr
     %x = call <8 x i16> @llvm.fptoui.sat.v8f16.v8i16(<8 x half> %f)
     ret <8 x i16> %x
 }
 
 define arm_aapcs_vfpcc <8 x i19> @test_unsigned_v8f16_v8i19(<8 x half> %f) {
 ; CHECK-LABEL: test_unsigned_v8f16_v8i19:
 ; CHECK:       @ %bb.0:
-; CHECK-NEXT:    .save {r7, lr}
-; CHECK-NEXT:    push {r7, lr}
-; CHECK-NEXT:    vldr s4, .LCPI46_0
-; CHECK-NEXT:    vcvtb.f32.f16 s8, s1
-; CHECK-NEXT:    vcvtt.f32.f16 s12, s1
-; CHECK-NEXT:    vcvtt.f32.f16 s1, s3
+; CHECK-NEXT:    .save {r4, r5, r7, lr}
+; CHECK-NEXT:    push {r4, r5, r7, lr}
 ; CHECK-NEXT:    vldr s6, .LCPI46_1
-; CHECK-NEXT:    vmaxnm.f32 s1, s1, s4
-; CHECK-NEXT:    vcvtb.f32.f16 s10, s2
-; CHECK-NEXT:    vcvtb.f32.f16 s14, s0
-; CHECK-NEXT:    vminnm.f32 s1, s1, s6
+; CHECK-NEXT:    vcvtb.f32.f16 s8, s0
+; CHECK-NEXT:    vcvtb.f32.f16 s12, s2
+; CHECK-NEXT:    vcvtb.f32.f16 s10, s1
+; CHECK-NEXT:    vcvtt.f32.f16 s14, s1
+; CHECK-NEXT:    vcvtb.f32.f16 s1, s3
 ; CHECK-NEXT:    vcvtt.f32.f16 s0, s0
-; CHECK-NEXT:    vcvt.u32.f32 s1, s1
 ; CHECK-NEXT:    vcvtt.f32.f16 s2, s2
-; CHECK-NEXT:    vcvtb.f32.f16 s3, s3
-; CHECK-NEXT:    vmaxnm.f32 s8, s8, s4
-; CHECK-NEXT:    vmaxnm.f32 s10, s10, s4
-; CHECK-NEXT:    vmaxnm.f32 s12, s12, s4
-; CHECK-NEXT:    vmaxnm.f32 s14, s14, s4
-; CHECK-NEXT:    vmaxnm.f32 s0, s0, s4
-; CHECK-NEXT:    vmaxnm.f32 s2, s2, s4
-; CHECK-NEXT:    vmaxnm.f32 s4, s3, s4
-; CHECK-NEXT:    vminnm.f32 s4, s4, s6
-; CHECK-NEXT:    vminnm.f32 s2, s2, s6
+; CHECK-NEXT:    vldr s4, .LCPI46_0
+; CHECK-NEXT:    vcvtt.f32.f16 s3, s3
+; CHECK-NEXT:    vmaxnm.f32 s8, s8, s6
+; CHECK-NEXT:    vmaxnm.f32 s10, s10, s6
+; CHECK-NEXT:    vmaxnm.f32 s0, s0, s6
+; CHECK-NEXT:    vmaxnm.f32 s12, s12, s6
+; CHECK-NEXT:    vmaxnm.f32 s14, s14, s6
+; CHECK-NEXT:    vmaxnm.f32 s2, s2, s6
+; CHECK-NEXT:    vmaxnm.f32 s1, s1, s6
+; CHECK-NEXT:    vmaxnm.f32 s6, s3, s6
+; CHECK-NEXT:    vminnm.f32 s8, s8, s4
+; CHECK-NEXT:    vminnm.f32 s10, s10, s4
+; CHECK-NEXT:    vminnm.f32 s0, s0, s4
+; CHECK-NEXT:    vminnm.f32 s12, s12, s4
+; CHECK-NEXT:    vminnm.f32 s14, s14, s4
+; CHECK-NEXT:    vminnm.f32 s2, s2, s4
+; CHECK-NEXT:    vminnm.f32 s1, s1, s4
+; CHECK-NEXT:    vminnm.f32 s4, s6, s4
+; CHECK-NEXT:    vcvt.u32.f32 s1, s1
 ; CHECK-NEXT:    vcvt.u32.f32 s4, s4
-; CHECK-NEXT:    vminnm.f32 s0, s0, s6
-; CHECK-NEXT:    vmov r1, s1
-; CHECK-NEXT:    vminnm.f32 s14, s14, s6
 ; CHECK-NEXT:    vcvt.u32.f32 s2, s2
-; CHECK-NEXT:    vminnm.f32 s10, s10, s6
-; CHECK-NEXT:    vcvt.u32.f32 s0, s0
-; CHECK-NEXT:    vminnm.f32 s12, s12, s6
 ; CHECK-NEXT:    vcvt.u32.f32 s14, s14
-; CHECK-NEXT:    vminnm.f32 s8, s8, s6
-; CHECK-NEXT:    vcvt.u32.f32 s10, s10
 ; CHECK-NEXT:    vcvt.u32.f32 s12, s12
+; CHECK-NEXT:    vcvt.u32.f32 s0, s0
+; CHECK-NEXT:    vcvt.u32.f32 s10, s10
+; CHECK-NEXT:    vmov r1, s1
+; CHECK-NEXT:    vmov r3, s4
 ; CHECK-NEXT:    vcvt.u32.f32 s8, s8
-; CHECK-NEXT:    vmov r12, s2
-; CHECK-NEXT:    vmov lr, s0
-; CHECK-NEXT:    lsrs r2, r1, #11
-; CHECK-NEXT:    strb r2, [r0, #18]
-; CHECK-NEXT:    vmov r2, s4
-; CHECK-NEXT:    bfc r12, #19, #13
-; CHECK-NEXT:    bfc lr, #19, #13
-; CHECK-NEXT:    bfc r2, #19, #13
-; CHECK-NEXT:    lsrs r3, r2, #14
-; CHECK-NEXT:    orr.w r1, r3, r1, lsl #5
-; CHECK-NEXT:    lsr.w r3, r12, #1
-; CHECK-NEXT:    orr.w r2, r3, r2, lsl #18
-; CHECK-NEXT:    vmov r3, s14
-; CHECK-NEXT:    strh r1, [r0, #16]
-; CHECK-NEXT:    vmov r1, s10
-; CHECK-NEXT:    str r2, [r0, #12]
-; CHECK-NEXT:    bfc r3, #19, #13
-; CHECK-NEXT:    orr.w r3, r3, lr, lsl #19
-; CHECK-NEXT:    str r3, [r0]
-; CHECK-NEXT:    vmov r3, s12
-; CHECK-NEXT:    bfc r1, #19, #13
-; CHECK-NEXT:    bfc r3, #19, #13
-; CHECK-NEXT:    lsrs r2, r3, #7
-; CHECK-NEXT:    orr.w r1, r2, r1, lsl #12
-; CHECK-NEXT:    orr.w r1, r1, r12, lsl #31
-; CHECK-NEXT:    str r1, [r0, #8]
-; CHECK-NEXT:    vmov r1, s8
-; CHECK-NEXT:    lsr.w r2, lr, #13
-; CHECK-NEXT:    bfc r1, #19, #13
-; CHECK-NEXT:    orr.w r1, r2, r1, lsl #6
-; CHECK-NEXT:    orr.w r1, r1, r3, lsl #25
-; CHECK-NEXT:    str r1, [r0, #4]
-; CHECK-NEXT:    pop {r7, pc}
+; CHECK-NEXT:    vmov r4, s12
+; CHECK-NEXT:    vmov r5, s10
+; CHECK-NEXT:    lsrs r2, r1, #14
+; CHECK-NEXT:    orr.w r12, r2, r3, lsl #5
+; CHECK-NEXT:    vmov r3, s2
+; CHECK-NEXT:    strh.w r12, [r0, #16]
+; CHECK-NEXT:    lsrs r2, r3, #1
+; CHECK-NEXT:    orr.w lr, r2, r1, lsl #18
+; CHECK-NEXT:    vmov r2, s14
+; CHECK-NEXT:    lsrs r1, r2, #7
+; CHECK-NEXT:    orr.w r1, r1, r4, lsl #12
+; CHECK-NEXT:    orr.w r1, r1, r3, lsl #31
+; CHECK-NEXT:    vmov r3, s0
+; CHECK-NEXT:    lsrs r4, r3, #13
+; CHECK-NEXT:    orr.w r4, r4, r5, lsl #6
+; CHECK-NEXT:    orr.w r2, r4, r2, lsl #25
+; CHECK-NEXT:    vmov r4, s8
+; CHECK-NEXT:    orr.w r3, r4, r3, lsl #19
+; CHECK-NEXT:    strd r3, r2, [r0]
+; CHECK-NEXT:    strd r1, lr, [r0, #8]
+; CHECK-NEXT:    lsr.w r1, r12, #16
+; CHECK-NEXT:    strb r1, [r0, #18]
+; CHECK-NEXT:    pop {r4, r5, r7, pc}
 ; CHECK-NEXT:    .p2align 2
 ; CHECK-NEXT:  @ %bb.1:
 ; CHECK-NEXT:  .LCPI46_0:
-; CHECK-NEXT:    .long 0x00000000 @ float 0
-; CHECK-NEXT:  .LCPI46_1:
 ; CHECK-NEXT:    .long 0x48ffffe0 @ float 524287
+; CHECK-NEXT:  .LCPI46_1:
+; CHECK-NEXT:    .long 0x00000000 @ float 0
     %x = call <8 x i19> @llvm.fptoui.sat.v8f16.v8i19(<8 x half> %f)
     ret <8 x i19> %x
 }
 
 define arm_aapcs_vfpcc <8 x i32> @test_unsigned_v8f16_v8i32_duplicate(<8 x half> %f) {
 ; CHECK-LABEL: test_unsigned_v8f16_v8i32_duplicate:
 ; CHECK:       @ %bb.0:
 ; CHECK-NEXT:    vmovx.f16 s4, s3

llvm/test/CodeGen/Thumb2/mve-vcvt-float-to-fixed.ll

 }
 
 define arm_aapcs_vfpcc <4 x i32> @vcvt_sat_u32_7_24(<4 x float> %0) {
 ; CHECK-LABEL: vcvt_sat_u32_7_24:
 ; CHECK:       @ %bb.0:
 ; CHECK-NEXT:    vmov.i32 q1, #0xffffff
 ; CHECK-NEXT:    vcvt.u32.f32 q0, q0, #23
 ; CHECK-NEXT:    vmin.u32 q0, q0, q1
-; CHECK-NEXT:    vbic.i32 q0, #0xff000000
 ; CHECK-NEXT:    bx lr
   %2 = fmul fast <4 x float> %0, <float 0x4160000000000000, float 0x4160000000000000, float 0x4160000000000000, float 0x4160000000000000>
   %3 = call <4 x i24> @llvm.fptoui.sat.v4i24.v4f32(<4 x float> %2)
   %4 = zext <4 x i24> %3 to <4 x i32>
   ret <4 x i32> %4
 }
 
 declare <4 x i32> @llvm.fptosi.sat.v4i32.v4f32(<4 x float>)
 declare <4 x i32> @llvm.fptoui.sat.v4i32.v4f32(<4 x float>)
 declare <4 x i24> @llvm.fptoui.sat.v4i24.v4f32(<4 x float>)
 declare <8 x i16> @llvm.fptosi.sat.v8i16.v8f16(<8 x half>)
 declare <8 x i16> @llvm.fptoui.sat.v8i16.v8f16(<8 x half>)