mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-16 11:30:51 +00:00
f0f98417ca
Reapply r216913, a fix for PR20832 by Andrea Di Biagio. The commit was reverted because of buildbot failures, and credit goes to Ulrich Weigand for isolating the underlying issue (which can be confirmed by Valgrind, which does helpfully light up like the fourth of July). Uli explained the problem with the original patch as: It seems the problem is calling multiplySignificand with an addend of category fcZero; that is not expected by this routine. Note that for fcZero, the significand parts are simply uninitialized, but the code in (or rather, called from) multiplySignificand will unconditionally access them -- in effect using uninitialized contents. This version avoids using a category == fcZero addend within multiplySignificand, which avoids this problem (the Valgrind output is also now clean). Original commit message: [APFloat] Fixed a bug in method 'fusedMultiplyAdd'. 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. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@219708 91177308-0d34-0410-b5e6-96231b3b80d8
120 lines
3.3 KiB
LLVM
120 lines
3.3 KiB
LLVM
; 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
|
|
|