[stdlib] Implement tgmath in Glibc

Author: rintaro

stdlib/public/Platform/CMakeLists.txt

@@ -2,16 +2,16 @@ set(swift_platform_name)
 set(swift_platform_flags)
 set(swift_platform_sources
     Platform.swift
-    Misc.c)
+    Misc.c
+    tgmath.swift.gyb)
 
 if(SWIFT_HOST_VARIANT MATCHES "${SWIFT_DARWIN_VARIANTS}")
   set(swift_platform_name swiftDarwin)
   set(swift_platform_sources
       Darwin.swift
       ${swift_platform_sources}
       POSIXError.swift
-      MachError.swift
-      tgmath.swift.gyb)
+      MachError.swift)
   set(swift_platform_flags
       SWIFT_COMPILE_FLAGS -Xfrontend -disable-objc-attr-requires-foundation-module
       API_NOTES_NON_OVERLAY)

stdlib/public/Platform/tgmath.swift.gyb

@@ -79,7 +79,7 @@ OtherFunctions = [
     'jn', 'yn'
 ]
 
-# These functions are imported correctly as-is.             
+# These functions are imported correctly as-is.
 OkayFunctions = ['j0', 'j1', 'y0', 'y1']
 
 # These functions are not supported for various reasons.
@@ -129,6 +129,7 @@ public func ${ufunc}(x: ${T}) -> ${T} {
 
 % end
 
+#if os(OSX) || os(iOS) || os(tvOS) || os(watchOS)
 // Unary intrinsic functions
 // Note these have a corresponding LLVM intrinsic
 % for T, ufunc in TypedUnaryIntrinsicFunctions():
@@ -139,6 +140,22 @@ public func ${ufunc}(x: ${T}) -> ${T} {
 }
 
 % end
+#else
+// FIXME: As of now, we cannot declare 64-bit (Double/CDouble) overlays here.
+// Since CoreFoundation also exports libc functions, they will conflict with
+// Swift overlays when building Foundation. For now, just like normal
+// UnaryFunctions, we define overlays only for OverlayFloatTypes.
+% for ufunc in UnaryIntrinsicFunctions:
+%     for T, CT, f in OverlayFloatTypes():
+@_transparent
+@warn_unused_result
+public func ${ufunc}(x: ${T}) -> ${T} {
+  return ${T}(${ufunc}${f}(${CT}(x)))
+}
+
+%     end
+% end
+#endif
 
 // Binary functions
 
@@ -153,11 +170,9 @@ public func ${bfunc}(lhs: ${T}, _ rhs: ${T}) -> ${T} {
 
 // Other functions
 
-% # These are AllFloatTypes not OverlayFloatTypes because of the Int return.
-% for T, CT, f in AllFloatTypes():
-%   if f == '':
-%     f = 'd'
-%   end
+% # These would be AllFloatTypes not OverlayFloatTypes because of the Int return.
+% # ... except we need special treatment for Double.
+% for T, CT, f in OverlayFloatTypes():
 @_transparent
 @warn_unused_result
 public func fpclassify(x: ${T}) -> Int {
@@ -166,6 +181,16 @@ public func fpclassify(x: ${T}) -> Int {
 
 % end
 
+@_transparent
+@warn_unused_result
+public func fpclassify(x: Double) -> Int {
+#if os(Linux)
+  return Int(__fpclassify(CDouble(x)))
+#else
+  return Int(__fpclassifyd(CDouble(x)))
+#endif
+}
+
 % # These are AllFloatTypes not OverlayFloatTypes because we need to cover 
 % # them all because C's declarations are compiler builtins.
 % for T, CT, f in AllFloatTypes():
@@ -257,6 +282,16 @@ public func scalbn(x: ${T}, _ n: Int) -> ${T} {
 
 % # This is AllFloatTypes not OverlayFloatTypes because of the tuple return.
 % for T, CT, f in AllFloatTypes():
+#if os(Linux) || os(FreeBSD)
+@_transparent
+@warn_unused_result
+public func lgamma(x: ${T}) -> (${T}, Int) {
+  var sign = CInt(0)
+  let value = lgamma${f}_r(${CT}(x), &sign)
+  return (${T}(value), Int(sign))
+}
+#else
+% # On Darwin platform,
 % # The real lgamma_r is not imported because it hides behind macro _REENTRANT.
 @warn_unused_result
 @_silgen_name("_swift_Darwin_lgamma${f}_r")
@@ -273,6 +308,7 @@ public func lgamma(x: ${T}) -> (${T}, Int) {
   }
   return (${T}(value), Int(sign))
 }
+#endif
 
 % end
 

test/1_stdlib/tgmath.swift

@@ -1,10 +1,19 @@
 // RUN: %target-run-simple-swift | FileCheck %s
 // REQUIRES: executable_test
 
-// XFAIL: linux
-
+#if os(Linux) || os(FreeBSD)
+  import Glibc
+  // FIXME: this is a quick hack for non Darwin platforms
+  // where they doesn't have CoreGraphics module.
+  #if arch(i386) || arch(arm)
+    typealias CGFloat = Float
+  #elseif arch(x86_64) || arch(arm64)
+    typealias CGFloat = Double
+  #endif
+#else
 import Darwin.C.tgmath
 import CoreGraphics
+#endif
 
 // verifiers
 
@@ -146,8 +155,10 @@ print3("tan", d1, f1, g1)
 d1 = acosh(dx)
 f1 = acosh(fx)
 g1 = acosh(gx)
-print3("acosh", d1, f1, g1)
-// CHECK-NEXT: acosh nan nan acosh
+print3("acosh", d1.isNaN, f1.isNaN, g1.isNaN)
+// CHECK-NEXT: acosh true true acosh
+// Note: We cannot check the output with "nan nan" using  String interpolations
+// because glibc on Linux outputs the result as "-nan" instead of "nan".
 
 d1 = asinh(dx)
 f1 = asinh(fx)

test/1_stdlib/tgmath_optimized.swift

@@ -3,9 +3,11 @@
 // RUN: %target-run %t/a.out
 // REQUIRES: executable_test
 
-// XFAIL: linux
-
-import Darwin
+#if os(Linux) || os(FreeBSD)
+  import Glibc
+#else
+  import Darwin
+#endif
 import StdlibUnittest
 
 // Also import modules which are used by StdlibUnittest internally. This