[arm+x86] Make GNU variants behave like GNU w.r.t combining sin+cos into sincos.

[dsanders]

Summary

canCombineSinCosLibcall() would previously combine sin+cos into sincos for
GNUX32/GNUEABI/GNUEABIHF regardless of whether UnsafeFPMath were set or not.
However, GNU would only combine them for UnsafeFPMath because sincos does not
set errno like sin and cos do. It seems likely that this is an oversight.

[rengolin]

This looks ok to me, but better to get more feed back from other people, as I was not really in the loop for sin/cos thing. :)

[t.p.northover]

I think it's just an omission to. sincos is definitely in my local copy of libm.so. I say go for it! (And thanks for the work).

Tim.

[t.p.northover]

Actually, it looks like it's in the androideabi too (since 2.3), so it might be a good idea to add that.

Tim.

[rengolin]

In D21431#459913, @t.p.northover wrote:

Actually, it looks like it's in the androideabi too (since 2.3), so it might be a good idea to add that.

Ah, yes, I thought about that, and forgot to say. :)

--renato

[dsanders]

In D21431#459909, @t.p.northover wrote:

I think it's just an omission to. sincos is definitely in my local copy of libm.so. I say go for it! (And thanks for the work).

Tim.

Thanks.

In D21431#459913, @t.p.northover wrote:

Actually, it looks like it's in the androideabi too (since 2.3), so it might be a good idea to add that.

Tim.

Is this combine beneficial for android at the moment? According to https://android.googlesource.com/platform/bionic/+/master/libm/sincos.c, android's sincos uses -O0 and just forwards the call to sin and cos. It looks like you'd be getting two calls for the price of three.

[dsanders]

I left androideabi alone in the commit since I think it's slower to call sincos than to call sin and cos separately in bionic.

include/llvm/ADT/Triple.h

public:
   bool isOSBitrig() const {
     return getOS() == Triple::Bitrig;
   }
 
   bool isOSIAMCU() const {
     return getOS() == Triple::ELFIAMCU;
   }
 
