[llvm] r216913 - [APFloat] Fixed a bug in method 'fusedMultiplyAdd'.

Tue Sep 2 10:20:54 PDT 2014

Hi Michael,

sure, I can add unit tests into unittests/ADT/APFloatTest.cpp.
However, at the moment I am seeing unexpected failures due to my new
test on a couple of the buildbots:
http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/18685.
I am going to revert this change for now as I need to investigate on
why it caused new failures..

On Tue, Sep 2, 2014 at 6:04 PM, Michael Gottesman <mgottesman at apple.com> wrote:
> Can you please put in unit tests into unittests/ADT/APFloatTest.cpp at least for the test cases that you put into the .ll file?
>
> Michael
>
> On Sep 2, 2014, at 9:44 AM, Andrea Di Biagio <Andrea_DiBiagio at sn.scee.net> wrote:
>
>> Author: adibiagio
>> Date: Tue Sep  2 11:44:56 2014
>> New Revision: 216913
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=216913&view=rev
>> Log:
>> [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.
>>
>> Differential Revision: http://reviews.llvm.org/D5152
>>
>> Added:
>>    llvm/trunk/test/Transforms/InstSimplify/fold-builtin-fma.ll
>> Modified:
>>    llvm/trunk/lib/Support/APFloat.cpp
>>
>> Modified: llvm/trunk/lib/Support/APFloat.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APFloat.cpp?rev=216913&r1=216912&r2=216913&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Support/APFloat.cpp (original)
>> +++ llvm/trunk/lib/Support/APFloat.cpp Tue Sep  2 11:44:56 2014
>> @@ -1801,7 +1801,7 @@ APFloat::fusedMultiplyAdd(const APFloat
>>      extended-precision calculation.  */
>>   if (isFiniteNonZero() &&
>>       multiplicand.isFiniteNonZero() &&
>> -      addend.isFiniteNonZero()) {
>> +      addend.isFinite()) {
>>     lostFraction lost_fraction;
>>
>>     lost_fraction = multiplySignificand(multiplicand, &addend);
>>
>> Added: llvm/trunk/test/Transforms/InstSimplify/fold-builtin-fma.ll
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstSimplify/fold-builtin-fma.ll?rev=216913&view=auto
>> ==============================================================================
>> --- llvm/trunk/test/Transforms/InstSimplify/fold-builtin-fma.ll (added)
>> +++ llvm/trunk/test/Transforms/InstSimplify/fold-builtin-fma.ll Tue Sep  2 11:44:56 2014
>> @@ -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
>> +
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits