; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=riscv32 -mattr=+zfh -verify-machineinstrs \
; RUN:   -target-abi ilp32f -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZFH,CHECK32-IZFH,RV32IZFH %s
; RUN: llc -mtriple=riscv64 -mattr=+zfh -verify-machineinstrs \
; RUN:   -target-abi lp64f -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZFH,CHECK64-IZFH,RV64IZFH %s
; RUN: llc -mtriple=riscv32 -mattr=+zhinx -verify-machineinstrs \
; RUN:   -target-abi ilp32 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZHINX,CHECK32-IZHINX,RV32IZHINX %s
; RUN: llc -mtriple=riscv64 -mattr=+zhinx -verify-machineinstrs \
; RUN:   -target-abi lp64 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZHINX,CHECK64-IZHINX,RV64IZHINX %s

; RUN: llc -mtriple=riscv32 -mattr=+d,+zfh -verify-machineinstrs \
; RUN:   -target-abi ilp32d -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIDZFH,CHECK32-IZFH %s
; RUN: llc -mtriple=riscv64 -mattr=+d,+zfh -verify-machineinstrs \
; RUN:   -target-abi lp64d -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIDZFH,CHECK64-IZFH %s
; RUN: llc -mtriple=riscv32 -mattr=+zdinx,+zhinx -verify-machineinstrs \
; RUN:   -target-abi ilp32 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZDINXZHINX,CHECK32-IZHINX %s
; RUN: llc -mtriple=riscv64 -mattr=+zdinx,+zhinx -verify-machineinstrs \
; RUN:   -target-abi lp64 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZDINXZHINX,CHECK64-IZHINX %s

; RUN: llc -mtriple=riscv32 -mattr=+zfhmin -verify-machineinstrs \
; RUN:   -target-abi ilp32f -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZFHMIN,CHECK32-IZFHMIN,RV32IFZFHMIN %s
; RUN: llc -mtriple=riscv64 -mattr=+zfhmin -verify-machineinstrs \
; RUN:   -target-abi lp64f -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZFHMIN,CHECK64-IZFHMIN,RV64IFZFHMIN %s
; RUN: llc -mtriple=riscv32 -mattr=+zhinxmin -verify-machineinstrs \
; RUN:   -target-abi ilp32 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZHINXMIN,CHECK32-IZHINXMIN,RV32IZHINXMIN %s
; RUN: llc -mtriple=riscv64 -mattr=+zhinxmin -verify-machineinstrs \
; RUN:   -target-abi lp64 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZHINXMIN,CHECK64-IZHINXMIN,RV64IZHINXMIN %s

; RUN: llc -mtriple=riscv32 -mattr=+d,+zfhmin -verify-machineinstrs \
; RUN:   -target-abi ilp32d -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIDZFHMIN,CHECK32-IZFHMIN %s
; RUN: llc -mtriple=riscv64 -mattr=+d,+zfhmin -verify-machineinstrs \
; RUN:   -target-abi lp64d -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIDZFHMIN,CHECK64-IZFHMIN %s
; RUN: llc -mtriple=riscv32 -mattr=+zdinx,+zhinxmin -verify-machineinstrs \
; RUN:   -target-abi ilp32 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZDINXZHINXMIN,CHECK32-IZHINXMIN %s
; RUN: llc -mtriple=riscv64 -mattr=+zdinx,+zhinxmin -verify-machineinstrs \
; RUN:   -target-abi lp64 -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECKIZDINXZHINXMIN,CHECK64-IZHINXMIN %s

; RUN: llc -mtriple=riscv32 -mattr=+d -verify-machineinstrs \
; RUN:   -target-abi ilp32d -disable-strictnode-mutation < %s \
; RUN:   | FileCheck -check-prefixes=CHECK32-D %s

; NOTE: The rounding mode metadata does not effect which instruction is
; selected. Dynamic rounding mode is always used for operations that
; support rounding mode.

define i16 @fcvt_si_h(half %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_si_h:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    fcvt.w.h a0, fa0, rtz
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_si_h:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.l.h a0, fa0, rtz
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_si_h:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    fcvt.w.h a0, a0, rtz
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_si_h:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.l.h a0, a0, rtz
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_si_h:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK32-IZFHMIN-NEXT:    fcvt.w.s a0, fa5, rtz
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_si_h:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK64-IZFHMIN-NEXT:    fcvt.l.s a0, fa5, rtz
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_si_h:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.w.s a0, a0, rtz
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_si_h:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.l.s a0, a0, rtz
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_si_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.w.s a0, fa0, rtz
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i16 @llvm.experimental.constrained.fptosi.i16.f16(half %a, metadata !"fpexcept.strict")
  ret i16 %1
}

define i16 @fcvt_ui_h(half %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_ui_h:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    fcvt.w.h a0, fa0, rtz
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_ui_h:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.l.h a0, fa0, rtz
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_ui_h:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    fcvt.w.h a0, a0, rtz
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_ui_h:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.l.h a0, a0, rtz
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_ui_h:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK32-IZFHMIN-NEXT:    fcvt.w.s a0, fa5, rtz
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_ui_h:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK64-IZFHMIN-NEXT:    fcvt.l.s a0, fa5, rtz
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_ui_h:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.w.s a0, a0, rtz
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_ui_h:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.l.s a0, a0, rtz
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_ui_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.w.s a0, fa0, rtz
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i16 @llvm.experimental.constrained.fptoui.i16.f16(half %a, metadata !"fpexcept.strict")
  ret i16 %1
}

define i32 @fcvt_w_h(half %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_w_h:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.w.h a0, fa0, rtz
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_w_h:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.w.h a0, a0, rtz
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_w_h:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.w.h a0, fa0, rtz
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_w_h:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.w.h a0, a0, rtz
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_w_h:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIZFHMIN-NEXT:    fcvt.w.s a0, fa5, rtz
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_w_h:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.w.s a0, a0, rtz
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_w_h:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIDZFHMIN-NEXT:    fcvt.w.s a0, fa5, rtz
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_w_h:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.w.s a0, a0, rtz
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_w_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.w.s a0, fa0, rtz
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i32 @llvm.experimental.constrained.fptosi.i32.f16(half %a, metadata !"fpexcept.strict")
  ret i32 %1
}

