Page MenuHomePhabricator
Differential D67925 Diff 223241 llvm/trunk/test/CodeGen/X86/fp-intrinsics.ll

Changeset View

Standalone View

View Options

llvm/trunk/test/CodeGen/X86/fp-intrinsics.ll

; RUN: llc -O3 -mtriple=x86_64-pc-linux < %s | FileCheck --check-prefix=COMMON --check-prefix=NO-FMA --check-prefix=FMACALL64 --check-prefix=FMACALL32 %s ; RUN: llc -O3 -mtriple=x86_64-pc-linux < %s | FileCheck --check-prefix=COMMON --check-prefix=NO-FMA --check-prefix=FMACALL64 --check-prefix=FMACALL32 %s
; RUN: llc -O3 -mtriple=x86_64-pc-linux -mattr=+fma < %s | FileCheck -check-prefix=COMMON --check-prefix=HAS-FMA --check-prefix=FMA64 --check-prefix=FMA32 %s ; RUN: llc -O3 -mtriple=x86_64-pc-linux -mattr=+fma < %s | FileCheck -check-prefix=COMMON --check-prefix=HAS-FMA --check-prefix=FMA64 --check-prefix=FMA32 %s
; Verify that constants aren't folded to inexact results when the rounding mode ; Verify that constants aren't folded to inexact results when the rounding mode
; is unknown. ; is unknown.
; ;
; double f1() { ; double f1() {
; // Because 0.1 cannot be represented exactly, this shouldn't be folded. ; // Because 0.1 cannot be represented exactly, this shouldn't be folded.
; return 1.0/10.0; ; return 1.0/10.0;
; } ; }
; ;
; CHECK-LABEL: f1 ; CHECK-LABEL: f1
; COMMON: divsd ; COMMON: divsd
define double @f1() { define double @f1() #0 {
entry: entry:
%div = call double @llvm.experimental.constrained.fdiv.f64( %div = call double @llvm.experimental.constrained.fdiv.f64(
double 1.000000e+00, double 1.000000e+00,
double 1.000000e+01, double 1.000000e+01,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %div ret double %div
} }
; Verify that 'a - 0' isn't simplified to 'a' when the rounding mode is unknown. ; Verify that 'a - 0' isn't simplified to 'a' when the rounding mode is unknown.
; ;
; double f2(double a) { ; double f2(double a) {
; // Because the result of '0 - 0' is negative zero if rounding mode is ; // Because the result of '0 - 0' is negative zero if rounding mode is
; // downward, this shouldn't be simplified. ; // downward, this shouldn't be simplified.
; return a - 0; ; return a - 0;
; } ; }
; ;
; CHECK-LABEL: f2 ; CHECK-LABEL: f2
; COMMON: subsd ; COMMON: subsd
define double @f2(double %a) { define double @f2(double %a) #0 {
entry: entry:
%sub = call double @llvm.experimental.constrained.fsub.f64( %sub = call double @llvm.experimental.constrained.fsub.f64(
double %a, double %a,
double 0.000000e+00, double 0.000000e+00,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %sub ret double %sub
} }
; Verify that '-((-a)*b)' isn't simplified to 'a*b' when the rounding mode is ; Verify that '-((-a)*b)' isn't simplified to 'a*b' when the rounding mode is
; unknown. ; unknown.
; ;
; double f3(double a, double b) { ; double f3(double a, double b) {
; // Because the intermediate value involved in this calculation may require ; // Because the intermediate value involved in this calculation may require
; // rounding, this shouldn't be simplified. ; // rounding, this shouldn't be simplified.
; return -((-a)*b); ; return -((-a)*b);
; } ; }
; ;
; CHECK-LABEL: f3: ; CHECK-LABEL: f3:
; COMMON: subsd ; COMMON: subsd
; COMMON: mulsd ; COMMON: mulsd
; COMMON: subsd ; COMMON: subsd
define double @f3(double %a, double %b) { define double @f3(double %a, double %b) #0 {
entry: entry:
%sub = call double @llvm.experimental.constrained.fsub.f64( %sub = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00, double %a, double -0.000000e+00, double %a,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
%mul = call double @llvm.experimental.constrained.fmul.f64( %mul = call double @llvm.experimental.constrained.fmul.f64(
double %sub, double %b, double %sub, double %b,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
%ret = call double @llvm.experimental.constrained.fsub.f64( %ret = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00, double -0.000000e+00,
double %mul, double %mul,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %ret ret double %ret
} }
; Verify that FP operations are not performed speculatively when FP exceptions ; Verify that FP operations are not performed speculatively when FP exceptions
; are not being ignored. ; are not being ignored.
; ;
; double f4(int n, double a) { ; double f4(int n, double a) {
; // Because a + 1 may overflow, this should not be simplified. ; // Because a + 1 may overflow, this should not be simplified.
; if (n > 0) ; if (n > 0)
; return a + 1.0; ; return a + 1.0;
; return a; ; return a;
; } ; }
; ;
; ;
; CHECK-LABEL: f4: ; CHECK-LABEL: f4:
; COMMON: testl ; COMMON: testl
; COMMON: jle ; COMMON: jle
; COMMON: addsd ; COMMON: addsd
define double @f4(i32 %n, double %a) { define double @f4(i32 %n, double %a) #0 {
entry: entry:
%cmp = icmp sgt i32 %n, 0 %cmp = icmp sgt i32 %n, 0
br i1 %cmp, label %if.then, label %if.end br i1 %cmp, label %if.then, label %if.end
if.then: if.then:
%add = call double @llvm.experimental.constrained.fadd.f64( %add = call double @llvm.experimental.constrained.fadd.f64(
double 1.000000e+00, double %a, double 1.000000e+00, double %a,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
br label %if.end br label %if.end
if.end: if.end:
%a.0 = phi double [%add, %if.then], [ %a, %entry ] %a.0 = phi double [%add, %if.then], [ %a, %entry ]
ret double %a.0 ret double %a.0
} }
; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown. ; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f5 ; CHECK-LABEL: f5
; COMMON: sqrtsd ; COMMON: sqrtsd
define double @f5() { define double @f5() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0, %result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown. ; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f6 ; CHECK-LABEL: f6
; COMMON: pow ; COMMON: pow
define double @f6() { define double @f6() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.pow.f64(double 42.1, %result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
double 3.0, double 3.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown. ; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f7 ; CHECK-LABEL: f7
; COMMON: powi ; COMMON: powi
define double @f7() { define double @f7() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.powi.f64(double 42.1, %result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
i32 3, i32 3,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that sin(42.0) isn't simplified when the rounding mode is unknown. ; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f8 ; CHECK-LABEL: f8
; COMMON: sin ; COMMON: sin
define double @f8() { define double @f8() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.sin.f64(double 42.0, %result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that cos(42.0) isn't simplified when the rounding mode is unknown. ; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f9 ; CHECK-LABEL: f9
; COMMON: cos ; COMMON: cos
define double @f9() { define double @f9() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.cos.f64(double 42.0, %result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that exp(42.0) isn't simplified when the rounding mode is unknown. ; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f10 ; CHECK-LABEL: f10
; COMMON: exp ; COMMON: exp
define double @f10() { define double @f10() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.exp.f64(double 42.0, %result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown. ; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f11 ; CHECK-LABEL: f11
; COMMON: exp2 ; COMMON: exp2
define double @f11() { define double @f11() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.exp2.f64(double 42.1, %result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that log(42.0) isn't simplified when the rounding mode is unknown. ; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f12 ; CHECK-LABEL: f12
; COMMON: log ; COMMON: log
define double @f12() { define double @f12() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.log.f64(double 42.0, %result = call double @llvm.experimental.constrained.log.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that log10(42.0) isn't simplified when the rounding mode is unknown. ; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f13 ; CHECK-LABEL: f13
; COMMON: log10 ; COMMON: log10
define double @f13() { define double @f13() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.log10.f64(double 42.0, %result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that log2(42.0) isn't simplified when the rounding mode is unknown. ; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f14 ; CHECK-LABEL: f14
; COMMON: log2 ; COMMON: log2
define double @f14() { define double @f14() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.log2.f64(double 42.0, %result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that rint(42.1) isn't simplified when the rounding mode is unknown. ; Verify that rint(42.1) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f15 ; CHECK-LABEL: f15
; NO-FMA: rint ; NO-FMA: rint
; HAS-FMA: vroundsd ; HAS-FMA: vroundsd
define double @f15() { define double @f15() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.rint.f64(double 42.1, %result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that nearbyint(42.1) isn't simplified when the rounding mode is ; Verify that nearbyint(42.1) isn't simplified when the rounding mode is
; unknown. ; unknown.
; CHECK-LABEL: f16 ; CHECK-LABEL: f16
; NO-FMA: nearbyint ; NO-FMA: nearbyint
; HAS-FMA: vroundsd ; HAS-FMA: vroundsd
define double @f16() { define double @f16() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.nearbyint.f64( %result = call double @llvm.experimental.constrained.nearbyint.f64(
double 42.1, double 42.1,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; Verify that fma(3.5) isn't simplified when the rounding mode is ; Verify that fma(3.5) isn't simplified when the rounding mode is
; unknown. ; unknown.
; CHECK-LABEL: f17 ; CHECK-LABEL: f17
; FMACALL32: jmp fmaf # TAILCALL ; FMACALL32: jmp fmaf # TAILCALL
; FMA32: vfmadd213ss ; FMA32: vfmadd213ss
define float @f17() { define float @f17() #0 {
entry: entry:
%result = call float @llvm.experimental.constrained.fma.f32( %result = call float @llvm.experimental.constrained.fma.f32(
float 3.5, float 3.5,
float 3.5, float 3.5,
float 3.5, float 3.5,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret float %result ret float %result
} }
; Verify that fma(42.1) isn't simplified when the rounding mode is ; Verify that fma(42.1) isn't simplified when the rounding mode is
; unknown. ; unknown.
; CHECK-LABEL: f18 ; CHECK-LABEL: f18
; FMACALL64: jmp fma # TAILCALL ; FMACALL64: jmp fma # TAILCALL
; FMA64: vfmadd213sd ; FMA64: vfmadd213sd
define double @f18() { define double @f18() #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.fma.f64( %result = call double @llvm.experimental.constrained.fma.f64(
double 42.1, double 42.1,
double 42.1, double 42.1,
double 42.1, double 42.1,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
; CHECK-LABEL: f19 ; CHECK-LABEL: f19
; COMMON: fmod ; COMMON: fmod
define double @f19() { define double @f19() #0 {
entry: entry:
%rem = call double @llvm.experimental.constrained.frem.f64( %rem = call double @llvm.experimental.constrained.frem.f64(
double 1.000000e+00, double 1.000000e+00,
double 1.000000e+01, double 1.000000e+01,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %rem ret double %rem
} }
; Verify that fptoui(%x) isn't simplified when the rounding mode is ; Verify that fptoui(%x) isn't simplified when the rounding mode is
; unknown. The expansion should have only one conversion instruction. ; unknown. The expansion should have only one conversion instruction.
; Verify that no gross errors happen. ; Verify that no gross errors happen.
; CHECK-LABEL: @f20u ; CHECK-LABEL: @f20u
; NO-FMA: cmpltsd ; NO-FMA: cmpltsd
Show All 13 Lines
; HAS-FMA: vsubsd ; HAS-FMA: vsubsd
; HAS-FMA: vblendvpd ; HAS-FMA: vblendvpd
; HAS-FMA: vcvttsd2si ; HAS-FMA: vcvttsd2si
; HAS-FMA: xorl ; HAS-FMA: xorl
; HAS-FMA: vucomisd ; HAS-FMA: vucomisd
; HAS-FMA: setae ; HAS-FMA: setae
; HAS-FMA: shll ; HAS-FMA: shll
; HAS-FMA: xorl ; HAS-FMA: xorl
define i32 @f20u(double %x) { define i32 @f20u(double %x) #0 {
entry: entry:
%result = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %x, %result = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %x,
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret i32 %result ret i32 %result
} }
; Verify that round(42.1) isn't simplified when the rounding mode is ; Verify that round(42.1) isn't simplified when the rounding mode is
; unknown. ; unknown.
; Verify that no gross errors happen. ; Verify that no gross errors happen.
; CHECK-LABEL: @f21 ; CHECK-LABEL: @f21
; COMMON: cvtsd2ss ; COMMON: cvtsd2ss
define float @f21() { define float @f21() #0 {
entry: entry:
%result = call float @llvm.experimental.constrained.fptrunc.f32.f64( %result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
double 42.1, double 42.1,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret float %result ret float %result
} }
; CHECK-LABEL: @f22 ; CHECK-LABEL: @f22
; COMMON: cvtss2sd ; COMMON: cvtss2sd
define double @f22(float %x) { define double @f22(float %x) #0 {
entry: entry:
%result = call double @llvm.experimental.constrained.fpext.f64.f32(float %x, %result = call double @llvm.experimental.constrained.fpext.f64.f32(float %x,
metadata !"fpexcept.strict") metadata !"fpexcept.strict") #0
ret double %result ret double %result
} }
attributes #0 = { strictfp }
@llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata" @llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
Show All 16 Lines