forked from OSchip/llvm-project
1030 lines
28 KiB
LLVM
1030 lines
28 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
|
|
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx512fp16 -mattr=+avx512vl | FileCheck %s --check-prefixes=CHECK,X64
|
|
; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+avx512fp16 -mattr=+avx512vl | FileCheck %s --check-prefixes=CHECK,X86
|
|
|
|
define half @f32tof16(float %b) nounwind {
|
|
; X64-LABEL: f32tof16:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtss2sh %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f32tof16:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
|
|
; X86-NEXT: vcvtss2sh %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = fptrunc float %b to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @f64tof16(double %b) nounwind {
|
|
; X64-LABEL: f64tof16:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsd2sh %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f64tof16:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; X86-NEXT: vcvtsd2sh %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = fptrunc double %b to half
|
|
ret half %a
|
|
}
|
|
|
|
define <16 x half> @f32to16f16(<16 x float> %b) nounwind {
|
|
; CHECK-LABEL: f32to16f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtps2phx %zmm0, %ymm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <16 x float> %b to <16 x half>
|
|
ret <16 x half> %a
|
|
}
|
|
|
|
define <8 x half> @f32to8f16(<8 x float> %b) {
|
|
; CHECK-LABEL: f32to8f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtps2phx %ymm0, %xmm0
|
|
; CHECK-NEXT: vzeroupper
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <8 x float> %b to <8 x half>
|
|
ret <8 x half> %a
|
|
}
|
|
|
|
define <4 x half> @f32to4f16(<4 x float> %b) {
|
|
; CHECK-LABEL: f32to4f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtps2phx %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <4 x float> %b to <4 x half>
|
|
ret <4 x half> %a
|
|
}
|
|
|
|
define <2 x half> @f32to2f16(<2 x float> %b) {
|
|
; CHECK-LABEL: f32to2f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtps2phx %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <2 x float> %b to <2 x half>
|
|
ret <2 x half> %a
|
|
}
|
|
|
|
declare <8 x half> @llvm.x86.avx512fp16.mask.vcvtps2phx.128(<4 x float>, <8 x half>, i8)
|
|
declare <8 x half> @llvm.x86.avx512fp16.mask.vcvtps2phx.256(<8 x float>, <8 x half>, i8)
|
|
|
|
define <8 x half> @f32to4f16_mask(<4 x float> %a, <8 x half> %b, i8 %mask) {
|
|
; X64-LABEL: f32to4f16_mask:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: kmovd %edi, %k1
|
|
; X64-NEXT: vcvtps2phx %xmm0, %xmm1 {%k1}
|
|
; X64-NEXT: vmovaps %xmm1, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f32to4f16_mask:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: kmovb {{[0-9]+}}(%esp), %k1
|
|
; X86-NEXT: vcvtps2phx %xmm0, %xmm1 {%k1}
|
|
; X86-NEXT: vmovaps %xmm1, %xmm0
|
|
; X86-NEXT: retl
|
|
%res = call <8 x half> @llvm.x86.avx512fp16.mask.vcvtps2phx.128(<4 x float> %a, <8 x half> %b, i8 %mask)
|
|
ret <8 x half> %res
|
|
}
|
|
|
|
define <8 x half> @f32to8f16_mask(<8 x float> %a, <8 x half> %b, i8 %mask) {
|
|
; X64-LABEL: f32to8f16_mask:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: kmovd %edi, %k1
|
|
; X64-NEXT: vcvtps2phx %ymm0, %xmm1 {%k1}
|
|
; X64-NEXT: vmovaps %xmm1, %xmm0
|
|
; X64-NEXT: vzeroupper
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f32to8f16_mask:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: kmovb {{[0-9]+}}(%esp), %k1
|
|
; X86-NEXT: vcvtps2phx %ymm0, %xmm1 {%k1}
|
|
; X86-NEXT: vmovaps %xmm1, %xmm0
|
|
; X86-NEXT: vzeroupper
|
|
; X86-NEXT: retl
|
|
%res = call <8 x half> @llvm.x86.avx512fp16.mask.vcvtps2phx.256(<8 x float> %a, <8 x half> %b, i8 %mask)
|
|
ret <8 x half> %res
|
|
}
|
|
|
|
define <8 x half> @f32to8f16_mask2(<8 x float> %b, <8 x i1> %mask) {
|
|
; CHECK-LABEL: f32to8f16_mask2:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vpsllw $15, %xmm1, %xmm1
|
|
; CHECK-NEXT: vpmovw2m %xmm1, %k1
|
|
; CHECK-NEXT: vcvtps2phx %ymm0, %xmm0 {%k1} {z}
|
|
; CHECK-NEXT: vzeroupper
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <8 x float> %b to <8 x half>
|
|
%c = select <8 x i1>%mask, <8 x half>%a, <8 x half> zeroinitializer
|
|
ret <8 x half> %c
|
|
}
|
|
|
|
define <16 x half> @f32to16f16_mask(<16 x float> %b, <16 x i1> %mask) {
|
|
; CHECK-LABEL: f32to16f16_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vpsllw $7, %xmm1, %xmm1
|
|
; CHECK-NEXT: vpmovb2m %xmm1, %k1
|
|
; CHECK-NEXT: vcvtps2phx %zmm0, %ymm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <16 x float> %b to <16 x half>
|
|
%c = select <16 x i1>%mask, <16 x half>%a, <16 x half> zeroinitializer
|
|
ret <16 x half> %c
|
|
}
|
|
|
|
define float @f16tof32(half %b) nounwind {
|
|
; X64-LABEL: f16tof32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsh2ss %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f16tof32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %eax
|
|
; X86-NEXT: vmovsh {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vcvtsh2ss %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: vmovss %xmm0, (%esp)
|
|
; X86-NEXT: flds (%esp)
|
|
; X86-NEXT: popl %eax
|
|
; X86-NEXT: retl
|
|
%a = fpext half %b to float
|
|
ret float %a
|
|
}
|
|
|
|
define double @f16tof64(half %b) nounwind {
|
|
; X64-LABEL: f16tof64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsh2sd %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f16tof64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $8, %esp
|
|
; X86-NEXT: vmovsh 8(%ebp), %xmm0
|
|
; X86-NEXT: vcvtsh2sd %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: vmovsd %xmm0, (%esp)
|
|
; X86-NEXT: fldl (%esp)
|
|
; X86-NEXT: movl %ebp, %esp
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: retl
|
|
%a = fpext half %b to double
|
|
ret double %a
|
|
}
|
|
|
|
define <16 x float> @f16to16f32(<16 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to16f32:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2psx %ymm0, %zmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <16 x half> %b to <16 x float>
|
|
ret <16 x float> %a
|
|
}
|
|
|
|
define <8 x float> @f16to8f32(<8 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to8f32:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %ymm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <8 x half> %b to <8 x float>
|
|
ret <8 x float> %a
|
|
}
|
|
|
|
define <4 x float> @f16to4f32(<4 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to4f32:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <4 x half> %b to <4 x float>
|
|
ret <4 x float> %a
|
|
}
|
|
|
|
define <2 x float> @f16to2f32(<2 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to2f32:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <2 x half> %b to <2 x float>
|
|
ret <2 x float> %a
|
|
}
|
|
|
|
define <16 x float> @f16to16f32_mask(<16 x half> %b, <16 x float> %b1, <16 x float> %a1) {
|
|
; CHECK-LABEL: f16to16f32_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltps %zmm2, %zmm1, %k1
|
|
; CHECK-NEXT: vcvtph2psx %ymm0, %zmm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <16 x half> %b to <16 x float>
|
|
%mask = fcmp ogt <16 x float> %a1, %b1
|
|
%c = select <16 x i1> %mask, <16 x float> %a, <16 x float> zeroinitializer
|
|
ret <16 x float> %c
|
|
}
|
|
|
|
define <8 x float> @f16to8f32_mask(<8 x half> %b, <8 x float> %b1, <8 x float> %a1) {
|
|
; CHECK-LABEL: f16to8f32_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltps %ymm2, %ymm1, %k1
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %ymm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <8 x half> %b to <8 x float>
|
|
%mask = fcmp ogt <8 x float> %a1, %b1
|
|
%c = select <8 x i1> %mask, <8 x float> %a, <8 x float> zeroinitializer
|
|
ret <8 x float> %c
|
|
}
|
|
|
|
define <4 x float> @f16to4f32_mask(<4 x half> %b, <4 x float> %b1, <4 x float> %a1) {
|
|
; CHECK-LABEL: f16to4f32_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltps %xmm2, %xmm1, %k1
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %xmm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <4 x half> %b to <4 x float>
|
|
%mask = fcmp ogt <4 x float> %a1, %b1
|
|
%c = select <4 x i1> %mask, <4 x float> %a, <4 x float> zeroinitializer
|
|
ret <4 x float> %c
|
|
}
|
|
|
|
define <2 x float> @f16to2f32_mask(<2 x half> %b, <2 x float> %b1, <2 x float> %a1) {
|
|
; CHECK-LABEL: f16to2f32_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltps %xmm2, %xmm1, %k1
|
|
; CHECK-NEXT: vcvtph2psx %xmm0, %xmm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <2 x half> %b to <2 x float>
|
|
%mask = fcmp ogt <2 x float> %a1, %b1
|
|
%c = select <2 x i1> %mask, <2 x float> %a, <2 x float> zeroinitializer
|
|
ret <2 x float> %c
|
|
}
|
|
|
|
define <2 x double> @f16to2f64(<2 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to2f64:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <2 x half> %b to <2 x double>
|
|
ret <2 x double> %a
|
|
}
|
|
|
|
define <2 x double> @f16to2f64_mask(<2 x half> %b, <2 x double> %b1, <2 x double> %a1) {
|
|
; CHECK-LABEL: f16to2f64_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltpd %xmm2, %xmm1, %k1
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %xmm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <2 x half> %b to <2 x double>
|
|
%mask = fcmp ogt <2 x double> %a1, %b1
|
|
%c = select <2 x i1> %mask, <2 x double> %a, <2 x double> zeroinitializer
|
|
ret <2 x double> %c
|
|
}
|
|
|
|
define <4 x double> @f16to4f64(<4 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to4f64:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %ymm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <4 x half> %b to <4 x double>
|
|
ret <4 x double> %a
|
|
}
|
|
|
|
define <4 x double> @f16to4f64_mask(<4 x half> %b, <4 x double> %b1, <4 x double> %a1) {
|
|
; CHECK-LABEL: f16to4f64_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltpd %ymm2, %ymm1, %k1
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %ymm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <4 x half> %b to <4 x double>
|
|
%mask = fcmp ogt <4 x double> %a1, %b1
|
|
%c = select <4 x i1> %mask, <4 x double> %a, <4 x double> zeroinitializer
|
|
ret <4 x double> %c
|
|
}
|
|
|
|
define <8 x double> @f16to8f64(<8 x half> %b) nounwind {
|
|
; CHECK-LABEL: f16to8f64:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %zmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <8 x half> %b to <8 x double>
|
|
ret <8 x double> %a
|
|
}
|
|
|
|
define <8 x double> @f16to8f64_mask(<8 x half> %b, <8 x double> %b1, <8 x double> %a1) {
|
|
; CHECK-LABEL: f16to8f64_mask:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcmpltpd %zmm2, %zmm1, %k1
|
|
; CHECK-NEXT: vcvtph2pd %xmm0, %zmm0 {%k1} {z}
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fpext <8 x half> %b to <8 x double>
|
|
%mask = fcmp ogt <8 x double> %a1, %b1
|
|
%c = select <8 x i1> %mask, <8 x double> %a, <8 x double> zeroinitializer
|
|
ret <8 x double> %c
|
|
}
|
|
|
|
define <2 x half> @f64to2f16(<2 x double> %b) {
|
|
; CHECK-LABEL: f64to2f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtpd2ph %xmm0, %xmm0
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <2 x double> %b to <2 x half>
|
|
ret <2 x half> %a
|
|
}
|
|
|
|
define <4 x half> @f64to4f16(<4 x double> %b) {
|
|
; CHECK-LABEL: f64to4f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtpd2ph %ymm0, %xmm0
|
|
; CHECK-NEXT: vzeroupper
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <4 x double> %b to <4 x half>
|
|
ret <4 x half> %a
|
|
}
|
|
|
|
define <8 x half> @f64to8f16(<8 x double> %b) {
|
|
; CHECK-LABEL: f64to8f16:
|
|
; CHECK: # %bb.0:
|
|
; CHECK-NEXT: vcvtpd2ph %zmm0, %xmm0
|
|
; CHECK-NEXT: vzeroupper
|
|
; CHECK-NEXT: ret{{[l|q]}}
|
|
%a = fptrunc <8 x double> %b to <8 x half>
|
|
ret <8 x half> %a
|
|
}
|
|
|
|
define float @extload_f16_f32(half* %x) {
|
|
; X64-LABEL: extload_f16_f32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vmovsh (%rdi), %xmm0
|
|
; X64-NEXT: vcvtsh2ss %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_f16_f32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %eax
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vmovsh (%eax), %xmm0
|
|
; X86-NEXT: vcvtsh2ss %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: vmovss %xmm0, (%esp)
|
|
; X86-NEXT: flds (%esp)
|
|
; X86-NEXT: popl %eax
|
|
; X86-NEXT: .cfi_def_cfa_offset 4
|
|
; X86-NEXT: retl
|
|
%a = load half, half* %x
|
|
%b = fpext half %a to float
|
|
ret float %b
|
|
}
|
|
|
|
define double @extload_f16_f64(half* %x) {
|
|
; X64-LABEL: extload_f16_f64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vmovsh (%rdi), %xmm0
|
|
; X64-NEXT: vcvtsh2sd %xmm0, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_f16_f64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: .cfi_offset %ebp, -8
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: .cfi_def_cfa_register %ebp
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $8, %esp
|
|
; X86-NEXT: movl 8(%ebp), %eax
|
|
; X86-NEXT: vmovsh (%eax), %xmm0
|
|
; X86-NEXT: vcvtsh2sd %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: vmovsd %xmm0, (%esp)
|
|
; X86-NEXT: fldl (%esp)
|
|
; X86-NEXT: movl %ebp, %esp
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: .cfi_def_cfa %esp, 4
|
|
; X86-NEXT: retl
|
|
%a = load half, half* %x
|
|
%b = fpext half %a to double
|
|
ret double %b
|
|
}
|
|
|
|
define float @extload_f16_f32_optsize(half* %x) optsize {
|
|
; X64-LABEL: extload_f16_f32_optsize:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsh2ss (%rdi), %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_f16_f32_optsize:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %eax
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtsh2ss (%eax), %xmm0, %xmm0
|
|
; X86-NEXT: vmovss %xmm0, (%esp)
|
|
; X86-NEXT: flds (%esp)
|
|
; X86-NEXT: popl %eax
|
|
; X86-NEXT: .cfi_def_cfa_offset 4
|
|
; X86-NEXT: retl
|
|
%a = load half, half* %x
|
|
%b = fpext half %a to float
|
|
ret float %b
|
|
}
|
|
|
|
define double @extload_f16_f64_optsize(half* %x) optsize {
|
|
; X64-LABEL: extload_f16_f64_optsize:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsh2sd (%rdi), %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_f16_f64_optsize:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: .cfi_offset %ebp, -8
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: .cfi_def_cfa_register %ebp
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $8, %esp
|
|
; X86-NEXT: movl 8(%ebp), %eax
|
|
; X86-NEXT: vcvtsh2sd (%eax), %xmm0, %xmm0
|
|
; X86-NEXT: vmovsd %xmm0, (%esp)
|
|
; X86-NEXT: fldl (%esp)
|
|
; X86-NEXT: movl %ebp, %esp
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: .cfi_def_cfa %esp, 4
|
|
; X86-NEXT: retl
|
|
%a = load half, half* %x
|
|
%b = fpext half %a to double
|
|
ret double %b
|
|
}
|
|
|
|
define <16 x float> @extload_v16f16_v16f32(<16 x half>* %x) {
|
|
; X64-LABEL: extload_v16f16_v16f32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2psx (%rdi), %zmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v16f16_v16f32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2psx (%eax), %zmm0
|
|
; X86-NEXT: retl
|
|
%a = load <16 x half>, <16 x half>* %x
|
|
%b = fpext <16 x half> %a to <16 x float>
|
|
ret <16 x float> %b
|
|
}
|
|
|
|
define <8 x float> @extload_v8f16_v8f32(<8 x half>* %x) {
|
|
; X64-LABEL: extload_v8f16_v8f32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2psx (%rdi), %ymm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v8f16_v8f32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2psx (%eax), %ymm0
|
|
; X86-NEXT: retl
|
|
%a = load <8 x half>, <8 x half>* %x
|
|
%b = fpext <8 x half> %a to <8 x float>
|
|
ret <8 x float> %b
|
|
}
|
|
|
|
define <4 x float> @extload_v4f16_v4f32(<4 x half>* %x) {
|
|
; X64-LABEL: extload_v4f16_v4f32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2psx (%rdi), %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v4f16_v4f32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2psx (%eax), %xmm0
|
|
; X86-NEXT: retl
|
|
%a = load <4 x half>, <4 x half>* %x
|
|
%b = fpext <4 x half> %a to <4 x float>
|
|
ret <4 x float> %b
|
|
}
|
|
|
|
define <8 x double> @extload_v8f16_v8f64(<8 x half>* %x) {
|
|
; X64-LABEL: extload_v8f16_v8f64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2pd (%rdi), %zmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v8f16_v8f64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2pd (%eax), %zmm0
|
|
; X86-NEXT: retl
|
|
%a = load <8 x half>, <8 x half>* %x
|
|
%b = fpext <8 x half> %a to <8 x double>
|
|
ret <8 x double> %b
|
|
}
|
|
|
|
define <4 x double> @extload_v4f16_v4f64(<4 x half>* %x) {
|
|
; X64-LABEL: extload_v4f16_v4f64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2pd (%rdi), %ymm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v4f16_v4f64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2pd (%eax), %ymm0
|
|
; X86-NEXT: retl
|
|
%a = load <4 x half>, <4 x half>* %x
|
|
%b = fpext <4 x half> %a to <4 x double>
|
|
ret <4 x double> %b
|
|
}
|
|
|
|
define <2 x double> @extload_v2f16_v2f64(<2 x half>* %x) {
|
|
; X64-LABEL: extload_v2f16_v2f64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtph2pd (%rdi), %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: extload_v2f16_v2f64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtph2pd (%eax), %xmm0
|
|
; X86-NEXT: retl
|
|
%a = load <2 x half>, <2 x half>* %x
|
|
%b = fpext <2 x half> %a to <2 x double>
|
|
ret <2 x double> %b
|
|
}
|
|
|
|
define half @s8_to_half(i8 %x) {
|
|
; X64-LABEL: s8_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: movsbl %dil, %eax
|
|
; X64-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: s8_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movsbl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = sitofp i8 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @s16_to_half(i16 %x) {
|
|
; X64-LABEL: s16_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: movswl %di, %eax
|
|
; X64-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: s16_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movswl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = sitofp i16 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @s32_to_half(i32 %x) {
|
|
; X64-LABEL: s32_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsi2sh %edi, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: s32_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvtsi2shl {{[0-9]+}}(%esp), %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = sitofp i32 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @s64_to_half(i64 %x) {
|
|
; X64-LABEL: s64_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtsi2sh %rdi, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: s64_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; X86-NEXT: vcvtqq2ph %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = sitofp i64 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @s128_to_half(i128 %x) {
|
|
; X64-LABEL: s128_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 16
|
|
; X64-NEXT: callq __floattihf@PLT
|
|
; X64-NEXT: popq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 8
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: s128_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: subl $16, %esp
|
|
; X86-NEXT: .cfi_def_cfa_offset 20
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovups %xmm0, (%esp)
|
|
; X86-NEXT: calll __floattihf
|
|
; X86-NEXT: addl $16, %esp
|
|
; X86-NEXT: .cfi_def_cfa_offset 4
|
|
; X86-NEXT: retl
|
|
%a = sitofp i128 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @u8_to_half(i8 %x) {
|
|
; X64-LABEL: u8_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: movzbl %dil, %eax
|
|
; X64-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: u8_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movzbl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = uitofp i8 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @u16_to_half(i16 %x) {
|
|
; X64-LABEL: u16_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: movzwl %di, %eax
|
|
; X64-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: u16_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: vcvtsi2sh %eax, %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = uitofp i16 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @u32_to_half(i32 %x) {
|
|
; X64-LABEL: u32_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtusi2sh %edi, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: u32_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvtusi2shl {{[0-9]+}}(%esp), %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = uitofp i32 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @u64_to_half(i64 %x) {
|
|
; X64-LABEL: u64_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvtusi2sh %rdi, %xmm0, %xmm0
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: u64_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; X86-NEXT: vcvtuqq2ph %xmm0, %xmm0
|
|
; X86-NEXT: retl
|
|
%a = uitofp i64 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define half @u128_to_half(i128 %x) {
|
|
; X64-LABEL: u128_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 16
|
|
; X64-NEXT: callq __floatuntihf@PLT
|
|
; X64-NEXT: popq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 8
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: u128_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: subl $16, %esp
|
|
; X86-NEXT: .cfi_def_cfa_offset 20
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovups %xmm0, (%esp)
|
|
; X86-NEXT: calll __floatuntihf
|
|
; X86-NEXT: addl $16, %esp
|
|
; X86-NEXT: .cfi_def_cfa_offset 4
|
|
; X86-NEXT: retl
|
|
%a = uitofp i128 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
define i8 @half_to_s8(half %x) {
|
|
; X64-LABEL: half_to_s8:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %eax
|
|
; X64-NEXT: # kill: def $al killed $al killed $eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_s8:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2si {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: # kill: def $al killed $al killed $eax
|
|
; X86-NEXT: retl
|
|
%a = fptosi half %x to i8
|
|
ret i8 %a
|
|
}
|
|
|
|
define i16 @half_to_s16(half %x) {
|
|
; X64-LABEL: half_to_s16:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %eax
|
|
; X64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_s16:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2si {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X86-NEXT: retl
|
|
%a = fptosi half %x to i16
|
|
ret i16 %a
|
|
}
|
|
|
|
define i32 @half_to_s32(half %x) {
|
|
; X64-LABEL: half_to_s32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_s32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2si {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: retl
|
|
%a = fptosi half %x to i32
|
|
ret i32 %a
|
|
}
|
|
|
|
define i64 @half_to_s64(half %x) {
|
|
; X64-LABEL: half_to_s64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %rax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_s64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovsh {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vcvttph2qq %xmm0, %xmm0
|
|
; X86-NEXT: vmovd %xmm0, %eax
|
|
; X86-NEXT: vpextrd $1, %xmm0, %edx
|
|
; X86-NEXT: retl
|
|
%a = fptosi half %x to i64
|
|
ret i64 %a
|
|
}
|
|
|
|
define i128 @half_to_s128(half %x) {
|
|
; X64-LABEL: half_to_s128:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 16
|
|
; X64-NEXT: callq __fixhfti@PLT
|
|
; X64-NEXT: popq %rcx
|
|
; X64-NEXT: .cfi_def_cfa_offset 8
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_s128:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: .cfi_offset %ebp, -8
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: .cfi_def_cfa_register %ebp
|
|
; X86-NEXT: pushl %esi
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $32, %esp
|
|
; X86-NEXT: .cfi_offset %esi, -12
|
|
; X86-NEXT: movl 8(%ebp), %esi
|
|
; X86-NEXT: vmovsh 12(%ebp), %xmm0
|
|
; X86-NEXT: vmovsh %xmm0, {{[0-9]+}}(%esp)
|
|
; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: movl %eax, (%esp)
|
|
; X86-NEXT: calll __fixhfti
|
|
; X86-NEXT: subl $4, %esp
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovups %xmm0, (%esi)
|
|
; X86-NEXT: movl %esi, %eax
|
|
; X86-NEXT: leal -4(%ebp), %esp
|
|
; X86-NEXT: popl %esi
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: .cfi_def_cfa %esp, 4
|
|
; X86-NEXT: retl $4
|
|
%a = fptosi half %x to i128
|
|
ret i128 %a
|
|
}
|
|
|
|
define i8 @half_to_u8(half %x) {
|
|
; X64-LABEL: half_to_u8:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %eax
|
|
; X64-NEXT: # kill: def $al killed $al killed $eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_u8:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2si {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: # kill: def $al killed $al killed $eax
|
|
; X86-NEXT: retl
|
|
%a = fptoui half %x to i8
|
|
ret i8 %a
|
|
}
|
|
|
|
define i16 @half_to_u16(half %x) {
|
|
; X64-LABEL: half_to_u16:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2si %xmm0, %eax
|
|
; X64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_u16:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2si {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X86-NEXT: retl
|
|
%a = fptoui half %x to i16
|
|
ret i16 %a
|
|
}
|
|
|
|
define i32 @half_to_u32(half %x) {
|
|
; X64-LABEL: half_to_u32:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2usi %xmm0, %eax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_u32:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vcvttsh2usi {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: retl
|
|
%a = fptoui half %x to i32
|
|
ret i32 %a
|
|
}
|
|
|
|
define i64 @half_to_u64(half %x) {
|
|
; X64-LABEL: half_to_u64:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: vcvttsh2usi %xmm0, %rax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_u64:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: vmovsh {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vcvttph2uqq %xmm0, %xmm0
|
|
; X86-NEXT: vmovd %xmm0, %eax
|
|
; X86-NEXT: vpextrd $1, %xmm0, %edx
|
|
; X86-NEXT: retl
|
|
%a = fptoui half %x to i64
|
|
ret i64 %a
|
|
}
|
|
|
|
define i128 @half_to_u128(half %x) {
|
|
; X64-LABEL: half_to_u128:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: .cfi_def_cfa_offset 16
|
|
; X64-NEXT: callq __fixunshfti@PLT
|
|
; X64-NEXT: popq %rcx
|
|
; X64-NEXT: .cfi_def_cfa_offset 8
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_u128:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: .cfi_def_cfa_offset 8
|
|
; X86-NEXT: .cfi_offset %ebp, -8
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: .cfi_def_cfa_register %ebp
|
|
; X86-NEXT: pushl %esi
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $32, %esp
|
|
; X86-NEXT: .cfi_offset %esi, -12
|
|
; X86-NEXT: movl 8(%ebp), %esi
|
|
; X86-NEXT: vmovsh 12(%ebp), %xmm0
|
|
; X86-NEXT: vmovsh %xmm0, {{[0-9]+}}(%esp)
|
|
; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: movl %eax, (%esp)
|
|
; X86-NEXT: calll __fixunshfti
|
|
; X86-NEXT: subl $4, %esp
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovups %xmm0, (%esi)
|
|
; X86-NEXT: movl %esi, %eax
|
|
; X86-NEXT: leal -4(%ebp), %esp
|
|
; X86-NEXT: popl %esi
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: .cfi_def_cfa %esp, 4
|
|
; X86-NEXT: retl $4
|
|
%a = fptoui half %x to i128
|
|
ret i128 %a
|
|
}
|
|
|
|
define x86_fp80 @half_to_f80(half %x) nounwind {
|
|
; X64-LABEL: half_to_f80:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: callq __extendhfxf2@PLT
|
|
; X64-NEXT: popq %rax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: half_to_f80:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %eax
|
|
; X86-NEXT: vmovsh {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovsh %xmm0, (%esp)
|
|
; X86-NEXT: calll __extendhfxf2
|
|
; X86-NEXT: popl %eax
|
|
; X86-NEXT: retl
|
|
%a = fpext half %x to x86_fp80
|
|
ret x86_fp80 %a
|
|
}
|
|
|
|
define half @f80_to_half(x86_fp80 %x) nounwind {
|
|
; X64-LABEL: f80_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: subq $24, %rsp
|
|
; X64-NEXT: fldt {{[0-9]+}}(%rsp)
|
|
; X64-NEXT: fstpt (%rsp)
|
|
; X64-NEXT: callq __truncxfhf2@PLT
|
|
; X64-NEXT: addq $24, %rsp
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f80_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: subl $12, %esp
|
|
; X86-NEXT: fldt {{[0-9]+}}(%esp)
|
|
; X86-NEXT: fstpt (%esp)
|
|
; X86-NEXT: calll __truncxfhf2
|
|
; X86-NEXT: addl $12, %esp
|
|
; X86-NEXT: retl
|
|
%a = fptrunc x86_fp80 %x to half
|
|
ret half %a
|
|
}
|
|
|
|
; FIXME: We're doing a two step conversion here on 32-bit.
|
|
; First from f16->f32 then f32->f128. This is occuring
|
|
; due to common code in LegalizeFloatTypes that thinks
|
|
; there are no libcalls for f16 to any type but f32.
|
|
; Changing this may break other non-x86 targets. The code
|
|
; generated here should be functional.
|
|
define fp128 @half_to_f128(half %x) nounwind {
|
|
; X64-LABEL: half_to_f128:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: jmp __extendhftf2@PLT # TAILCALL
|
|
;
|
|
; X86-LABEL: half_to_f128:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: pushl %ebp
|
|
; X86-NEXT: movl %esp, %ebp
|
|
; X86-NEXT: pushl %esi
|
|
; X86-NEXT: andl $-8, %esp
|
|
; X86-NEXT: subl $32, %esp
|
|
; X86-NEXT: movl 8(%ebp), %esi
|
|
; X86-NEXT: vmovsh 12(%ebp), %xmm0
|
|
; X86-NEXT: vcvtsh2ss %xmm0, %xmm0, %xmm0
|
|
; X86-NEXT: vmovss %xmm0, {{[0-9]+}}(%esp)
|
|
; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
|
|
; X86-NEXT: movl %eax, (%esp)
|
|
; X86-NEXT: calll __extendsftf2
|
|
; X86-NEXT: subl $4, %esp
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovaps %xmm0, (%esi)
|
|
; X86-NEXT: movl %esi, %eax
|
|
; X86-NEXT: leal -4(%ebp), %esp
|
|
; X86-NEXT: popl %esi
|
|
; X86-NEXT: popl %ebp
|
|
; X86-NEXT: retl $4
|
|
%a = fpext half %x to fp128
|
|
ret fp128 %a
|
|
}
|
|
|
|
define half @f128_to_half(fp128 %x) nounwind {
|
|
; X64-LABEL: f128_to_half:
|
|
; X64: # %bb.0:
|
|
; X64-NEXT: pushq %rax
|
|
; X64-NEXT: callq __trunctfhf2@PLT
|
|
; X64-NEXT: popq %rax
|
|
; X64-NEXT: retq
|
|
;
|
|
; X86-LABEL: f128_to_half:
|
|
; X86: # %bb.0:
|
|
; X86-NEXT: subl $16, %esp
|
|
; X86-NEXT: vmovups {{[0-9]+}}(%esp), %xmm0
|
|
; X86-NEXT: vmovups %xmm0, (%esp)
|
|
; X86-NEXT: calll __trunctfhf2
|
|
; X86-NEXT: addl $16, %esp
|
|
; X86-NEXT: retl
|
|
%a = fptrunc fp128 %x to half
|
|
ret half %a
|
|
}
|