+  bool isGNUEnvironment() const {
+    EnvironmentType Env = getEnvironment();
+    return Env == Triple::GNU || Env == Triple::GNUEABI ||
+           Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
+  }
+
   /// Checks if the environment could be MSVC.
   bool isWindowsMSVCEnvironment() const {
     return getOS() == Triple::Win32 &&
            (getEnvironment() == Triple::UnknownEnvironment ||
             getEnvironment() == Triple::MSVC);
   }
 
   /// Checks if the environment is MSVC.

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 /// Return true if sincos libcall is available and can be used to combine sin
 /// and cos.
 static bool canCombineSinCosLibcall(SDNode *Node, const TargetLowering &TLI,
                                     const TargetMachine &TM) {
   if (!isSinCosLibcallAvailable(Node, TLI))
     return false;
   // GNU sin/cos functions set errno while sincos does not. Therefore
   // combining sin and cos is only safe if unsafe-fpmath is enabled.
-  bool isGNU = Triple(TM.getTargetTriple()).getEnvironment() == Triple::GNU;
-  if (isGNU && !TM.Options.UnsafeFPMath)
+  if (TM.getTargetTriple().isGNUEnvironment() && !TM.Options.UnsafeFPMath)
     return false;
   return true;
 }
 
 /// Only issue sincos libcall if both sin and cos are needed.
 static bool useSinCos(SDNode *Node) {
   unsigned OtherOpcode = Node->getOpcode() == ISD::FSIN
     ? ISD::FCOS : ISD::FSIN;

lib/CodeGen/TargetLoweringBase.cpp

static void InitLibcallNames(const char **Names, const Triple &TT) {
   Names[RTLIB::ATOMIC_FETCH_XOR_8] = "__atomic_fetch_xor_8";
   Names[RTLIB::ATOMIC_FETCH_XOR_16] = "__atomic_fetch_xor_16";
   Names[RTLIB::ATOMIC_FETCH_NAND_1] = "__atomic_fetch_nand_1";
   Names[RTLIB::ATOMIC_FETCH_NAND_2] = "__atomic_fetch_nand_2";
   Names[RTLIB::ATOMIC_FETCH_NAND_4] = "__atomic_fetch_nand_4";
   Names[RTLIB::ATOMIC_FETCH_NAND_8] = "__atomic_fetch_nand_8";
   Names[RTLIB::ATOMIC_FETCH_NAND_16] = "__atomic_fetch_nand_16";
 
-  if (TT.getEnvironment() == Triple::GNU) {
+  if (TT.isGNUEnvironment()) {
     Names[RTLIB::SINCOS_F32] = "sincosf";
     Names[RTLIB::SINCOS_F64] = "sincos";
     Names[RTLIB::SINCOS_F80] = "sincosl";
     Names[RTLIB::SINCOS_F128] = "sincosl";
     Names[RTLIB::SINCOS_PPCF128] = "sincosl";
   }
 
   if (!TT.isOSOpenBSD()) {

test/CodeGen/ARM/sincos.ll

 ; RUN: llc < %s -mtriple=armv7-apple-ios6 -mcpu=cortex-a8 | FileCheck %s --check-prefix=NOOPT
 ; RUN: llc < %s -mtriple=armv7-apple-ios7 -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS
+; RUN: llc < %s -mtriple=armv7-linux-gnu -mcpu=cortex-a8 | FileCheck %s --check-prefix=NOOPT-GNU
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a8 \
+; RUN:   --enable-unsafe-fp-math | FileCheck %s --check-prefix=SINCOS-GNU
 
 ; Combine sin / cos into a single call.
 ; rdar://12856873
 
 define float @test1(float %x) nounwind {
 entry:
 ; SINCOS-LABEL: test1:
 ; SINCOS: bl ___sincosf_stret
 
+; SINCOS-GNU-LABEL: test1:
+; SINCOS-GNU: bl sincosf
+
 ; NOOPT-LABEL: test1:
 ; NOOPT: bl _sinf
 ; NOOPT: bl _cosf
+
+; NOOPT-GNU-LABEL: test1:
+; NOOPT-GNU: bl sinf
+; NOOPT-GNU: bl cosf
+
   %call = tail call float @sinf(float %x) nounwind readnone
   %call1 = tail call float @cosf(float %x) nounwind readnone
   %add = fadd float %call, %call1
   ret float %add
 }
 
 define double @test2(double %x) nounwind {
 entry:
 ; SINCOS-LABEL: test2:
 ; SINCOS: bl ___sincos_stret
 
+; SINCOS-GNU-LABEL: test2:
+; SINCOS-GNU: bl sincos
+
 ; NOOPT-LABEL: test2:
 ; NOOPT: bl _sin
 ; NOOPT: bl _cos
+
+; NOOPT-GNU-LABEL: test2:
+; NOOPT-GNU: bl sin
+; NOOPT-GNU: bl cos
   %call = tail call double @sin(double %x) nounwind readnone
   %call1 = tail call double @cos(double %x) nounwind readnone
   %add = fadd double %call, %call1
   ret double %add
 }
 
 declare float  @sinf(float) readonly
 declare double @sin(double) readonly
 declare float @cosf(float) readonly
 declare double @cos(double) readonly

test/CodeGen/X86/sincos-opt.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-macosx10.9.0 -mcpu=core2 | FileCheck %s --check-prefix=OSX_SINCOS
 ; RUN: llc < %s -mtriple=x86_64-apple-macosx10.8.0 -mcpu=core2 | FileCheck %s --check-prefix=OSX_NOOPT
+; RUN: llc < %s -mtriple=x86_64-pc-linux-gnu -mcpu=core2 | FileCheck %s --check-prefix=GNU_NOOPT
 ; RUN: llc < %s -mtriple=x86_64-pc-linux-gnu -mcpu=core2 -enable-unsafe-fp-math | FileCheck %s --check-prefix=GNU_SINCOS
+; RUN: llc < %s -mtriple=x86_64-pc-linux-gnux32 -mcpu=core2 -enable-unsafe-fp-math | FileCheck %s --check-prefix=GNUX32_SINCOS
 
 ; Combine sin / cos into a single call.
 ; rdar://13087969
 ; rdar://13599493
 
 define float @test1(float %x) nounwind {
 entry:
 ; GNU_SINCOS-LABEL: test1:
 ; GNU_SINCOS: callq sincosf
 ; GNU_SINCOS: movss 4(%rsp), %xmm0
 ; GNU_SINCOS: addss (%rsp), %xmm0
 
+; GNUX32_SINCOS-LABEL: test1:
+; GNUX32_SINCOS: callq sincosf
+; GNUX32_SINCOS: movss 4(%esp), %xmm0
+; GNUX32_SINCOS: addss (%esp), %xmm0
+
+; GNU_NOOPT: test1
+; GNU_NOOPT: callq sinf
+; GNU_NOOPT: callq cosf
+
 ; OSX_SINCOS-LABEL: test1:
 ; OSX_SINCOS: callq ___sincosf_stret
 ; OSX_SINCOS: movshdup {{.*}} xmm1 = xmm0[1,1,3,3]
 ; OSX_SINCOS: addss %xmm1, %xmm0
 
 ; OSX_NOOPT: test1
 ; OSX_NOOPT: callq _sinf
 ; OSX_NOOPT: callq _cosf
   %call = tail call float @sinf(float %x) nounwind readnone
   %call1 = tail call float @cosf(float %x) nounwind readnone
   %add = fadd float %call, %call1
   ret float %add
 }
 
 define double @test2(double %x) nounwind {
 entry:
 ; GNU_SINCOS-LABEL: test2:
 ; GNU_SINCOS: callq sincos
 ; GNU_SINCOS: movsd 16(%rsp), %xmm0
 ; GNU_SINCOS: addsd 8(%rsp), %xmm0
 
+; GNUX32_SINCOS-LABEL: test2:
+; GNUX32_SINCOS: callq sincos
+; GNUX32_SINCOS: movsd 16(%esp), %xmm0
+; GNUX32_SINCOS: addsd 8(%esp), %xmm0
+
+; GNU_NOOPT: test2:
+; GNU_NOOPT: callq sin
+; GNU_NOOPT: callq cos
+
 ; OSX_SINCOS-LABEL: test2:
 ; OSX_SINCOS: callq ___sincos_stret
 ; OSX_SINCOS: addsd %xmm1, %xmm0
 
 ; OSX_NOOPT: test2
 ; OSX_NOOPT: callq _sin
 ; OSX_NOOPT: callq _cos
   %call = tail call double @sin(double %x) nounwind readnone
   %call1 = tail call double @cos(double %x) nounwind readnone
   %add = fadd double %call, %call1
   ret double %add
 }
 
 define x86_fp80 @test3(x86_fp80 %x) nounwind {
 entry:
 ; GNU_SINCOS-LABEL: test3:
 ; GNU_SINCOS: callq sinl
 ; GNU_SINCOS: callq cosl
 ; GNU_SINCOS: ret
+
+; GNUX32_SINCOS-LABEL: test3:
+; GNUX32_SINCOS: callq sinl
+; GNUX32_SINCOS: callq cosl
+; GNUX32_SINCOS: ret
+
+; GNU_NOOPT: test3:
+; GNU_NOOPT: callq sinl
+; GNU_NOOPT: callq cosl
+
   %call = tail call x86_fp80 @sinl(x86_fp80 %x) nounwind
   %call1 = tail call x86_fp80 @cosl(x86_fp80 %x) nounwind
   %add = fadd x86_fp80 %call, %call1
   ret x86_fp80 %add
 }
 
 declare float  @sinf(float) readonly
 declare double @sin(double) readonly
 declare float @cosf(float) readonly
 declare double @cos(double) readonly
 
 declare x86_fp80 @sinl(x86_fp80)
 declare x86_fp80 @cosl(x86_fp80)