6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-10 20:33:15 +00:00
Code Issues Projects Releases Wiki Activity

[APFloat] Fixed a bug in method 'fusedMultiplyAdd'.

Browse Source 
When folding a fused multiply-add builtin call, make sure that we propagate the
correct result in the case where the addend is zero, and the two other operands
are finite non-zero.

Example:
  define double @test() {
    %1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0.0)
    ret double %1
  }

Before this patch, the instruction simplifier wrongly folded the builtin call
in function @test to constant 'double 7.0'.
With this patch, method 'fusedMultiplyAdd' correctly evaluates the multiply and
propagates the expected result (i.e. 56.0).

Added test fold-builtin-fma.ll with the reproducible from PR20832 plus extra
test cases to verify the behavior of method 'fusedMultiplyAdd' in the presence
of NaN/Inf operands.

This fixes PR20832.

Differential Revision: http://reviews.llvm.org/D5152


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216913 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Andrea Di Biagio 2014-09-02 16:44:56 +00:00
parent a778b5efaa
commit 0b6ee9fd1c
2 changed files with 120 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/Support/APFloat.cpp
View File

@ -1801,7 +1801,7 @@ APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
extended-precision calculation. */
if (isFiniteNonZero() &&
multiplicand.isFiniteNonZero() &&
addend.isFiniteNonZero()) {
addend.isFinite()) {
lostFraction lost_fraction;
lost_fraction = multiplySignificand(multiplicand, &addend);

119
test/Transforms/InstSimplify/fold-builtin-fma.ll Normal file
View File

@ -0,0 +1,119 @@
; RUN: opt -instsimplify -S < %s | FileCheck %s
; 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() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0.0)
ret double %1
}
; CHECK-LABEL: @PR20832(
; CHECK: ret double 5.600000e+01
; Test builtin fma with all finite non-zero constants.
define double @test_all_finite() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 5.0)
ret double %1
}
; CHECK-LABEL: @test_all_finite(
; CHECK: ret double 6.100000e+01
; Test builtin fma with a +/-NaN addend.
define double @test_NaN_addend() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0x7FF8000000000000)
ret double %1
}
; CHECK-LABEL: @test_NaN_addend(
; CHECK: ret double 0x7FF8000000000000
define double @test_NaN_addend_2() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0xFFF8000000000000)
ret double %1
}
; CHECK-LABEL: @test_NaN_addend_2(
; CHECK: ret double 0xFFF8000000000000
; Test builtin fma with a +/-Inf addend.
define double @test_Inf_addend() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0x7FF0000000000000)
ret double %1
}
; CHECK-LABEL: @test_Inf_addend(
; CHECK: ret double 0x7FF0000000000000
define double @test_Inf_addend_2() {
%1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 0xFFF0000000000000)
ret double %1
}
; CHECK-LABEL: @test_Inf_addend_2(
; CHECK: ret double 0xFFF0000000000000
; Test builtin fma with one of the operands to the multiply being +/-NaN.
define double @test_NaN_1() {
%1 = call double @llvm.fma.f64(double 0x7FF8000000000000, double 8.0, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_NaN_1(
; CHECK: ret double 0x7FF8000000000000
define double @test_NaN_2() {
%1 = call double @llvm.fma.f64(double 7.0, double 0x7FF8000000000000, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_NaN_2(
; CHECK: ret double 0x7FF8000000000000
define double @test_NaN_3() {
%1 = call double @llvm.fma.f64(double 0xFFF8000000000000, double 8.0, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_NaN_3(
; CHECK: ret double 0x7FF8000000000000
define double @test_NaN_4() {
%1 = call double @llvm.fma.f64(double 7.0, double 0xFFF8000000000000, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_NaN_4(
; CHECK: ret double 0x7FF8000000000000
; Test builtin fma with one of the operands to the multiply being +/-Inf.
define double @test_Inf_1() {
%1 = call double @llvm.fma.f64(double 0x7FF0000000000000, double 8.0, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_Inf_1(
; CHECK: ret double 0x7FF0000000000000
define double @test_Inf_2() {
%1 = call double @llvm.fma.f64(double 7.0, double 0x7FF0000000000000, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_Inf_2(
; CHECK: ret double 0x7FF0000000000000
define double @test_Inf_3() {
%1 = call double @llvm.fma.f64(double 0xFFF0000000000000, double 8.0, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_Inf_3(
; CHECK: ret double 0xFFF0000000000000
define double @test_Inf_4() {
%1 = call double @llvm.fma.f64(double 7.0, double 0xFFF0000000000000, double 0.0)
ret double %1
}
; CHECK-LABEL: @test_Inf_4(
; CHECK: ret double 0xFFF0000000000000