2019-09-11 21:56:07 +08:00
|
|
|
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
2019-09-11 22:01:11 +08:00
|
|
|
; RUN: opt -constprop -S < %s | FileCheck %s
|
2019-04-17 12:52:47 +08:00
|
|
|
|
|
|
|
|
; Fixes PR20832
|
|
|
|
|
; Make sure that we correctly fold a fused multiply-add where operands
|
|
|
|
|
; are all finite constants and addend is zero.
|
|
|
|
|
|
|
|
|
|
declare double @llvm.fma.f64(double, double, double)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
define double @PR20832() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @PR20832(
|
|
|
|
|
; CHECK-NEXT: ret double 5.600000e+01
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Test builtin fma with all finite non-zero constants.
|
|
|
|
|
define double @test_all_finite() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_all_finite(
|
|
|
|
|
; CHECK-NEXT: ret double 6.100000e+01
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 5.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Test builtin fma with a +/-NaN addend.
|
|
|
|
|
define double @test_NaN_addend() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_addend(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0x7FF8000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_NaN_addend_2() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_addend_2(
|
|
|
|
|
; CHECK-NEXT: ret double 0xFFF8000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0xFFF8000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Test builtin fma with a +/-Inf addend.
|
|
|
|
|
define double @test_Inf_addend() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_addend(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0x7FF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_Inf_addend_2() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_addend_2(
|
|
|
|
|
; CHECK-NEXT: ret double 0xFFF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0xFFF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Test builtin fma with one of the operands to the multiply being +/-NaN.
|
|
|
|
|
define double @test_NaN_1() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_1(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 0x7FF8000000000000, double 8.0, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_NaN_2() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_2(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0x7FF8000000000000, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_NaN_3() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_3(
|
2020-01-22 03:48:07 +08:00
|
|
|
; CHECK-NEXT: ret double 0xFFF8000000000000
|
2019-09-11 21:56:07 +08:00
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 0xFFF8000000000000, double 8.0, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_NaN_4() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_NaN_4(
|
2020-01-22 03:48:07 +08:00
|
|
|
; CHECK-NEXT: ret double 0xFFF8000000000000
|
2019-09-11 21:56:07 +08:00
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0xFFF8000000000000, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Test builtin fma with one of the operands to the multiply being +/-Inf.
|
|
|
|
|
define double @test_Inf_1() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_1(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 0x7FF0000000000000, double 8.0, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_Inf_2() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_2(
|
|
|
|
|
; CHECK-NEXT: ret double 0x7FF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0x7FF0000000000000, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_Inf_3() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_3(
|
|
|
|
|
; CHECK-NEXT: ret double 0xFFF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 0xFFF0000000000000, double 8.0, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test_Inf_4() {
|
2019-09-11 21:56:07 +08:00
|
|
|
; CHECK-LABEL: @test_Inf_4(
|
|
|
|
|
; CHECK-NEXT: ret double 0xFFF0000000000000
|
|
|
|
|
;
|
2019-04-17 12:52:47 +08:00
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0xFFF0000000000000, double 0.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
2019-09-11 22:18:48 +08:00
|
|
|
|
|
|
|
|
; -inf + inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_product_opposite_inf_addend_1() {
|
|
|
|
|
; CHECK-LABEL: @inf_product_opposite_inf_addend_1(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0xFFF0000000000000, double 0x7FF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; inf + -inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_product_opposite_inf_addend_2() {
|
|
|
|
|
; CHECK-LABEL: @inf_product_opposite_inf_addend_2(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 7.0, double 0x7FF0000000000000, double 0xFFF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; -inf + inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_product_opposite_inf_addend_3() {
|
|
|
|
|
; CHECK-LABEL: @inf_product_opposite_inf_addend_3(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0xFFF0000000000000, double 42.0, double 0x7FF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; inf + -inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_product_opposite_inf_addend_4() {
|
|
|
|
|
; CHECK-LABEL: @inf_product_opposite_inf_addend_4(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0x7FF0000000000000, double 42.0, double 0xFFF0000000000000)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; 0 * -inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_1() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_1(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0.0, double 0xFFF0000000000000, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; 0 * inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_2() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_2(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0.0, double 0x7FF0000000000000, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; -inf * 0 --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_3() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_3(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0xFFF0000000000000, double 0.0, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; inf * 0 --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_4() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_4(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0x7FF0000000000000, double 0.0, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; -0 * -inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_5() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_5(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double -0.0, double 0xFFF0000000000000, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; -0 * inf --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_6() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_6(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double -0.0, double 0x7FF0000000000000, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; -inf * -0 --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_7() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_7(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0xFFF0000000000000, double -0.0, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; inf * -0 --> NaN
|
|
|
|
|
|
|
|
|
|
define double @inf_times_zero_8() {
|
|
|
|
|
; CHECK-LABEL: @inf_times_zero_8(
|
[ConstProp] allow folding for fma that produces NaN
Folding for fma/fmuladd was added here:
rL202914
...and as seen in existing/unchanged tests, that works to propagate NaN
if it's already an input, but we should fold an fma() that creates NaN too.
From IEEE-754-2008 7.2 "Invalid Operation", there are 2 clauses that apply
to fma, so I added tests for those patterns:
c) fusedMultiplyAdd: fusedMultiplyAdd(0, ∞, c) or fusedMultiplyAdd(∞, 0, c)
unless c is a quiet NaN; if c is a quiet NaN then it is implementation
defined whether the invalid operation exception is signaled
d) addition or subtraction or fusedMultiplyAdd: magnitude subtraction of
infinities, such as: addition(+∞, −∞)
Differential Revision: https://reviews.llvm.org/D67446
llvm-svn: 371735
2019-09-12 22:10:50 +08:00
|
|
|
; CHECK-NEXT: ret double 0x7FF8000000000000
|
2019-09-11 22:18:48 +08:00
|
|
|
;
|
|
|
|
|
%1 = call double @llvm.fma.f64(double 0x7FF0000000000000, double -0.0, double 42.0)
|
|
|
|
|
ret double %1
|
|
|
|
|
}
|