define i32 @fcvt_wu_h(half %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_wu_h:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.wu.h a0, fa0, rtz
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_wu_h:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.wu.h a0, a0, rtz
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_wu_h:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.wu.h a0, fa0, rtz
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_wu_h:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.wu.h a0, a0, rtz
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_wu_h:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIZFHMIN-NEXT:    fcvt.wu.s a0, fa5, rtz
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_wu_h:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.wu.s a0, a0, rtz
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_wu_h:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIDZFHMIN-NEXT:    fcvt.wu.s a0, fa5, rtz
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_wu_h:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.wu.s a0, a0, rtz
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_wu_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.wu.s a0, fa0, rtz
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i32 @llvm.experimental.constrained.fptoui.i32.f16(half %a, metadata !"fpexcept.strict")
  ret i32 %1
}

; Test where the fptoui has multiple uses, one of which causes a sext to be
; inserted on RV64.
; FIXME: We should not have an fcvt.wu.h and an fcvt.lu.h.
define i32 @fcvt_wu_h_multiple_use(half %x, ptr %y) strictfp {
; CHECKIZFH-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.wu.h a0, fa0, rtz
; CHECKIZFH-NEXT:    seqz a1, a0
; CHECKIZFH-NEXT:    add a0, a0, a1
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.wu.h a0, a0, rtz
; CHECKIZHINX-NEXT:    seqz a1, a0
; CHECKIZHINX-NEXT:    add a0, a0, a1
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_wu_h_multiple_use:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.wu.h a0, fa0, rtz
; CHECKIDZFH-NEXT:    seqz a1, a0
; CHECKIDZFH-NEXT:    add a0, a0, a1
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.wu.h a0, a0, rtz
; CHECKIZDINXZHINX-NEXT:    seqz a1, a0
; CHECKIZDINXZHINX-NEXT:    add a0, a0, a1
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIZFHMIN-NEXT:    fcvt.wu.s a0, fa5, rtz
; CHECKIZFHMIN-NEXT:    seqz a1, a0
; CHECKIZFHMIN-NEXT:    add a0, a0, a1
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.wu.s a0, a0, rtz
; CHECKIZHINXMIN-NEXT:    seqz a1, a0
; CHECKIZHINXMIN-NEXT:    add a0, a0, a1
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_wu_h_multiple_use:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECKIDZFHMIN-NEXT:    fcvt.wu.s a0, fa5, rtz
; CHECKIDZFHMIN-NEXT:    seqz a1, a0
; CHECKIDZFHMIN-NEXT:    add a0, a0, a1
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_wu_h_multiple_use:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.wu.s a0, a0, rtz
; CHECKIZDINXZHINXMIN-NEXT:    seqz a1, a0
; CHECKIZDINXZHINXMIN-NEXT:    add a0, a0, a1
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_wu_h_multiple_use:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    .cfi_offset ra, -4
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.wu.s a0, fa0, rtz
; CHECK32-D-NEXT:    seqz a1, a0
; CHECK32-D-NEXT:    add a0, a0, a1
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    .cfi_restore ra
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 0
; CHECK32-D-NEXT:    ret
  %a = call i32 @llvm.experimental.constrained.fptoui.i32.f16(half %x, metadata !"fpexcept.strict")
  %b = icmp eq i32 %a, 0
  %c = select i1 %b, i32 1, i32 %a
  ret i32 %c
}

define i64 @fcvt_l_h(half %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_l_h:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -16
; CHECK32-IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    call __fixhfdi
; CHECK32-IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 16
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_l_h:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.l.h a0, fa0, rtz
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_l_h:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -16
; CHECK32-IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    call __fixhfdi
; CHECK32-IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 16
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_l_h:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.l.h a0, a0, rtz
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_l_h:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    call __fixhfdi
; CHECK32-IZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_l_h:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK64-IZFHMIN-NEXT:    fcvt.l.s a0, fa5, rtz
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_l_h:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    call __fixhfdi
; CHECK32-IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_l_h:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.l.s a0, a0, rtz
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_l_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    call __fixsfdi
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i64 @llvm.experimental.constrained.fptosi.i64.f16(half %a, metadata !"fpexcept.strict")
  ret i64 %1
}

define i64 @fcvt_lu_h(half %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_lu_h:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -16
; CHECK32-IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    call __fixunshfdi
; CHECK32-IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 16
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_lu_h:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.lu.h a0, fa0, rtz
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_lu_h:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -16
; CHECK32-IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    call __fixunshfdi
; CHECK32-IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 16
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_lu_h:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.lu.h a0, a0, rtz
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_lu_h:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    call __fixunshfdi
; CHECK32-IZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_lu_h:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.h fa5, fa0
; CHECK64-IZFHMIN-NEXT:    fcvt.lu.s a0, fa5, rtz
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_lu_h:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    call __fixunshfdi
; CHECK32-IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_lu_h:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.lu.s a0, a0, rtz
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_lu_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    call __fixunssfdi
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call i64 @llvm.experimental.constrained.fptoui.i64.f16(half %a, metadata !"fpexcept.strict")
  ret i64 %1
}

define half @fcvt_h_si(i16 %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_si:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    slli a0, a0, 16
; CHECK32-IZFH-NEXT:    srai a0, a0, 16
; CHECK32-IZFH-NEXT:    fcvt.h.w fa0, a0
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_si:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    slli a0, a0, 48
; CHECK64-IZFH-NEXT:    srai a0, a0, 48
; CHECK64-IZFH-NEXT:    fcvt.h.w fa0, a0
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_si:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    slli a0, a0, 16
; CHECK32-IZHINX-NEXT:    srai a0, a0, 16
; CHECK32-IZHINX-NEXT:    fcvt.h.w a0, a0
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_si:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    slli a0, a0, 48
; CHECK64-IZHINX-NEXT:    srai a0, a0, 48
; CHECK64-IZHINX-NEXT:    fcvt.h.w a0, a0
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_si:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    slli a0, a0, 16
; CHECK32-IZFHMIN-NEXT:    srai a0, a0, 16
; CHECK32-IZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECK32-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_si:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    slli a0, a0, 48
; CHECK64-IZFHMIN-NEXT:    srai a0, a0, 48
; CHECK64-IZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_si:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    slli a0, a0, 16
; CHECK32-IZHINXMIN-NEXT:    srai a0, a0, 16
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_si:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    slli a0, a0, 48
; CHECK64-IZHINXMIN-NEXT:    srai a0, a0, 48
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_si:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srai a0, a0, 16
; CHECK32-D-NEXT:    fcvt.s.w fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.sitofp.f16.i16(i16 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_si_signext(i16 signext %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_si_signext:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_si_signext:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_si_signext:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_si_signext:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_si_signext:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_si_signext:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_si_signext:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_si_signext:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_si_signext:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fcvt.s.w fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.sitofp.f16.i16(i16 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_ui(i16 %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_ui:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    slli a0, a0, 16
; CHECK32-IZFH-NEXT:    srli a0, a0, 16
; CHECK32-IZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_ui:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    slli a0, a0, 48
; CHECK64-IZFH-NEXT:    srli a0, a0, 48
; CHECK64-IZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_ui:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    slli a0, a0, 16
; CHECK32-IZHINX-NEXT:    srli a0, a0, 16
; CHECK32-IZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_ui:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    slli a0, a0, 48
; CHECK64-IZHINX-NEXT:    srli a0, a0, 48
; CHECK64-IZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_ui:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    slli a0, a0, 16
; CHECK32-IZFHMIN-NEXT:    srli a0, a0, 16
; CHECK32-IZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECK32-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_ui:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    slli a0, a0, 48
; CHECK64-IZFHMIN-NEXT:    srli a0, a0, 48
; CHECK64-IZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_ui:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    slli a0, a0, 16
; CHECK32-IZHINXMIN-NEXT:    srli a0, a0, 16
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_ui:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    slli a0, a0, 48
; CHECK64-IZHINXMIN-NEXT:    srli a0, a0, 48
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_ui:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fcvt.s.wu fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.uitofp.f16.i16(i16 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_ui_zeroext(i16 zeroext %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_ui_zeroext:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_ui_zeroext:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_ui_zeroext:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_ui_zeroext:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_ui_zeroext:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_ui_zeroext:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_ui_zeroext:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_ui_zeroext:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_ui_zeroext:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fcvt.s.wu fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.uitofp.f16.i16(i16 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_w(i32 %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_w:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_w:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_w:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_w:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_w:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_w:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_w:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_w:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_w:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fcvt.s.w fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.sitofp.f16.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_w_load(ptr %p) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_w_load:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    lw a0, 0(a0)
; CHECKIZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_w_load:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    lw a0, 0(a0)
; CHECKIZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_w_load:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    lw a0, 0(a0)
; CHECKIDZFH-NEXT:    fcvt.h.w fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_w_load:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    lw a0, 0(a0)
; CHECKIZDINXZHINX-NEXT:    fcvt.h.w a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_w_load:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    lw a0, 0(a0)
; CHECKIZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_w_load:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    lw a0, 0(a0)
; CHECKIZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_w_load:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    lw a0, 0(a0)
; CHECKIDZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_w_load:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    lw a0, 0(a0)
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.w a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_w_load:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    lw a0, 0(a0)
; CHECK32-D-NEXT:    fcvt.s.w fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %a = load i32, ptr %p
  %1 = call half @llvm.experimental.constrained.sitofp.f16.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_wu(i32 %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_wu:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_wu:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_wu:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_wu:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_wu:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_wu:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_wu:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_wu:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_wu:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fcvt.s.wu fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.uitofp.f16.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_wu_load(ptr %p) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_wu_load:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    lw a0, 0(a0)
; CHECKIZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_wu_load:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    lw a0, 0(a0)
; CHECKIZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_wu_load:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    lw a0, 0(a0)
; CHECKIDZFH-NEXT:    fcvt.h.wu fa0, a0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_wu_load:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    lw a0, 0(a0)
; CHECKIZDINXZHINX-NEXT:    fcvt.h.wu a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_wu_load:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    lw a0, 0(a0)
; CHECKIZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_wu_load:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    lw a0, 0(a0)
; CHECKIZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_wu_load:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    lw a0, 0(a0)
; CHECKIDZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_wu_load:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    lw a0, 0(a0)
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.wu a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_wu_load:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    lw a0, 0(a0)
; CHECK32-D-NEXT:    fcvt.s.wu fa0, a0
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %a = load i32, ptr %p
  %1 = call half @llvm.experimental.constrained.uitofp.f16.i32(i32 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_l(i64 %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_l:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -16
; CHECK32-IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    call __floatdihf
; CHECK32-IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 16
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_l:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.h.l fa0, a0
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_l:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -16
; CHECK32-IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    call __floatdihf
; CHECK32-IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 16
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_l:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.h.l a0, a0
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_l:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    call __floatdihf
; CHECK32-IZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_l:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.l fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_l:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    call __floatdihf
; CHECK32-IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_l:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.l a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_l:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    call __floatdisf
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.sitofp.f16.i64(i64 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_lu(i64 %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_lu:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -16
; CHECK32-IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    call __floatundihf
; CHECK32-IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 16
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_lu:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    fcvt.h.lu fa0, a0
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_lu:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -16
; CHECK32-IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    call __floatundihf
; CHECK32-IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 16
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_lu:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    fcvt.h.lu a0, a0
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_lu:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    call __floatundihf
; CHECK32-IZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_lu:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    fcvt.s.lu fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa0, fa5
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_lu:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK32-IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    call __floatundihf
; CHECK32-IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_lu:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.lu a0, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_lu:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    call __floatundisf
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.uitofp.f16.i64(i64 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define half @fcvt_h_s(float %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_h_s:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.h.s fa0, fa0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_h_s:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_s:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.s fa0, fa0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_s:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_h_s:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.h.s fa0, fa0
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_h_s:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_s:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.h.s fa0, fa0
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_s:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.s a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_s:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.fptrunc.f16.f32(float %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define float @fcvt_s_h(half %a) nounwind strictfp {
; CHECKIZFH-LABEL: fcvt_s_h:
; CHECKIZFH:       # %bb.0:
; CHECKIZFH-NEXT:    fcvt.s.h fa0, fa0
; CHECKIZFH-NEXT:    ret
;
; CHECKIZHINX-LABEL: fcvt_s_h:
; CHECKIZHINX:       # %bb.0:
; CHECKIZHINX-NEXT:    fcvt.s.h a0, a0
; CHECKIZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_s_h:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.s.h fa0, fa0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_s_h:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.s.h a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; CHECKIZFHMIN-LABEL: fcvt_s_h:
; CHECKIZFHMIN:       # %bb.0:
; CHECKIZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; CHECKIZFHMIN-NEXT:    ret
;
; CHECKIZHINXMIN-LABEL: fcvt_s_h:
; CHECKIZHINXMIN:       # %bb.0:
; CHECKIZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_s_h:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_s_h:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_s_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call float @llvm.experimental.constrained.fpext.f32.f16(half %a, metadata !"fpexcept.strict")
  ret float %1
}

define half @fcvt_h_d(double %a) nounwind strictfp {
; RV32IZFH-LABEL: fcvt_h_d:
; RV32IZFH:       # %bb.0:
; RV32IZFH-NEXT:    addi sp, sp, -16
; RV32IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZFH-NEXT:    call __truncdfhf2
; RV32IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZFH-NEXT:    addi sp, sp, 16
; RV32IZFH-NEXT:    ret
;
; RV64IZFH-LABEL: fcvt_h_d:
; RV64IZFH:       # %bb.0:
; RV64IZFH-NEXT:    addi sp, sp, -16
; RV64IZFH-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZFH-NEXT:    call __truncdfhf2
; RV64IZFH-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZFH-NEXT:    addi sp, sp, 16
; RV64IZFH-NEXT:    ret
;
; RV32IZHINX-LABEL: fcvt_h_d:
; RV32IZHINX:       # %bb.0:
; RV32IZHINX-NEXT:    addi sp, sp, -16
; RV32IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZHINX-NEXT:    call __truncdfhf2
; RV32IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZHINX-NEXT:    addi sp, sp, 16
; RV32IZHINX-NEXT:    ret
;
; RV64IZHINX-LABEL: fcvt_h_d:
; RV64IZHINX:       # %bb.0:
; RV64IZHINX-NEXT:    addi sp, sp, -16
; RV64IZHINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZHINX-NEXT:    call __truncdfhf2
; RV64IZHINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZHINX-NEXT:    addi sp, sp, 16
; RV64IZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_h_d:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.h.d fa0, fa0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_h_d:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.h.d a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; RV32IFZFHMIN-LABEL: fcvt_h_d:
; RV32IFZFHMIN:       # %bb.0:
; RV32IFZFHMIN-NEXT:    addi sp, sp, -16
; RV32IFZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IFZFHMIN-NEXT:    call __truncdfhf2
; RV32IFZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IFZFHMIN-NEXT:    addi sp, sp, 16
; RV32IFZFHMIN-NEXT:    ret
;
; RV64IFZFHMIN-LABEL: fcvt_h_d:
; RV64IFZFHMIN:       # %bb.0:
; RV64IFZFHMIN-NEXT:    addi sp, sp, -16
; RV64IFZFHMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IFZFHMIN-NEXT:    call __truncdfhf2
; RV64IFZFHMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IFZFHMIN-NEXT:    addi sp, sp, 16
; RV64IFZFHMIN-NEXT:    ret
;
; RV32IZHINXMIN-LABEL: fcvt_h_d:
; RV32IZHINXMIN:       # %bb.0:
; RV32IZHINXMIN-NEXT:    addi sp, sp, -16
; RV32IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZHINXMIN-NEXT:    call __truncdfhf2
; RV32IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZHINXMIN-NEXT:    addi sp, sp, 16
; RV32IZHINXMIN-NEXT:    ret
;
; RV64IZHINXMIN-LABEL: fcvt_h_d:
; RV64IZHINXMIN:       # %bb.0:
; RV64IZHINXMIN-NEXT:    addi sp, sp, -16
; RV64IZHINXMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZHINXMIN-NEXT:    call __truncdfhf2
; RV64IZHINXMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZHINXMIN-NEXT:    addi sp, sp, 16
; RV64IZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_h_d:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.h.d fa0, fa0
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_h_d:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.h.d a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_d:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    call __truncdfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.fptrunc.f16.f64(double %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define double @fcvt_d_h(half %a) nounwind strictfp {
; RV32IZFH-LABEL: fcvt_d_h:
; RV32IZFH:       # %bb.0:
; RV32IZFH-NEXT:    addi sp, sp, -16
; RV32IZFH-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZFH-NEXT:    fcvt.s.h fa0, fa0
; RV32IZFH-NEXT:    call __extendsfdf2
; RV32IZFH-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZFH-NEXT:    addi sp, sp, 16
; RV32IZFH-NEXT:    ret
;
; RV64IZFH-LABEL: fcvt_d_h:
; RV64IZFH:       # %bb.0:
; RV64IZFH-NEXT:    addi sp, sp, -16
; RV64IZFH-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZFH-NEXT:    fcvt.s.h fa0, fa0
; RV64IZFH-NEXT:    call __extendsfdf2
; RV64IZFH-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZFH-NEXT:    addi sp, sp, 16
; RV64IZFH-NEXT:    ret
;
; RV32IZHINX-LABEL: fcvt_d_h:
; RV32IZHINX:       # %bb.0:
; RV32IZHINX-NEXT:    addi sp, sp, -16
; RV32IZHINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZHINX-NEXT:    fcvt.s.h a0, a0
; RV32IZHINX-NEXT:    call __extendsfdf2
; RV32IZHINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZHINX-NEXT:    addi sp, sp, 16
; RV32IZHINX-NEXT:    ret
;
; RV64IZHINX-LABEL: fcvt_d_h:
; RV64IZHINX:       # %bb.0:
; RV64IZHINX-NEXT:    addi sp, sp, -16
; RV64IZHINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZHINX-NEXT:    fcvt.s.h a0, a0
; RV64IZHINX-NEXT:    call __extendsfdf2
; RV64IZHINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZHINX-NEXT:    addi sp, sp, 16
; RV64IZHINX-NEXT:    ret
;
; CHECKIDZFH-LABEL: fcvt_d_h:
; CHECKIDZFH:       # %bb.0:
; CHECKIDZFH-NEXT:    fcvt.d.h fa0, fa0
; CHECKIDZFH-NEXT:    ret
;
; CHECKIZDINXZHINX-LABEL: fcvt_d_h:
; CHECKIZDINXZHINX:       # %bb.0:
; CHECKIZDINXZHINX-NEXT:    fcvt.d.h a0, a0
; CHECKIZDINXZHINX-NEXT:    ret
;
; RV32IFZFHMIN-LABEL: fcvt_d_h:
; RV32IFZFHMIN:       # %bb.0:
; RV32IFZFHMIN-NEXT:    addi sp, sp, -16
; RV32IFZFHMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IFZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; RV32IFZFHMIN-NEXT:    call __extendsfdf2
; RV32IFZFHMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IFZFHMIN-NEXT:    addi sp, sp, 16
; RV32IFZFHMIN-NEXT:    ret
;
; RV64IFZFHMIN-LABEL: fcvt_d_h:
; RV64IFZFHMIN:       # %bb.0:
; RV64IFZFHMIN-NEXT:    addi sp, sp, -16
; RV64IFZFHMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IFZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; RV64IFZFHMIN-NEXT:    call __extendsfdf2
; RV64IFZFHMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IFZFHMIN-NEXT:    addi sp, sp, 16
; RV64IFZFHMIN-NEXT:    ret
;
; RV32IZHINXMIN-LABEL: fcvt_d_h:
; RV32IZHINXMIN:       # %bb.0:
; RV32IZHINXMIN-NEXT:    addi sp, sp, -16
; RV32IZHINXMIN-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; RV32IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; RV32IZHINXMIN-NEXT:    call __extendsfdf2
; RV32IZHINXMIN-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; RV32IZHINXMIN-NEXT:    addi sp, sp, 16
; RV32IZHINXMIN-NEXT:    ret
;
; RV64IZHINXMIN-LABEL: fcvt_d_h:
; RV64IZHINXMIN:       # %bb.0:
; RV64IZHINXMIN-NEXT:    addi sp, sp, -16
; RV64IZHINXMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; RV64IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; RV64IZHINXMIN-NEXT:    call __extendsfdf2
; RV64IZHINXMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; RV64IZHINXMIN-NEXT:    addi sp, sp, 16
; RV64IZHINXMIN-NEXT:    ret
;
; CHECKIDZFHMIN-LABEL: fcvt_d_h:
; CHECKIDZFHMIN:       # %bb.0:
; CHECKIDZFHMIN-NEXT:    fcvt.d.h fa0, fa0
; CHECKIDZFHMIN-NEXT:    ret
;
; CHECKIZDINXZHINXMIN-LABEL: fcvt_d_h:
; CHECKIZDINXZHINXMIN:       # %bb.0:
; CHECKIZDINXZHINXMIN-NEXT:    fcvt.d.h a0, a0
; CHECKIZDINXZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_d_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    fcvt.d.s fa0, fa0
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    ret
  %1 = call double @llvm.experimental.constrained.fpext.f64.f16(half %a, metadata !"fpexcept.strict")
  ret double %1
}

; Make sure we select W version of addi on RV64.
define signext i32 @fcvt_h_w_demanded_bits(i32 signext %0, ptr %1) strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_w_demanded_bits:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi a0, a0, 1
; CHECK32-IZFH-NEXT:    fcvt.h.w fa5, a0
; CHECK32-IZFH-NEXT:    fsh fa5, 0(a1)
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_w_demanded_bits:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    addiw a0, a0, 1
; CHECK64-IZFH-NEXT:    fcvt.h.w fa5, a0
; CHECK64-IZFH-NEXT:    fsh fa5, 0(a1)
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_w_demanded_bits:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi a0, a0, 1
; CHECK32-IZHINX-NEXT:    fcvt.h.w a2, a0
; CHECK32-IZHINX-NEXT:    sh a2, 0(a1)
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_w_demanded_bits:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    addiw a0, a0, 1
; CHECK64-IZHINX-NEXT:    fcvt.h.w a2, a0
; CHECK64-IZHINX-NEXT:    sh a2, 0(a1)
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_w_demanded_bits:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi a0, a0, 1
; CHECK32-IZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECK32-IZFHMIN-NEXT:    fcvt.h.s fa5, fa5
; CHECK32-IZFHMIN-NEXT:    fsh fa5, 0(a1)
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_w_demanded_bits:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    addiw a0, a0, 1
; CHECK64-IZFHMIN-NEXT:    fcvt.s.w fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa5, fa5
; CHECK64-IZFHMIN-NEXT:    fsh fa5, 0(a1)
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_w_demanded_bits:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi a0, a0, 1
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.w a2, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.h.s a2, a2
; CHECK32-IZHINXMIN-NEXT:    sh a2, 0(a1)
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_w_demanded_bits:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    addiw a0, a0, 1
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.w a2, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a2, a2
; CHECK64-IZHINXMIN-NEXT:    sh a2, 0(a1)
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_w_demanded_bits:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    .cfi_offset ra, -4
; CHECK32-D-NEXT:    .cfi_offset s0, -8
; CHECK32-D-NEXT:    .cfi_offset s1, -12
; CHECK32-D-NEXT:    mv s0, a1
; CHECK32-D-NEXT:    addi s1, a0, 1
; CHECK32-D-NEXT:    fcvt.s.w fa0, s1
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    sh a0, 0(s0)
; CHECK32-D-NEXT:    mv a0, s1
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    lw s0, 8(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    lw s1, 4(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    .cfi_restore ra
; CHECK32-D-NEXT:    .cfi_restore s0
; CHECK32-D-NEXT:    .cfi_restore s1
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 0
; CHECK32-D-NEXT:    ret
  %3 = add i32 %0, 1
  %4 = call half @llvm.experimental.constrained.sitofp.f16.i32(i32 %3, metadata !"round.dynamic", metadata !"fpexcept.strict")
  store half %4, ptr %1, align 2
  ret i32 %3
}

; Make sure we select W version of addi on RV64.
define signext i32 @fcvt_h_wu_demanded_bits(i32 signext %0, ptr %1) strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_wu_demanded_bits:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi a0, a0, 1
; CHECK32-IZFH-NEXT:    fcvt.h.wu fa5, a0
; CHECK32-IZFH-NEXT:    fsh fa5, 0(a1)
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_wu_demanded_bits:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    addiw a0, a0, 1
; CHECK64-IZFH-NEXT:    fcvt.h.wu fa5, a0
; CHECK64-IZFH-NEXT:    fsh fa5, 0(a1)
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_wu_demanded_bits:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi a0, a0, 1
; CHECK32-IZHINX-NEXT:    fcvt.h.wu a2, a0
; CHECK32-IZHINX-NEXT:    sh a2, 0(a1)
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_wu_demanded_bits:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    addiw a0, a0, 1
; CHECK64-IZHINX-NEXT:    fcvt.h.wu a2, a0
; CHECK64-IZHINX-NEXT:    sh a2, 0(a1)
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_wu_demanded_bits:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi a0, a0, 1
; CHECK32-IZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECK32-IZFHMIN-NEXT:    fcvt.h.s fa5, fa5
; CHECK32-IZFHMIN-NEXT:    fsh fa5, 0(a1)
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_wu_demanded_bits:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    addiw a0, a0, 1
; CHECK64-IZFHMIN-NEXT:    fcvt.s.wu fa5, a0
; CHECK64-IZFHMIN-NEXT:    fcvt.h.s fa5, fa5
; CHECK64-IZFHMIN-NEXT:    fsh fa5, 0(a1)
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_wu_demanded_bits:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi a0, a0, 1
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.wu a2, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.h.s a2, a2
; CHECK32-IZHINXMIN-NEXT:    sh a2, 0(a1)
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_wu_demanded_bits:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    addiw a0, a0, 1
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.wu a2, a0
; CHECK64-IZHINXMIN-NEXT:    fcvt.h.s a2, a2
; CHECK64-IZHINXMIN-NEXT:    sh a2, 0(a1)
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_wu_demanded_bits:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 16
; CHECK32-D-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    .cfi_offset ra, -4
; CHECK32-D-NEXT:    .cfi_offset s0, -8
; CHECK32-D-NEXT:    .cfi_offset s1, -12
; CHECK32-D-NEXT:    mv s0, a1
; CHECK32-D-NEXT:    addi s1, a0, 1
; CHECK32-D-NEXT:    fcvt.s.wu fa0, s1
; CHECK32-D-NEXT:    call __truncsfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    sh a0, 0(s0)
; CHECK32-D-NEXT:    mv a0, s1
; CHECK32-D-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    lw s0, 8(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    lw s1, 4(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    .cfi_restore ra
; CHECK32-D-NEXT:    .cfi_restore s0
; CHECK32-D-NEXT:    .cfi_restore s1
; CHECK32-D-NEXT:    addi sp, sp, 16
; CHECK32-D-NEXT:    .cfi_def_cfa_offset 0
; CHECK32-D-NEXT:    ret
  %3 = add i32 %0, 1
  %4 = call half @llvm.experimental.constrained.uitofp.f16.i32(i32 %3, metadata !"round.dynamic", metadata !"fpexcept.strict")
  store half %4, ptr %1, align 2
  ret i32 %3
}

define half @fcvt_h_q(fp128 %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_h_q:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -32
; CHECK32-IZFH-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    lw a1, 0(a0)
; CHECK32-IZFH-NEXT:    lw a2, 4(a0)
; CHECK32-IZFH-NEXT:    lw a3, 8(a0)
; CHECK32-IZFH-NEXT:    lw a4, 12(a0)
; CHECK32-IZFH-NEXT:    addi a0, sp, 8
; CHECK32-IZFH-NEXT:    sw a1, 8(sp)
; CHECK32-IZFH-NEXT:    sw a2, 12(sp)
; CHECK32-IZFH-NEXT:    sw a3, 16(sp)
; CHECK32-IZFH-NEXT:    sw a4, 20(sp)
; CHECK32-IZFH-NEXT:    call __trunctfhf2
; CHECK32-IZFH-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 32
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_h_q:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    addi sp, sp, -16
; CHECK64-IZFH-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZFH-NEXT:    call __trunctfhf2
; CHECK64-IZFH-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZFH-NEXT:    addi sp, sp, 16
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_h_q:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -32
; CHECK32-IZHINX-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    lw a1, 0(a0)
; CHECK32-IZHINX-NEXT:    lw a2, 4(a0)
; CHECK32-IZHINX-NEXT:    lw a3, 8(a0)
; CHECK32-IZHINX-NEXT:    lw a4, 12(a0)
; CHECK32-IZHINX-NEXT:    addi a0, sp, 8
; CHECK32-IZHINX-NEXT:    sw a1, 8(sp)
; CHECK32-IZHINX-NEXT:    sw a2, 12(sp)
; CHECK32-IZHINX-NEXT:    sw a3, 16(sp)
; CHECK32-IZHINX-NEXT:    sw a4, 20(sp)
; CHECK32-IZHINX-NEXT:    call __trunctfhf2
; CHECK32-IZHINX-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 32
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_h_q:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    addi sp, sp, -16
; CHECK64-IZHINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZHINX-NEXT:    call __trunctfhf2
; CHECK64-IZHINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZHINX-NEXT:    addi sp, sp, 16
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_h_q:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -32
; CHECK32-IZFHMIN-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    lw a1, 0(a0)
; CHECK32-IZFHMIN-NEXT:    lw a2, 4(a0)
; CHECK32-IZFHMIN-NEXT:    lw a3, 8(a0)
; CHECK32-IZFHMIN-NEXT:    lw a4, 12(a0)
; CHECK32-IZFHMIN-NEXT:    addi a0, sp, 8
; CHECK32-IZFHMIN-NEXT:    sw a1, 8(sp)
; CHECK32-IZFHMIN-NEXT:    sw a2, 12(sp)
; CHECK32-IZFHMIN-NEXT:    sw a3, 16(sp)
; CHECK32-IZFHMIN-NEXT:    sw a4, 20(sp)
; CHECK32-IZFHMIN-NEXT:    call __trunctfhf2
; CHECK32-IZFHMIN-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 32
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_h_q:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK64-IZFHMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZFHMIN-NEXT:    call __trunctfhf2
; CHECK64-IZFHMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_h_q:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -32
; CHECK32-IZHINXMIN-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    lw a1, 0(a0)
; CHECK32-IZHINXMIN-NEXT:    lw a2, 4(a0)
; CHECK32-IZHINXMIN-NEXT:    lw a3, 8(a0)
; CHECK32-IZHINXMIN-NEXT:    lw a4, 12(a0)
; CHECK32-IZHINXMIN-NEXT:    addi a0, sp, 8
; CHECK32-IZHINXMIN-NEXT:    sw a1, 8(sp)
; CHECK32-IZHINXMIN-NEXT:    sw a2, 12(sp)
; CHECK32-IZHINXMIN-NEXT:    sw a3, 16(sp)
; CHECK32-IZHINXMIN-NEXT:    sw a4, 20(sp)
; CHECK32-IZHINXMIN-NEXT:    call __trunctfhf2
; CHECK32-IZHINXMIN-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 32
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_h_q:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK64-IZHINXMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZHINXMIN-NEXT:    call __trunctfhf2
; CHECK64-IZHINXMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_h_q:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -32
; CHECK32-D-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    lw a1, 0(a0)
; CHECK32-D-NEXT:    lw a2, 4(a0)
; CHECK32-D-NEXT:    lw a3, 8(a0)
; CHECK32-D-NEXT:    lw a4, 12(a0)
; CHECK32-D-NEXT:    addi a0, sp, 8
; CHECK32-D-NEXT:    sw a1, 8(sp)
; CHECK32-D-NEXT:    sw a2, 12(sp)
; CHECK32-D-NEXT:    sw a3, 16(sp)
; CHECK32-D-NEXT:    sw a4, 20(sp)
; CHECK32-D-NEXT:    call __trunctfhf2
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    lui a1, 1048560
; CHECK32-D-NEXT:    or a0, a0, a1
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 32
; CHECK32-D-NEXT:    ret
  %1 = call half @llvm.experimental.constrained.fptrunc.f16.f128(fp128 %a, metadata !"round.dynamic", metadata !"fpexcept.strict")
  ret half %1
}

define fp128 @fcvt_q_h(half %a) nounwind strictfp {
; CHECK32-IZFH-LABEL: fcvt_q_h:
; CHECK32-IZFH:       # %bb.0:
; CHECK32-IZFH-NEXT:    addi sp, sp, -32
; CHECK32-IZFH-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
; CHECK32-IZFH-NEXT:    mv s0, a0
; CHECK32-IZFH-NEXT:    fcvt.s.h fa0, fa0
; CHECK32-IZFH-NEXT:    addi a0, sp, 8
; CHECK32-IZFH-NEXT:    call __extendsftf2
; CHECK32-IZFH-NEXT:    lw a0, 8(sp)
; CHECK32-IZFH-NEXT:    lw a1, 12(sp)
; CHECK32-IZFH-NEXT:    lw a2, 16(sp)
; CHECK32-IZFH-NEXT:    lw a3, 20(sp)
; CHECK32-IZFH-NEXT:    sw a0, 0(s0)
; CHECK32-IZFH-NEXT:    sw a1, 4(s0)
; CHECK32-IZFH-NEXT:    sw a2, 8(s0)
; CHECK32-IZFH-NEXT:    sw a3, 12(s0)
; CHECK32-IZFH-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
; CHECK32-IZFH-NEXT:    addi sp, sp, 32
; CHECK32-IZFH-NEXT:    ret
;
; CHECK64-IZFH-LABEL: fcvt_q_h:
; CHECK64-IZFH:       # %bb.0:
; CHECK64-IZFH-NEXT:    addi sp, sp, -16
; CHECK64-IZFH-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZFH-NEXT:    fcvt.s.h fa0, fa0
; CHECK64-IZFH-NEXT:    call __extendsftf2
; CHECK64-IZFH-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZFH-NEXT:    addi sp, sp, 16
; CHECK64-IZFH-NEXT:    ret
;
; CHECK32-IZHINX-LABEL: fcvt_q_h:
; CHECK32-IZHINX:       # %bb.0:
; CHECK32-IZHINX-NEXT:    addi sp, sp, -32
; CHECK32-IZHINX-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
; CHECK32-IZHINX-NEXT:    mv s0, a0
; CHECK32-IZHINX-NEXT:    fcvt.s.h a1, a1
; CHECK32-IZHINX-NEXT:    addi a0, sp, 8
; CHECK32-IZHINX-NEXT:    call __extendsftf2
; CHECK32-IZHINX-NEXT:    lw a0, 8(sp)
; CHECK32-IZHINX-NEXT:    lw a1, 12(sp)
; CHECK32-IZHINX-NEXT:    lw a2, 16(sp)
; CHECK32-IZHINX-NEXT:    lw a3, 20(sp)
; CHECK32-IZHINX-NEXT:    sw a0, 0(s0)
; CHECK32-IZHINX-NEXT:    sw a1, 4(s0)
; CHECK32-IZHINX-NEXT:    sw a2, 8(s0)
; CHECK32-IZHINX-NEXT:    sw a3, 12(s0)
; CHECK32-IZHINX-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
; CHECK32-IZHINX-NEXT:    addi sp, sp, 32
; CHECK32-IZHINX-NEXT:    ret
;
; CHECK64-IZHINX-LABEL: fcvt_q_h:
; CHECK64-IZHINX:       # %bb.0:
; CHECK64-IZHINX-NEXT:    addi sp, sp, -16
; CHECK64-IZHINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZHINX-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINX-NEXT:    call __extendsftf2
; CHECK64-IZHINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZHINX-NEXT:    addi sp, sp, 16
; CHECK64-IZHINX-NEXT:    ret
;
; CHECK32-IZFHMIN-LABEL: fcvt_q_h:
; CHECK32-IZFHMIN:       # %bb.0:
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, -32
; CHECK32-IZFHMIN-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
; CHECK32-IZFHMIN-NEXT:    mv s0, a0
; CHECK32-IZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; CHECK32-IZFHMIN-NEXT:    addi a0, sp, 8
; CHECK32-IZFHMIN-NEXT:    call __extendsftf2
; CHECK32-IZFHMIN-NEXT:    lw a0, 8(sp)
; CHECK32-IZFHMIN-NEXT:    lw a1, 12(sp)
; CHECK32-IZFHMIN-NEXT:    lw a2, 16(sp)
; CHECK32-IZFHMIN-NEXT:    lw a3, 20(sp)
; CHECK32-IZFHMIN-NEXT:    sw a0, 0(s0)
; CHECK32-IZFHMIN-NEXT:    sw a1, 4(s0)
; CHECK32-IZFHMIN-NEXT:    sw a2, 8(s0)
; CHECK32-IZFHMIN-NEXT:    sw a3, 12(s0)
; CHECK32-IZFHMIN-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
; CHECK32-IZFHMIN-NEXT:    addi sp, sp, 32
; CHECK32-IZFHMIN-NEXT:    ret
;
; CHECK64-IZFHMIN-LABEL: fcvt_q_h:
; CHECK64-IZFHMIN:       # %bb.0:
; CHECK64-IZFHMIN-NEXT:    addi sp, sp, -16
; CHECK64-IZFHMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZFHMIN-NEXT:    fcvt.s.h fa0, fa0
; CHECK64-IZFHMIN-NEXT:    call __extendsftf2
; CHECK64-IZFHMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZFHMIN-NEXT:    addi sp, sp, 16
; CHECK64-IZFHMIN-NEXT:    ret
;
; CHECK32-IZHINXMIN-LABEL: fcvt_q_h:
; CHECK32-IZHINXMIN:       # %bb.0:
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, -32
; CHECK32-IZHINXMIN-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
; CHECK32-IZHINXMIN-NEXT:    mv s0, a0
; CHECK32-IZHINXMIN-NEXT:    fcvt.s.h a1, a1
; CHECK32-IZHINXMIN-NEXT:    addi a0, sp, 8
; CHECK32-IZHINXMIN-NEXT:    call __extendsftf2
; CHECK32-IZHINXMIN-NEXT:    lw a0, 8(sp)
; CHECK32-IZHINXMIN-NEXT:    lw a1, 12(sp)
; CHECK32-IZHINXMIN-NEXT:    lw a2, 16(sp)
; CHECK32-IZHINXMIN-NEXT:    lw a3, 20(sp)
; CHECK32-IZHINXMIN-NEXT:    sw a0, 0(s0)
; CHECK32-IZHINXMIN-NEXT:    sw a1, 4(s0)
; CHECK32-IZHINXMIN-NEXT:    sw a2, 8(s0)
; CHECK32-IZHINXMIN-NEXT:    sw a3, 12(s0)
; CHECK32-IZHINXMIN-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
; CHECK32-IZHINXMIN-NEXT:    addi sp, sp, 32
; CHECK32-IZHINXMIN-NEXT:    ret
;
; CHECK64-IZHINXMIN-LABEL: fcvt_q_h:
; CHECK64-IZHINXMIN:       # %bb.0:
; CHECK64-IZHINXMIN-NEXT:    addi sp, sp, -16
; CHECK64-IZHINXMIN-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
; CHECK64-IZHINXMIN-NEXT:    fcvt.s.h a0, a0
; CHECK64-IZHINXMIN-NEXT:    call __extendsftf2
; CHECK64-IZHINXMIN-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
; CHECK64-IZHINXMIN-NEXT:    addi sp, sp, 16
; CHECK64-IZHINXMIN-NEXT:    ret
;
; CHECK32-D-LABEL: fcvt_q_h:
; CHECK32-D:       # %bb.0:
; CHECK32-D-NEXT:    addi sp, sp, -32
; CHECK32-D-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
; CHECK32-D-NEXT:    mv s0, a0
; CHECK32-D-NEXT:    fmv.x.w a0, fa0
; CHECK32-D-NEXT:    slli a0, a0, 16
; CHECK32-D-NEXT:    srli a0, a0, 16
; CHECK32-D-NEXT:    fmv.w.x fa0, a0
; CHECK32-D-NEXT:    call __extendhfsf2
; CHECK32-D-NEXT:    addi a0, sp, 8
; CHECK32-D-NEXT:    call __extendsftf2
; CHECK32-D-NEXT:    lw a0, 8(sp)
; CHECK32-D-NEXT:    lw a1, 12(sp)
; CHECK32-D-NEXT:    lw a2, 16(sp)
; CHECK32-D-NEXT:    lw a3, 20(sp)
; CHECK32-D-NEXT:    sw a0, 0(s0)
; CHECK32-D-NEXT:    sw a1, 4(s0)
; CHECK32-D-NEXT:    sw a2, 8(s0)
; CHECK32-D-NEXT:    sw a3, 12(s0)
; CHECK32-D-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
; CHECK32-D-NEXT:    addi sp, sp, 32
; CHECK32-D-NEXT:    ret
  %1 = call fp128 @llvm.experimental.constrained.fpext.f128.f16(half %a, metadata !"fpexcept.strict")
  ret fp128 %1
}