Revert SE-0246 (#23800)

* Revert "Merge pull request #23791 from compnerd/you-know-nothing-clang" This reverts commit 5150981150, reversing changes made to 8fc305c03e. * Revert "Merge pull request #23780 from compnerd/math-is-terrible" This reverts commit 2d7fedd25f, reversing changes made to 0205150b8f. * Revert "Merge pull request #23140 from stephentyrone/mafs" This reverts commit 777750dc51, reversing changes made to 0c8920e747.
2025-12-21 12:14:44 +01:00 · 2019-04-04 19:35:25 -04:00
parent b6c3ca0cd8
commit c5e3f85378
18 changed files with 227 additions and 1215 deletions
--- a/stdlib/public/Darwin/CoreGraphics/CGFloat.swift.gyb
+++ b/stdlib/public/Darwin/CoreGraphics/CGFloat.swift.gyb
@@ -513,111 +513,18 @@ public func %=(lhs: inout CGFloat, rhs: CGFloat) {
 // tgmath
 //===----------------------------------------------------------------------===//

-%from SwiftMathFunctions import *
-extension CGFloat: Real {
-% for func in ElementaryFunctions + RealFunctions:
-
-  @_alwaysEmitIntoClient
-  public static func ${func.decl("CGFloat")} {
-    return CGFloat(NativeType.${func.swiftName}(${func.params("", ".native")}))
-  }
-% end
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.pow(x.native, y.native))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: CGFloat, _ n: Int) -> CGFloat {
-    return CGFloat(NativeType.pow(x.native, n))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func root(_ x: CGFloat, _ n: Int) -> CGFloat {
-    return CGFloat(NativeType.root(x.native, n))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func atan2(y: CGFloat, x: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.atan2(y: y.native, x: x.native))
-  }
-
-#if !os(Windows)
-  @_alwaysEmitIntoClient
-  public static func logGamma(_ x: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.logGamma(x.native))
-  }
-#endif
-}
-
-@available(swift, deprecated: 5.1, message: "Use `root(x, 3)`.")
-@_transparent
-public func cbrt(_ x: CGFloat) -> CGFloat {
-  return CGFloat.root(x, 3)
-}
-
-@available(swift, deprecated: 5.1, message: "Use CGFloat.minimum( ) or Swift.min( )")
-@_transparent
-public func fmin(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return .minimum(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use CGFloat.maximum( ) or Swift.max( )")
-@_transparent
-public func fmax(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return .maximum(x, y)
-}
-
-#if !os(Windows)
-@available(swift, deprecated: 5.1, message: "Use (logGamma(x), signGamma(x)).")
-@_transparent
-public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
-  return (CGFloat.logGamma(x), CGFloat.signGamma(x) == .plus ? 1 : -1)
-}
-#endif
-
-@available(swift, deprecated: 5.1, message: "Use `x.exponent` or `floor(log2(x))`.")
-@_transparent
-public func logb(_ x: CGFloat) -> CGFloat {
-  return CGFloat.log2(x).rounded(.down)
-}
-
-@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
-@_transparent
-public func nearbyint(_ x: CGFloat) -> CGFloat {
-  return x.rounded(.toNearestOrEven)
-}
-
-@available(swift, deprecated: 5.1, message: "Use the .nextUp or .nextDown property.")
-@_transparent
-public func nextafter(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return y > x ? x.nextUp : (y < x ? x.nextDown : y)
-}
-
-@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
-@_transparent
-public func rint(_ x: CGFloat) -> CGFloat {
-  return x.rounded(.toNearestOrEven)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `gamma(x)`.")
-@_transparent
-public func tgamma(_ x: CGFloat) -> CGFloat {
-  return CGFloat.gamma(x)
-}
-
 %{
 UnaryFunctions = [
  'acos', 'asin', 'atan', 'cos', 'sin', 'tan',
  'acosh', 'asinh', 'atanh', 'cosh', 'sinh', 'tanh',
  'exp', 'exp2', 'expm1',
-  'log', 'log10', 'log1p', 'log2',
-  'erf', 'erfc',
+  'log', 'log10', 'log1p', 'log2', 'logb',
+  'cbrt', 'erf', 'erfc', 'tgamma',
+  'nearbyint', 'rint'
 ]

 BinaryFunctions = [
-  'atan2', 'hypot', 'pow', 'copysign', 'fdim'
+  'atan2', 'hypot', 'pow', 'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
 ]
 }%

@@ -664,12 +571,18 @@ public func ldexp(_ x: CGFloat, _ n: Int) -> CGFloat {
  return CGFloat(ldexp(x.native, n))
 }

-@available(swift, deprecated: 4.2, obsoleted: 5.1, message: "use the exponent property.")
+@available(swift, deprecated: 4.2, message: "use the exponent property.")
@_transparent
 public func ilogb(_ x: CGFloat) -> Int {
  return Int(x.exponent)
 }

+@_transparent
+public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
+  let (value, sign) = lgamma(x.native)
+  return (CGFloat(value), sign)
+}
+
@_transparent
 public func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int) {
  let (rem, quo) = remquo(x.native, y.native)
--- a/stdlib/public/Platform/tgmath.swift.gyb
+++ b/stdlib/public/Platform/tgmath.swift.gyb
@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -14,12 +14,11 @@ import SwiftShims

 // Generic functions implementable directly on FloatingPoint.
@_transparent
-@available(swift, deprecated: 4.2, obsoleted: 5.1, renamed: "Swift.abs")
+@available(swift, deprecated: 4.2, renamed: "abs")
 public func fabs<T: FloatingPoint>(_ x: T) -> T {
  return x.magnitude
 }

-@available(swift, obsoleted: 5.1, message: "Use Swift.sqrt(x) or x.squareRoot().")
@_transparent
 public func sqrt<T: FloatingPoint>(_ x: T) -> T {
  return x.squareRoot()
@@ -113,7 +112,7 @@ public func isnan<T: FloatingPoint>(_ value: T) -> Bool { fatalError() }
@available(*, unavailable, message: "use the sign property.")
 public func signbit<T: FloatingPoint>(_ value: T) -> Int { fatalError() }

-@available(swift, deprecated: 4.2, obsoleted: 5.1, message: "use the exponent property.")
+@available(swift, deprecated: 4.2, message: "use the exponent property.")
 public func ilogb<T: BinaryFloatingPoint>(_ x: T) -> Int {
  return Int(x.exponent)
 }
@@ -156,20 +155,44 @@ UnaryFunctions = [
    'acos', 'asin', 'atan', 'tan',
    'acosh', 'asinh', 'atanh', 'cosh', 'sinh', 'tanh',
    'expm1',
-    'log1p',
-    'erf', 'erfc',
+    'log1p', 'logb',
+    'cbrt', 'erf', 'erfc', 'tgamma',
 ]

 # These functions have a corresponding LLVM intrinsic
+# We call this intrinsic via the Builtin method so keep this list in
+# sync with core/BuiltinMath.swift.gyb
 UnaryIntrinsicFunctions = [
-    'cos', 'sin', 'exp', 'exp2', 'log', 'log10', 'log2', 'nearbyint', 'rint'
+    'cos', 'sin',
+    'exp', 'exp2',
+    'log', 'log10', 'log2',
+    'nearbyint', 'rint',
 ]

 # (T, T) -> T
 BinaryFunctions = [
-    'atan2', 'hypot', 'fdim', 'copysign'
+    'atan2', 'hypot', 'pow',
+    'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
 ]

+# These functions have special implementations.
+OtherFunctions = [
+    'scalbn', 'lgamma', 'remquo', 'nan', 'jn', 'yn'
+]
+
+# These functions are imported correctly as-is.
+OkayFunctions = ['j0', 'j1', 'y0', 'y1']
+
+# These functions are not supported for various reasons.
+UnhandledFunctions = [
+    'math_errhandling', 'scalbln',
+    'lrint', 'lround', 'llrint', 'llround', 'nexttoward',
+    'isgreater', 'isgreaterequal', 'isless', 'islessequal',
+    'islessgreater', 'isunordered', '__exp10',
+    '__sincos', '__cospi', '__sinpi', '__tanpi', '__sincospi'
+]
+
+
 def AllFloatTypes():
    for bits in allFloatBits:
        yield floatName(bits), cFloatName(bits), cFuncSuffix(bits)
@@ -203,74 +226,50 @@ def TypedBinaryFunctions():
 %  end
@_transparent
 public func ${ufunc}(_ x: ${T}) -> ${T} {
-  return ${T}.${ufunc}(x)
+  return ${T}(${ufunc}${f}(${CT}(x)))
 }
 %  if T == 'Float80':
 #endif
 %  end

 % end
-@available(swift, deprecated: 5.1, message: "Use `root(x, 3)`.")
-@_transparent
-public func cbrt(_ x: Float) -> Float {
-  return Float.root(x, 3)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `x.exponent` or `floor(log2(x))`.")
-@_transparent
-public func logb(_ x: Float) -> Float {
-  return Float.log2(x).rounded(.down)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `gamma(x)`.")
-@_transparent
-public func tgamma(_ x: Float) -> Float {
-  return Float.gamma(x)
-}
-
-#if (arch(i386) || arch(x86_64)) && !os(Windows)
-@available(swift, deprecated: 5.1, message: "Use `root(x, 3)`.")
-@_transparent
-public func cbrt(_ x: Float80) -> Float80 {
-  return Float80.root(x, 3)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `x.exponent` or `floor(log2(x))`.")
-@_transparent
-public func logb(_ x: Float80) -> Float80 {
-  return Float80.log2(x).rounded(.down)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `gamma(x)`.")
-@_transparent
-public func tgamma(_ x: Float80) -> Float80 {
-  return Float80.gamma(x)
-}
-#endif

+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 // Unary intrinsic functions
 // Note these have a corresponding LLVM intrinsic
 % for T, ufunc in TypedUnaryIntrinsicFunctions():
 %  if T == 'Float80':
 #if (arch(i386) || arch(x86_64)) && !os(Windows)
 %  end
-%  if ufunc[-3:] != 'int':
@_transparent
 public func ${ufunc}(_ x: ${T}) -> ${T} {
-  return ${T}.${ufunc}(x)
+  return _${ufunc}(x)
 }
-%  else:
-@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven) instead.")
-@_transparent
-public func ${ufunc}(_ x: ${T}) -> ${T} {
-  return x.rounded(.toNearestOrEven)
-}
-%  end
 %  if T == 'Float80':
 #endif
 %  end

 % 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():
+%   if T == 'Float80':
+#if (arch(i386) || arch(x86_64)) && !os(Windows)
+%   end
+@_transparent
+public func ${ufunc}(_ x: ${T}) -> ${T} {
+  return ${T}(${ufunc}${f}(${CT}(x)))
+}
+%   if T == 'Float80':
+#endif
+%   end
+%  end
+% end
+#endif

 // Binary functions

@@ -288,54 +287,6 @@ public func ${bfunc}(_ lhs: ${T}, _ rhs: ${T}) -> ${T} {

 % end

-@_transparent
-public func pow(_ x: Float, _ y: Float) -> Float {
-  return Float.pow(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use the .nextUp and .nextDown properties.")
-@_transparent
-public func nextafter(_ x: Float, _ y: Float) -> Float {
-  return y > x ? x.nextUp : (y < x ? x.nextDown : y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use Float.minimum( ) or Swift.min( )")
-@_transparent
-public func fmin(_ x: Float, _ y: Float) -> Float {
-  return .minimum(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use Float.maximum( ) or Swift.max( )")
-@_transparent
-public func fmax(_ x: Float, _ y: Float) -> Float {
-  return .maximum(x, y)
-}
-
-#if (arch(i386) || arch(x86_64)) && !os(Windows)
-@_transparent
-public func pow(_ x: Float80, _ y: Float80) -> Float80 {
-  return Float80.pow(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use the .nextUp and .nextDown properties.")
-@_transparent
-public func nextafter(_ x: Float80, _ y: Float80) -> Float80 {
-  return y > x ? x.nextUp : (y < x ? x.nextDown : y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use Float80.minimum( ) or Swift.min( )")
-@_transparent
-public func fmin(_ x: Float80, _ y: Float80) -> Float80 {
-  return Float80.minimum(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use Float80.maximum( ) or Swift.max( )")
-@_transparent
-public func fmax(_ x: Float80, _ y: Float80) -> Float80 {
-  return Float80.maximum(x, y)
-}
-#endif
-
 % # This is AllFloatTypes not OverlayFloatTypes because of the tuple return.
 % for T, CT, f in AllFloatTypes():
 %  if T == 'Float80':
@@ -344,10 +295,11 @@ public func fmax(_ x: Float80, _ y: Float80) -> Float80 {
 //  lgamma not available on Windows, apparently?
 #if !os(Windows)
 %  end
-@available(swift, deprecated: 5.1, message: "Use (logGamma(x), signGamma(x)).")
@_transparent
 public func lgamma(_ x: ${T}) -> (${T}, Int) {
-  return (${T}.logGamma(x), ${T}.signGamma(x) == .plus ? 1 : -1)
+  var sign = Int32(0)
+  let value = lgamma${f}_r(${CT}(x), &sign)
+  return (${T}(value), Int(sign))
 }
 #endif

@@ -374,8 +326,8 @@ public func remquo(_ x: ${T}, _ y: ${T}) -> (${T}, Int) {
 %  if T == 'Float80':
 #if (arch(i386) || arch(x86_64)) && !os(Windows)
 %  end
-@available(swift, deprecated: 4.2, obsoleted: 5.1, message:
-           "use ${T}(nan: ${T}.RawSignificand).")
+@available(swift, deprecated: 4.2, message:
+           "use ${T}(nan: ${T}.RawSignificand) instead.")
@_transparent
 public func nan(_ tag: String) -> ${T} {
  return ${T}(nan${f}(tag))
--- a/stdlib/public/SwiftShims/LibcShims.h
+++ b/stdlib/public/SwiftShims/LibcShims.h
@@ -127,343 +127,46 @@ static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {

 // Math library functions
 static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_remainderf(float _self, float other) {
-  return __builtin_remainderf(_self, other);
+float _stdlib_remainderf(float _self, float _other) {
+  return __builtin_remainderf(_self, _other);
 }
  
 static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_squareRootf(float _self) {
+float _stdlib_squareRootf(float _self) {
  return __builtin_sqrtf(_self);
 }
-  
+
 static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_tanf(float x) {
-  return __builtin_tanf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_acosf(float x) {
-  return __builtin_acosf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_asinf(float x) {
-  return __builtin_asinf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_atanf(float x) {
-  return __builtin_atanf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_atan2f(float y, float x) {
-  return __builtin_atan2f(y, x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_coshf(float x) {
-  return __builtin_coshf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_sinhf(float x) {
-  return __builtin_sinhf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_tanhf(float x) {
-  return __builtin_tanhf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_acoshf(float x) {
-  return __builtin_acoshf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_asinhf(float x) {
-  return __builtin_asinhf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_atanhf(float x) {
-  return __builtin_atanhf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_exp10f(float x) {
-#if defined __APPLE__
-  extern float __exp10f(float);
-  return __exp10f(x);
-#else
-  return __builtin_powf(10, x);
-#endif
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_expm1f(float x) {
-  return __builtin_expm1f(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_log1pf(float x) {
-  return __builtin_log1pf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_hypotf(float x, float y) {
-#if defined(_WIN32)
-  extern float _hypotf(float, float);
-  return _hypotf(x, y);
-#else
-  return __builtin_hypotf(x, y);
-#endif
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_erff(float x) {
-  return __builtin_erff(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_erfcf(float x) {
-  return __builtin_erfcf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_tgammaf(float x) {
-  return __builtin_tgammaf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-float _swift_stdlib_lgammaf(float x) {
-  extern float lgammaf_r(float x, int *psigngam);
-  int dontCare;
-  return lgammaf_r(x, &dontCare);
+double _stdlib_remainder(double _self, double _other) {
+  return __builtin_remainder(_self, _other);
 }

 static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_remainder(double _self, double other) {
-  return __builtin_remainder(_self, other);
-}
-
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_squareRoot(double _self) {
+double _stdlib_squareRoot(double _self) {
  return __builtin_sqrt(_self);
 }

-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_tan(double x) {
-  return __builtin_tan(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_acos(double x) {
-  return __builtin_acos(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_asin(double x) {
-  return __builtin_asin(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_atan(double x) {
-  return __builtin_atan(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_atan2(double y, double x) {
-  return __builtin_atan2(y, x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_cosh(double x) {
-  return __builtin_cosh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_sinh(double x) {
-  return __builtin_sinh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_tanh(double x) {
-  return __builtin_tanh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_acosh(double x) {
-  return __builtin_acosh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_asinh(double x) {
-  return __builtin_asinh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_atanh(double x) {
-  return __builtin_atanh(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_exp10(double x) {
-#if defined __APPLE__
-  extern double __exp10(double);
-  return __exp10(x);
-#else
-  return __builtin_pow(10, x);
-#endif
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_expm1(double x) {
-  return __builtin_expm1(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_log1p(double x) {
-  return __builtin_log1p(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_hypot(double x, double y) {
-  return __builtin_hypot(x, y);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_erf(double x) {
-  return __builtin_erf(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_erfc(double x) {
-  return __builtin_erfc(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_tgamma(double x) {
-  return __builtin_tgamma(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-double _swift_stdlib_lgamma(double x) {
-  extern double lgamma_r(double x, int *psigngam);
-  int dontCare;
-  return lgamma_r(x, &dontCare);
-}
-
 #if !defined _WIN32 && (defined __i386__ || defined __x86_64__)
 static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_remainderl(long double _self, long double other) {
-  return __builtin_remainderl(_self, other);
+long double _stdlib_remainderl(long double _self, long double _other) {
+  return __builtin_remainderl(_self, _other);
 }
-
+  
 static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_squareRootl(long double _self) {
+long double _stdlib_squareRootl(long double _self) {
  return __builtin_sqrtl(_self);
 }
-
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_tanl(long double x) {
-  return __builtin_tanl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_acosl(long double x) {
-  return __builtin_acosl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_asinl(long double x) {
-  return __builtin_asinl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_atanl(long double x) {
-  return __builtin_atanl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_atan2l(long double y, long double x) {
-  return __builtin_atan2l(y, x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_coshl(long double x) {
-  return __builtin_coshl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_sinhl(long double x) {
-  return __builtin_sinhl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_tanhl(long double x) {
-  return __builtin_tanhl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_acoshl(long double x) {
-  return __builtin_acoshl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_asinhl(long double x) {
-  return __builtin_asinhl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_atanhl(long double x) {
-  return __builtin_atanhl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_exp10l(long double x) {
-  return __builtin_powl(10, x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_expm1l(long double x) {
-  return __builtin_expm1l(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_log1pl(long double x) {
-  return __builtin_log1pl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_hypotl(long double x, long double y) {
-  return __builtin_hypotl(x, y);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_erfl(long double x) {
-  return __builtin_erfl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_erfcl(long double x) {
-  return __builtin_erfcl(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_tgammal(long double x) {
-  return __builtin_tgammal(x);
-}
-  
-static inline SWIFT_ALWAYS_INLINE
-long double _swift_stdlib_lgammal(long double x) {
-  extern long double lgammal_r(long double x, int *psigngam);
-  int dontCare;
-  return lgammal_r(x, &dontCare);
-}
 #endif

+// Apple's math.h does not declare lgamma_r() etc by default, but they're
+// unconditionally exported by libsystem_m.dylib in all OS versions that
+// support Swift development; we simply need to provide declarations here.
+#if defined(__APPLE__)
+float lgammaf_r(float x, int *psigngam);
+double lgamma_r(double x, int *psigngam);
+long double lgammal_r(long double x, int *psigngam);
+#endif // defined(__APPLE__)
+
 #ifdef __cplusplus
 }} // extern "C", namespace swift
 #endif
--- a/stdlib/public/core/BuiltinMath.swift.gyb
+++ b/stdlib/public/core/BuiltinMath.swift.gyb
@@ -0,0 +1,78 @@
+//===--- BuiltinMath.swift.gyb --------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+%{
+
+# Don't need 64-bit (Double/CDouble) overlays. The ordinary C imports work fine.
+overlayFloatBits = [32, 80]
+allFloatBits = [32, 64, 80]
+
+def floatName(bits):
+    if bits == 32:
+        return 'Float'
+    if bits == 64:
+        return 'Double'
+    if bits == 80:
+        return 'Float80'
+
+def cFloatName(bits):
+    if bits == 32:
+        return 'CFloat'
+    if bits == 64:
+        return 'CDouble'
+    if bits == 80:
+        return 'CLongDouble'
+
+def cFuncSuffix(bits):
+    if bits == 32:
+        return 'f'
+    if bits == 64:
+        return ''
+    if bits == 80:
+        return 'l'
+
+# Each of the following lists is ordered to match math.h
+
+# These functions have a corresponding LLVM intrinsic
+# Note, keep this up to date with Darwin/tgmath.swift.gyb
+UnaryIntrinsicFunctions = [
+    'cos', 'sin',
+    'exp', 'exp2',
+    'log', 'log10', 'log2',
+    'nearbyint', 'rint',
+]
+
+def TypedUnaryIntrinsicFunctions():
+    for ufunc in UnaryIntrinsicFunctions:
+        for bits in allFloatBits:
+            yield floatName(bits), cFloatName(bits), bits, ufunc
+
+}%
+
+// Unary intrinsic functions
+// Note these have a corresponding LLVM intrinsic
+% for T, CT, bits, ufunc in TypedUnaryIntrinsicFunctions():
+%  if bits == 80:
+#if !os(Windows) && (arch(i386) || arch(x86_64))
+%  end
+@_transparent
+public func _${ufunc}(_ x: ${T}) -> ${T} {
+  return ${T}(Builtin.int_${ufunc}_FPIEEE${bits}(x._value))
+}
+%  if bits == 80:
+#endif
+%  end
+% end
+
+// ${'Local Variables'}:
+// eval: (read-only-mode 1)
+// End:
--- a/stdlib/public/core/CMakeLists.txt
+++ b/stdlib/public/core/CMakeLists.txt
@@ -184,6 +184,7 @@ set(SWIFTLIB_ESSENTIAL

 set(SWIFTLIB_ESSENTIAL_GYB_SOURCES
  AtomicInt.swift.gyb
+  BuiltinMath.swift.gyb
  Codable.swift.gyb
  FixedArray.swift.gyb
  FloatingPointParsing.swift.gyb
@@ -217,11 +218,10 @@ set(SWIFTLIB_SOURCES
  )

 set(SWIFTLIB_GYB_SOURCES
-  ${SWIFTLIB_ESSENTIAL_GYB_SOURCES}
-  ExistentialCollection.swift.gyb
-  MathFunctions.swift.gyb
-  SIMDVectorTypes.swift.gyb
-  Tuple.swift.gyb
+    ${SWIFTLIB_ESSENTIAL_GYB_SOURCES}
+    ExistentialCollection.swift.gyb
+    SIMDVectorTypes.swift.gyb
+    Tuple.swift.gyb
  )
 set(GROUP_INFO_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/GroupInfo.json)
 set(swift_core_link_flags "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}")
--- a/stdlib/public/core/FloatingPoint.swift
+++ b/stdlib/public/core/FloatingPoint.swift
@@ -1898,6 +1898,10 @@ extension FloatingPoint {
  ///   other is NaN.
  @inlinable
  public static func minimum(_ x: Self, _ y: Self) -> Self {
+    if x.isSignalingNaN || y.isSignalingNaN {
+      //  Produce a quiet NaN matching platform arithmetic behavior.
+      return x + y
+    }
    if x <= y || y.isNaN { return x }
    return y
  }
@@ -1931,6 +1935,10 @@ extension FloatingPoint {
  ///   other is NaN.
  @inlinable
  public static func maximum(_ x: Self, _ y: Self) -> Self {
+    if x.isSignalingNaN || y.isSignalingNaN {
+      //  Produce a quiet NaN matching platform arithmetic behavior.
+      return x + y
+    }
    if x > y || y.isNaN { return x }
    return y
  }
@@ -1966,6 +1974,10 @@ extension FloatingPoint {
  ///   a number if the other is NaN.
  @inlinable
  public static func minimumMagnitude(_ x: Self, _ y: Self) -> Self {
+    if x.isSignalingNaN || y.isSignalingNaN {
+      //  Produce a quiet NaN matching platform arithmetic behavior.
+      return x + y
+    }
    if x.magnitude <= y.magnitude || y.isNaN { return x }
    return y
  }
@@ -2001,6 +2013,10 @@ extension FloatingPoint {
  ///   a number if the other is NaN.
  @inlinable
  public static func maximumMagnitude(_ x: Self, _ y: Self) -> Self {
+    if x.isSignalingNaN || y.isSignalingNaN {
+      //  Produce a quiet NaN matching platform arithmetic behavior.
+      return x + y
+    }
    if x.magnitude > y.magnitude || y.isNaN { return x }
    return y
  }
--- a/stdlib/public/core/FloatingPointTypes.swift.gyb
+++ b/stdlib/public/core/FloatingPointTypes.swift.gyb
@@ -1115,7 +1115,7 @@ extension ${Self}: BinaryFloatingPoint {
  @inlinable // FIXME(inline-always)
  @inline(__always)
  public mutating func formRemainder(dividingBy other: ${Self}) {
-    self = _swift_stdlib_remainder${cFuncSuffix}(self, other)
+    self = _stdlib_remainder${cFuncSuffix}(self, other)
  }

  /// Replaces this value with the remainder of itself divided by the given
@@ -1157,7 +1157,7 @@ extension ${Self}: BinaryFloatingPoint {
  /// value.
  @_transparent
  public mutating func formSquareRoot( ) {
-    self = _swift_stdlib_squareRoot${cFuncSuffix}(self)
+    self = _stdlib_squareRoot${cFuncSuffix}(self)
  }

  /// Adds the product of the two given values to this value in place, computed
--- a/stdlib/public/core/GroupInfo.json
+++ b/stdlib/public/core/GroupInfo.json
@@ -158,7 +158,7 @@
  ],
  "Math": [
    "SetAlgebra.swift",
-    "MathFunctions.swift",
+    "BuiltinMath.swift",
    {
    "Integers": [
      "Integers.swift",
--- a/stdlib/public/core/MathFunctions.swift.gyb
+++ b/stdlib/public/core/MathFunctions.swift.gyb
@@ -1,329 +0,0 @@
-//===--- MathFunctions.swift ----------------------------------*- swift -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2019 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-
-import SwiftShims
-%from SwiftMathFunctions import *
-%from SwiftFloatingPointTypes import all_floating_point_types
-
-/// A type that has elementary functions available.
-///
-/// An ["elementary function"][elfn] is a function built up from powers, roots,
-/// exponentials, logarithms, trigonometric functions (sin, cos, tan) and
-/// their inverses, and the hyperbolic functions (sinh, cosh, tanh) and their
-/// inverses.
-///
-/// Conformance to this protocol means that all of these building blocks are
-/// available as static functions on the type.
-///
-/// ```swift
-/// let x: Float = 1
-/// let y = Float.sin(x) // 0.84147096
-/// ```
-///
-/// All of these are made available as free functions by importing the Math
-/// module:
-///
-/// ```swift
-/// import Math
-/// let y = sin(x) // 0.84147096
-/// ```
-///
-/// Additional operations, such as `atan2(y:x:)`, `hypot(_:_:)` and some
-/// special functions, are provided on the Real protocol, which refines both
-/// ElementaryFunctions and FloatingPoint.
-///
-/// [elfn]: http://en.wikipedia.org/wiki/Elementary_function
-public protocol ElementaryFunctions {
-
-%for func in ElementaryFunctions:
-
-  ${func.comment}
-  static func ${func.decl("Self")}
-%end
-
-  /// `exp(y log(x))` computed without loss of intermediate precision.
-  ///
-  /// For real types, if `x` is negative the result is NaN, even if `y` has
-  /// an integral value. For complex types, there is a branch cut on the
-  /// negative real axis.
-  static func pow(_ x: Self, _ y: Self) -> Self
-
-  /// `x` raised to the `n`th power.
-  static func pow(_ x: Self, _ n: Int) -> Self
-
-  /// The `n`th root of `x`.
-  ///
-  /// For real types, if `x` is negative and `n` is even, the result is NaN.
-  /// For complex types, there is a branch cut along the negative real axis.
-  static func root(_ x: Self, _ n: Int) -> Self
-}
-
-/// A type that models the real numbers.
-public protocol Real: ElementaryFunctions, FloatingPoint {
-%for func in RealFunctions:
-
-  ${func.comment}
-  static func ${func.decl("Self")}
-%end
-
-  /// `atan(y/x)` with quadrant fixup.
-  ///
-  /// There is an infinite family of angles whose tangent is `y/x`. `atan2`
-  /// selects the representative that is the angle between the vector `(x, y)`
-  /// and the real axis in the range [-π, π].
-  static func atan2(y: Self, x: Self) -> Self
-
-#if !os(Windows)
-  //  lgamma is not available on Windows.
-  //  TODO: provide an implementation of lgamma with the stdlib to support
-  //  Windows so we can vend a uniform interface.
-
-  /// `log(gamma(x))` computed without undue overflow.
-  ///
-  /// `log(abs(gamma(x)))` is returned. To get the sign of `gamma(x)` cheaply,
-  /// use `signGamma(x)`.
-  static func logGamma(_ x: Self) -> Self
-#endif
-}
-
-extension Real {
-#if !os(Windows)
-  //  lgamma is not available on Windows; no lgamma means signGamma
-  //  is basically useless, so don't bother exposing it.
-
-  /// The sign of `gamma(x)`.
-  ///
-  /// This function is typically used in conjunction with `logGamma(x)`, which
-  /// computes `log(abs(gamma(x)))`, to recover the sign information that is
-  /// lost to the absolute value.
-  ///
-  /// `gamma(x)` has a simple pole at each non-positive integer and an
-  /// essential singularity at infinity; we arbitrarily choose to return
-  /// `.plus` for the sign in those cases. For all other values, `signGamma(x)`
-  /// is `.plus` if `x >= 0` or `trunc(x)` is odd, and `.minus` otherwise.
-  @_alwaysEmitIntoClient
-  public static func signGamma(_ x: Self) -> FloatingPointSign {
-    if x >= 0 { return .plus }
-    let trunc = x.rounded(.towardZero)
-    // Treat poles as gamma(x) == +inf. This is arbitrary, but we need to
-    // pick one sign or the other.
-    if x == trunc { return .plus }
-    // Result is .minus if trunc is even, .plus otherwise. To figure out if
-    // trunc is even or odd, check if trunc/2 is an integer.
-    let halfTrunc = trunc/2
-    if halfTrunc == halfTrunc.rounded(.towardZero) { return .minus }
-    return .plus
-  }
-#endif
-}
-
-%for type in all_floating_point_types():
-% if type.bits == 80:
-#if (arch(i386) || arch(x86_64)) && !os(Windows)
-% end
-% Self = type.stdlib_name
-extension ${Self}: Real {
-% for func in ElementaryFunctions + RealFunctions:
-
-  @_alwaysEmitIntoClient
-  public static func ${func.decl(Self)} {
-    return ${func.impl(type)}
-  }
-% end
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: ${Self}, _ y: ${Self}) -> ${Self} {
-    guard x >= 0 else { return .nan }
-    return ${Self}(Builtin.int_pow_FPIEEE${type.bits}(x._value, y._value))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: ${Self}, _ n: Int) -> ${Self} {
-    // TODO: this implementation isn't quite right for n so large that
-    // the conversion to `${Self}` rounds. We could also consider using
-    // a multiply-chain implementation for small `n`; this would be faster
-    // for static `n`, but less accurate on platforms with a good `pow`
-    // implementation.
-    return ${Self}(Builtin.int_pow_FPIEEE${type.bits}(x._value, ${Self}(n)._value))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func root(_ x: ${Self}, _ n: Int) -> ${Self} {
-    guard x >= 0 || n % 2 != 0 else { return .nan }
-    // TODO: this implementation isn't quite right for n so large that
-    // the conversion to `${Self}` rounds.
-    return ${Self}(signOf: x, magnitudeOf: pow(x, 1/${Self}(n)))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func atan2(y: ${Self}, x: ${Self}) -> ${Self} {
-    return _swift_stdlib_atan2${type.cFuncSuffix}(y, x)
-  }
-
-#if !os(Windows)
-  @_alwaysEmitIntoClient
-  public static func logGamma(_ x: ${Self}) -> ${Self} {
-    return _swift_stdlib_lgamma${type.cFuncSuffix}(x)
-  }
-#endif
-}
-% if type.bits == 80:
-#endif
-% end
-%end
-
-// MARK: - Free functions defined on ElementaryFunctions:
-%from SwiftMathFunctions import *
-%for func in ElementaryFunctions:
-
-% if func.name == 'sqrt':
-// sqrt requires availability because it was previous generic on FloatingPoint.
-@available(swift, introduced: 5.1)
-% end
-@_alwaysEmitIntoClient
-public func ${func.free_decl()} {
-  return T.${func.swiftName}(${func.params()})
-}
-
-@_alwaysEmitIntoClient
-public func ${func.free_decl("T: SIMD, T.Scalar: ElementaryFunctions")} {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.${func.swiftName}(${func.params("","[i]")}) }
-  return r
-}
-%end
-
-@_alwaysEmitIntoClient
-public func pow<T>(_ x: T, _ y: T) -> T where T: ElementaryFunctions {
-  return T.pow(x, y)
-}
-
-@_alwaysEmitIntoClient
-public func pow<T>(_ x: T, _ y: T) -> T where T: SIMD, T.Scalar: ElementaryFunctions {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.pow(x[i], y[i]) }
-  return r
-}
-
-@_alwaysEmitIntoClient
-public func pow<T>(_ x: T, _ n: Int) -> T where T: ElementaryFunctions {
-  return T.pow(x, n)
-}
-
-@_alwaysEmitIntoClient
-public func pow<T>(_ x: T, _ n: Int) -> T where T: SIMD, T.Scalar: ElementaryFunctions {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.pow(x[i], n) }
-  return r
-}
-
-@_alwaysEmitIntoClient
-public func root<T>(_ x: T, _ n: Int) -> T where T: ElementaryFunctions {
-  return T.root(x, n)
-}
-
-@_alwaysEmitIntoClient
-public func root<T>(_ x: T, _ n: Int) -> T where T: SIMD, T.Scalar: ElementaryFunctions {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.root(x[i], n) }
-  return r
-}
-
-// MARK: - Free functions defined on Real:
-%for func in RealFunctions:
-
-@_alwaysEmitIntoClient
-public func ${func.free_decl("T: Real")} {
-  return T.${func.swiftName}(${func.params()})
-}
-
-@_alwaysEmitIntoClient
-public func ${func.free_decl("T: SIMD, T.Scalar: Real")} {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.${func.swiftName}(${func.params("","[i]")}) }
-  return r
-}
-%end
-
-@_alwaysEmitIntoClient
-public func atan2<T>(y: T, x: T) -> T where T: Real {
-  return T.atan2(y: y, x: x)
-}
-
-@_alwaysEmitIntoClient
-public func atan2<T>(y: T, x: T) -> T where T: SIMD, T.Scalar: Real {
-  var r = T()
-  for i in r.indices { r[i] = T.Scalar.atan2(y: y[i], x: x[i]) }
-  return r
-}
-
-//  logGamma is not available on Windows.
-//  TODO: logGamma, signGamma for SIMD types.
-#if !os(Windows)
-@_alwaysEmitIntoClient
-public func logGamma<T>(_ x: T) -> T where T: Real {
-  return T.logGamma(x)
-}
-
-@_alwaysEmitIntoClient
-public func signGamma<T>(_ x: T) -> FloatingPointSign where T: Real {
-  return T.signGamma(x)
-}
-#endif
-
-// MARK: - Free functions defined on FloatingPoint:
-% for (func,dir) in [("ceil", ".up"), ("floor", ".down"), ("round", ""), ("trunc", ".towardZero")]:
-
-@_alwaysEmitIntoClient
-public func ${func}<T>(_ x: T) -> T where T: FloatingPoint {
-  return x.rounded(${dir})
-}
-
-@_alwaysEmitIntoClient
-public func ${func}<T>(_ x: T) -> T where T: SIMD, T.Scalar: FloatingPoint {
-  return x.rounded(${dir})
-}
-%end
-
-@_alwaysEmitIntoClient
-public func fma<T>(_ x: T, _ y: T, _ z: T) -> T where T: FloatingPoint {
-  return z.addingProduct(x, y)
-}
-
-@_alwaysEmitIntoClient
-public func fma<T>(_ x: T, _ y: T, _ z: T) -> T where T: SIMD, T.Scalar: FloatingPoint {
-  return z.addingProduct(x, y)
-}
-
-@_alwaysEmitIntoClient
-public func remainder<T>(_ dividend: T, _ divisor: T) -> T where T: FloatingPoint {
-  return dividend.remainder(dividingBy: divisor)
-}
-
-@_alwaysEmitIntoClient
-public func remainder<T>(_ dividend: T, _ divisor: T) -> T where T: SIMD, T.Scalar: FloatingPoint {
-  var r = T()
-  for i in r.indices { r[i] = dividend[i].remainder(dividingBy: divisor[i]) }
-  return r
-}
-
-@_alwaysEmitIntoClient
-public func copysign<T>(_ magnitude: T, _ sign: T) -> T where T: FloatingPoint {
-  return T(signOf: sign, magnitudeOf: magnitude)
-}
-
-@_alwaysEmitIntoClient
-public func copysign<T>(_ magnitude: T, _ sign: T) -> T where T: SIMD, T.Scalar: FloatingPoint {
-  var r = T()
-  for i in r.indices { r[i] = copysign(magnitude[i], sign[i]) }
-  return r
-}
--- a/stdlib/public/core/SIMDVector.swift
+++ b/stdlib/public/core/SIMDVector.swift
@@ -652,7 +652,7 @@ extension SIMD where Scalar : FloatingPoint {
  }
  
  @_transparent
-  public func rounded(_ rule: FloatingPointRoundingRule = .toNearestOrEven) -> Self {
+  public func rounded(_ rule: FloatingPointRoundingRule) -> Self {
    var result = Self()
    for i in result.indices { result[i] = self[i].rounded(rule) }
    return result
--- a/test/IDE/complete_repl_identifier_prefix_1.swift
+++ b/test/IDE/complete_repl_identifier_prefix_1.swift
@@ -2,8 +2,6 @@

 // CHECK: Begin completions
 // CHECK-NEXT: {{^}}true: Bool{{$}}
-// CHECK-NEXT: {{^}}trunc(x: FloatingPoint) -> FloatingPoint
-// CHECK-NEXT: {{^}}trunc(x: SIMD) -> SIMD
 // CHECK-NEXT: End completions

 tru
--- a/test/IRGen/builtin_math.swift
+++ b/test/IRGen/builtin_math.swift
@@ -13,7 +13,13 @@
 // Make sure we use an intrinsic for functions such as exp.

 // CHECK-LABEL: define {{.*}}test1
-// CHECK: call float @llvm.exp.f32
+// CHECK-ios: call float @llvm.exp.f32
+// CHECK-macosx: call float @llvm.exp.f32
+// CHECK-tvos: call float @llvm.exp.f32
+// CHECK-watchos: call float @llvm.exp.f32
+// CHECK-darwin: call float @llvm.exp.f32
+// CHECK-linux-gnu: call float @expf
+// CHECK-windows: call float @expf

 public func test1(f : Float) -> Float {
  return exp(f)
@@ -23,7 +29,7 @@ public func test1(f : Float) -> Float {
 // CHECK: call double @llvm.exp.f64

 public func test2(f : Double) -> Double {
-  return exp(f)
+  return _exp(f)
 }

 // CHECK-LABEL: define {{.*}}test3
--- a/test/Parse/recovery.swift
+++ b/test/Parse/recovery.swift
@@ -33,7 +33,8 @@ func useContainer() -> () {
  func exists() -> Bool { return true }
 }

-// expected-note @+1 {{did you mean 'test'?}}
+// expected-note @+2 {{did you mean 'test'?}}
+// expected-note @+1 {{'test' declared here}}
 func test(a: BadAttributes) -> () {
  _ = a.exists() // no-warning
 }
@@ -618,7 +619,7 @@ func foo1(bar!=baz) {} // expected-note {{did you mean 'foo1'?}}
 func foo2(bar! = baz) {}// expected-note {{did you mean 'foo2'?}}

 // rdar://19605567
-// expected-error@+1{{use of unresolved identifier 'esp'; did you mean 'exp'?}}
+// expected-error@+1{{use of unresolved identifier 'esp'; did you mean 'test'?}}
 switch esp {
 case let (jeb):
  // expected-error@+5{{top-level statement cannot begin with a closure expression}}
--- a/test/SourceKit/Sema/sema_symlink.swift.response
+++ b/test/SourceKit/Sema/sema_symlink.swift.response
@@ -12,7 +12,7 @@
    key.column: 16,
    key.filepath: real.swift,
    key.severity: source.diagnostic.severity.error,
-    key.description: "use of unresolved identifier 'goo'",
+    key.description: "use of unresolved identifier 'goo'; did you mean 'Bool'?",
    key.diagnostic_stage: source.diagnostic.stage.swift.sema,
    key.ranges: [
      {
@@ -20,27 +20,20 @@
        key.length: 3
      }
    ],
+    key.fixits: [
+      {
+        key.offset: 15,
+        key.length: 3,
+        key.sourcetext: "Bool"
+      }
+    ],
    key.diagnostics: [
      {
        key.line: 1,
        key.column: 16,
        key.filepath: real.swift,
        key.severity: source.diagnostic.severity.note,
-        key.description: "did you mean 'root'? (Swift.root)"
-      },
-      {
-        key.line: 1,
-        key.column: 16,
-        key.filepath: real.swift,
-        key.severity: source.diagnostic.severity.note,
-        key.description: "did you mean 'root'? (Swift.root)"
-      },
-      {
-        key.line: 1,
-        key.column: 16,
-        key.filepath: real.swift,
-        key.severity: source.diagnostic.severity.note,
-        key.description: "did you mean 'Bool'? (Swift.Bool)"
+        key.description: "'Bool' declared here (Swift.Bool)"
      }
    ]
  }
--- a/test/api-digester/Outputs/stability-stdlib-abi.swift.expected
+++ b/test/api-digester/Outputs/stability-stdlib-abi.swift.expected
@@ -1,51 +1 @@
-Func _cos(_:) has been removed
-Func _cos(_:) has been renamed to Func cos(_:)
-Func _cos(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _cos(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _cos(_:) has parameter 0 type change from Double to τ_0_0
-Func _cos(_:) has parameter 0 type change from Float to τ_0_0
-Func _cos(_:) has return type change from Double to τ_0_0
-Func _cos(_:) has return type change from Float to τ_0_0
-Func _exp(_:) has been removed
-Func _exp(_:) has been renamed to Func exp(_:)
-Func _exp(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _exp(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _exp(_:) has parameter 0 type change from Double to τ_0_0
-Func _exp(_:) has parameter 0 type change from Float to τ_0_0
-Func _exp(_:) has return type change from Double to τ_0_0
-Func _exp(_:) has return type change from Float to τ_0_0
-Func _exp2(_:) has been removed
-Func _exp2(_:) has been renamed to Func exp2(_:)
-Func _exp2(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _exp2(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _exp2(_:) has parameter 0 type change from Double to τ_0_0
-Func _exp2(_:) has parameter 0 type change from Float to τ_0_0
-Func _exp2(_:) has return type change from Double to τ_0_0
-Func _exp2(_:) has return type change from Float to τ_0_0
-Func _log(_:) has been removed
-Func _log10(_:) has been removed
-Func _log10(_:) has been renamed to Func log10(_:)
-Func _log10(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _log10(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _log10(_:) has parameter 0 type change from Double to τ_0_0
-Func _log10(_:) has parameter 0 type change from Float to τ_0_0
-Func _log10(_:) has return type change from Double to τ_0_0
-Func _log10(_:) has return type change from Float to τ_0_0
-Func _log2(_:) has been removed
-Func _log2(_:) has been renamed to Func log2(_:)
-Func _log2(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _log2(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _log2(_:) has parameter 0 type change from Double to τ_0_0
-Func _log2(_:) has parameter 0 type change from Float to τ_0_0
-Func _log2(_:) has return type change from Double to τ_0_0
-Func _log2(_:) has return type change from Float to τ_0_0
-Func _nearbyint(_:) has been removed
-Func _rint(_:) has been removed
-Func _sin(_:) has been removed
-Func _sin(_:) has been renamed to Func sin(_:)
-Func _sin(_:) has generic signature change from to <τ_0_0 where τ_0_0 : ElementaryFunctions>
-Func _sin(_:) has generic signature change from to <τ_0_0 where τ_0_0 : SIMD, τ_0_0.Scalar : ElementaryFunctions>
-Func _sin(_:) has parameter 0 type change from Double to τ_0_0
-Func _sin(_:) has parameter 0 type change from Float to τ_0_0
-Func _sin(_:) has return type change from Double to τ_0_0
-Func _sin(_:) has return type change from Float to τ_0_0
+
--- a/test/stdlib/MathFunctions.swift.gyb
+++ b/test/stdlib/MathFunctions.swift.gyb
@@ -1,168 +0,0 @@
-//===--- Math.swift.gyb ---------------------------------------*- swift -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-// -*- swift -*-
-// RUN: %empty-directory(%t)
-// RUN: %gyb %s -o %t/tgmath.swift
-// RUN: %line-directive %t/tgmath.swift -- %target-build-swift %t/tgmath.swift -o %t/a.out
-// RUN: %target-codesign %t/a.out
-// RUN: %line-directive %t/tgmath.swift -- %target-run %t/a.out
-// REQUIRES: executable_test
-
-#if (arch(i386) || arch(x86_64)) && !os(Windows)
-  typealias TestLiteralType = Float80
-#else
-  typealias TestLiteralType = Double
-#endif
-
-import StdlibUnittest
-
-let MathTests = TestSuite("Math")
-
-func expectEqualWithTolerance<T>(_ expected: TestLiteralType, _ actual: T,
-                                 ulps allowed: T = 3,
-                                 file: String = #file, line: UInt = #line)
-                                 where T: BinaryFloatingPoint {
-  if actual == T(expected) || actual.isNaN && expected.isNaN {
-    return
-  }
-  //  Compute error in ulp, compare to tolerance.
-  let absoluteError = T(abs(TestLiteralType(actual) - expected))
-  let ulpError = absoluteError / T(expected).ulp
-  expectTrue(ulpError <= allowed,
-             "\(actual) != \(expected) as \(T.self)" +
-             "\n  \(ulpError)-ulp error exceeds \(allowed)-ulp tolerance.",
-             file: file, line: line)
-}
-
-%from SwiftMathFunctions import *
-
-internal extension ElementaryFunctions where Self: BinaryFloatingPoint {
-  static func elementaryFunctionTests() {
-    /* Default tolerance is 3 ulps unless specified otherwise. It's OK to relax
-     * this as needed for new platforms, as these tests are *not* intended to
-     * validate the math library--they are only intended to check that the
-     * Swift bindings are calling the right functions in the math library.    */
-    expectEqualWithTolerance(1.1863995522992575361931268186727044683, Self.acos(0.375))
-    expectEqualWithTolerance(0.3843967744956390830381948729670469737, Self.asin(0.375))
-    expectEqualWithTolerance(0.3587706702705722203959200639264604997, Self.atan(0.375))
-    expectEqualWithTolerance(0.9305076219123142911494767922295555080, Self.cos(0.375))
-    expectEqualWithTolerance(0.3662725290860475613729093517162641571, Self.sin(0.375))
-    expectEqualWithTolerance(0.3936265759256327582294137871012180981, Self.tan(0.375))
-    expectEqualWithTolerance(0.4949329230945269058895630995767185785, Self.acosh(1.125))
-    expectEqualWithTolerance(0.9670596312833237113713762009167286709, Self.asinh(1.125))
-    expectEqualWithTolerance(0.7331685343967135223291211023213964500, Self.atanh(0.625))
-    expectEqualWithTolerance(1.0711403467045867672994980155670160493, Self.cosh(0.375))
-    expectEqualWithTolerance(0.3838510679136145687542956764205024589, Self.sinh(0.375))
-    expectEqualWithTolerance(0.3583573983507859463193602315531580424, Self.tanh(0.375))
-    expectEqualWithTolerance(1.4549914146182013360537936919875185083, Self.exp(0.375))
-    expectEqualWithTolerance(1.2968395546510096659337541177924511598, Self.exp2(0.375))
-    expectEqualWithTolerance(2.3713737056616552616517527574788898386, Self.exp10(0.375))
-    expectEqualWithTolerance(0.4549914146182013360537936919875185083, Self.expm1(0.375))
-    expectEqualWithTolerance(-0.980829253011726236856451127452003999, Self.log(0.375))
-    expectEqualWithTolerance(-1.415037499278843818546261056052183491, Self.log2(0.375))
-    expectEqualWithTolerance(0.3184537311185346158102472135905995955, Self.log1p(0.375))
-    expectEqualWithTolerance(-0.425968732272281148346188780918363771, Self.log10(0.375))
-    expectEqualWithTolerance(0.7211247851537041911608191553900547941, Self.root(0.375, 3))
-    expectEqualWithTolerance(0.6123724356957945245493210186764728479, Self.sqrt(0.375))
-    expectEqualWithTolerance(0.54171335479545025876069682133938570, Self.pow(0.375, 0.625))
-    expectEqualWithTolerance(-0.052734375, Self.pow(-0.375, 3))
-
-    expectEqual(Self.acos(0.375), acos(0.375))
-    expectEqual(Self.asin(0.375), asin(0.375))
-    expectEqual(Self.atan(0.375), atan(0.375))
-    expectEqual(Self.cos(0.375), cos(0.375))
-    expectEqual(Self.sin(0.375), sin(0.375))
-    expectEqual(Self.tan(0.375), tan(0.375))
-    expectEqual(Self.acosh(1.125), acosh(1.125))
-    expectEqual(Self.asinh(1.125), asinh(1.125))
-    expectEqual(Self.atanh(0.625), atanh(0.625))
-    expectEqual(Self.cosh(0.375), cosh(0.375))
-    expectEqual(Self.sinh(0.375), sinh(0.375))
-    expectEqual(Self.tanh(0.375), tanh(0.375))
-    expectEqual(Self.exp(0.375), exp(0.375))
-    expectEqual(Self.exp2(0.375), exp2(0.375))
-    expectEqual(Self.exp10(0.375), exp10(0.375))
-    expectEqual(Self.expm1(0.375), expm1(0.375))
-    expectEqual(Self.log(0.375), log(0.375))
-    expectEqual(Self.log2(0.375), log2(0.375))
-    expectEqual(Self.log1p(0.375), log1p(0.375))
-    expectEqual(Self.log10(0.375), log10(0.375))
-    expectEqual(Self.sqrt(0.375), sqrt(0.375))
-    expectEqual(Self.pow(0.375, 0.625), pow(0.375, 0.625))
-    expectEqual(Self.root(0.375, 3), root(0.375, 3))
-    expectEqual(Self.pow(-0.375, 3), pow(-0.375, 3))
-  }
-}
-
-internal extension Real where Self: BinaryFloatingPoint {
-  static func realFunctionTests() {
-    expectEqualWithTolerance(0.54041950027058415544357836460859991, Self.atan2(y: 0.375, x: 0.625))
-    expectEqualWithTolerance(0.72886898685566255885926910969319788, Self.hypot(0.375, 0.625))
-    expectEqualWithTolerance(0.4041169094348222983238250859191217675, Self.erf(0.375))
-    expectEqualWithTolerance(0.5958830905651777016761749140808782324, Self.erfc(0.375))
-    expectEqualWithTolerance(2.3704361844166009086464735041766525098, Self.gamma(0.375))
-#if !os(Windows)
-    expectEqualWithTolerance( -0.11775527074107877445136203331798850, Self.logGamma(1.375), ulps: 16)
-    expectEqual(.plus,  Self.signGamma(1.375))
-    expectEqual(.minus, Self.signGamma(-2.375))
-#endif
-
-    expectEqual(Self.atan2(y: 0.375, x: 0.625), atan2(y: 0.375, x: 0.625))
-    expectEqual(Self.hypot(0.375, 0.625), hypot(0.375, 0.625))
-    expectEqual(Self.erf(0.375), erf(0.375))
-    expectEqual(Self.erfc(0.375), erfc(0.375))
-    expectEqual(Self.gamma(0.375), gamma(0.375))
-#if !os(Windows)
-    expectEqual(Self.logGamma(1.375), logGamma(1.375))
-    expectEqual(Self.signGamma(1.375), signGamma(1.375))
-    expectEqual(Self.signGamma(-2.375), signGamma(-2.375))
-#endif
-  }
-}
-
-internal extension BinaryFloatingPoint {
-  static func floatingPointFunctionTests() {
-    expectEqual(1 as Self, ceil(0.375))
-    expectEqual(0 as Self, floor(0.375))
-    expectEqual(0 as Self, Swift.round(0.375))
-    expectEqual(0 as Self, trunc(0.375))
-    expectEqual(0 as Self, ceil(-0.625))
-    expectEqual(-1 as Self, floor(-0.625))
-    expectEqual(-1 as Self, Swift.round(-0.625))
-    expectEqual(0 as Self, trunc(-0.625))
-    expectEqual(1 as Self, ceil(0.5))
-    expectEqual(0 as Self, floor(0.5))
-    expectEqual(1 as Self, Swift.round(0.5))
-    expectEqual(0 as Self, trunc(0.5))
-  }
-}
-
-%for T in ['Float', 'Double', 'CGFloat', 'Float80']:
-% if T == 'Float80':
-#if (arch(i386) || arch(x86_64)) && !os(Windows)
-% elif T == 'CGFloat':
-#if canImport(CoreGraphics)
-  import CoreGraphics
-% end
-
-MathTests.test("${T}") {
-  ${T}.elementaryFunctionTests()
-  ${T}.realFunctionTests()
-  ${T}.floatingPointFunctionTests()
-}
-
-% if T in ['CGFloat', 'Float80']:
-#endif
-% end
-%end
-
-runAllTests()
--- a/test/stdlib/tgmath.swift.gyb
+++ b/test/stdlib/tgmath.swift.gyb
@@ -18,7 +18,7 @@
 // REQUIRES: executable_test

 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-  import Darwin
+  import Darwin.C.tgmath
 #elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin) || os(Haiku)
  import Glibc
 #elseif os(Windows)
@@ -61,7 +61,7 @@ unary = [
  'cosh', 'sinh', 'tanh',
  'exp', 'exp2', 'expm1',
  'log', 'log2', 'log1p', 'log10', 'logb',
-  'fabs', 'cbrt',
+  'fabs', 'cbrt', 'sqrt',
  'erf', 'erfc',
  'tgamma',
  'ceil', 'floor', 'nearbyint', 'rint', 'trunc',
@@ -118,6 +118,7 @@ internal extension TGMath {
    expectEqual(-2, Self._logb(0.375))
    expectEqual(0.375, Self._fabs(-0.375))
    expectEqualWithTolerance(0.7211247851537041911608191553900547941, Self._cbrt(0.375))
+    expectEqualWithTolerance(0.6123724356957945245493210186764728479, Self._sqrt(0.375))
    expectEqualWithTolerance(0.4041169094348222983238250859191217675, Self._erf(0.375))
    expectEqualWithTolerance(0.5958830905651777016761749140808782324, Self._erfc(0.375))
    expectEqualWithTolerance(2.3704361844166009086464735041766525098, Self._tgamma(0.375))
@@ -180,49 +181,21 @@ internal extension TGMath {
 % end

 extension ${T}: TGMath {
-#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-% Module = 'CoreGraphics' if T == 'CGFloat' else 'Darwin'
 % for f in unary:
-  static func _${f}(_ x: ${T}) -> ${T} { return ${Module}.${f}(x) }
+  static func _${f}(_ x: ${T}) -> ${T} { return ${f}(x) }
 % end
 %for f in binary:
-  static func _${f}(_ x: ${T}, _ y: ${T}) -> ${T} { return ${Module}.${f}(x, y) }
+  static func _${f}(_ x: ${T}, _ y: ${T}) -> ${T} { return ${f}(x, y) }
 %end
-  static func _remquo(_ x: ${T}, _ y: ${T}) -> (${T}, Int) { return ${Module}.remquo(x, y) }
-  static func _fma(_ x: ${T}, _ y: ${T}, _ z: ${T}) -> ${T} { return ${Module}.fma(x, y, z) }
-  static func _lgamma(_ x: ${T}) -> (${T}, Int) { return ${Module}.lgamma(x) }
-  static func _modf(_ x: ${T}) -> (${T}, ${T}) { return ${Module}.modf(x) }
-  static func _scalbn(_ x: ${T}, _ n: Int) -> ${T} { return ${Module}.scalbn(x, n) }
-  static func _frexp(_ x: ${T}) -> (${T}, Int) { return ${Module}.frexp(x) }
-  static func _ilogb(_ x: ${T}) -> Int { return ${Module}.ilogb(x) }
-#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin) || os(Haiku)
-% for f in unary:
-  static func _${f}(_ x: ${T}) -> ${T} { return Glibc.${f}(x) }
-% end
-%for f in binary:
-  static func _${f}(_ x: ${T}, _ y: ${T}) -> ${T} { return Glibc.${f}(x, y) }
-%end
-  static func _remquo(_ x: ${T}, _ y: ${T}) -> (${T}, Int) { return Glibc.remquo(x, y) }
-  static func _fma(_ x: ${T}, _ y: ${T}, _ z: ${T}) -> ${T} { return Glibc.fma(x, y, z) }
-  static func _lgamma(_ x: ${T}) -> (${T}, Int) { return Glibc.lgamma(x) }
-  static func _modf(_ x: ${T}) -> (${T}, ${T}) { return Glibc.modf(x) }
-  static func _scalbn(_ x: ${T}, _ n: Int) -> ${T} { return Glibc.scalbn(x, n) }
-  static func _frexp(_ x: ${T}) -> (${T}, Int) { return Glibc.frexp(x) }
-  static func _ilogb(_ x: ${T}) -> Int { return Glibc.ilogb(x) }
-#elseif os(Windows)
-% for f in unary:
-  static func _${f}(_ x: ${T}) -> ${T} { return MSVCRT.${f}(x) }
-% end
-%for f in binary:
-  static func _${f}(_ x: ${T}, _ y: ${T}) -> ${T} { return MSVCRT.${f}(x, y) }
-%end
-  static func _remquo(_ x: ${T}, _ y: ${T}) -> (${T}, Int) { return MSVCRT.remquo(x, y) }
-  static func _fma(_ x: ${T}, _ y: ${T}, _ z: ${T}) -> ${T} { return MSVCRT.fma(x, y, z) }
-  static func _modf(_ x: ${T}) -> (${T}, ${T}) { return MSVCRT.modf(x) }
-  static func _scalbn(_ x: ${T}, _ n: Int) -> ${T} { return MSVCRT.scalbn(x, n) }
-  static func _frexp(_ x: ${T}) -> (${T}, Int) { return MSVCRT.frexp(x) }
-  static func _ilogb(_ x: ${T}) -> Int { return MSVCRT.ilogb(x) }
+  static func _remquo(_ x: ${T}, _ y: ${T}) -> (${T}, Int) { return remquo(x, y) }
+  static func _fma(_ x: ${T}, _ y: ${T}, _ z: ${T}) -> ${T} { return fma(x, y, z) }
+#if !os(Windows)
+  static func _lgamma(_ x: ${T}) -> (${T}, Int) { return lgamma(x) }
 #endif
+  static func _modf(_ x: ${T}) -> (${T}, ${T}) { return modf(x) }
+  static func _scalbn(_ x: ${T}, _ n: Int) -> ${T} { return scalbn(x, n) }
+  static func _frexp(_ x: ${T}) -> (${T}, Int) { return frexp(x) }
+  static func _ilogb(_ x: ${T}) -> Int { return ilogb(x) }
 }

 MathTests.test("${T}") {
--- a/utils/SwiftMathFunctions.py
+++ b/utils/SwiftMathFunctions.py
@@ -1,74 +0,0 @@
-class SwiftMathFunction(object):
-    def __init__(self, name, kind=None, swiftName=None, args="x", comment=None,
-                 platforms=None):
-        self.name = name
-        self.swiftName = swiftName if swiftName is not None else name
-        self.kind = kind if kind is not None else "library"
-        self.args = args
-        if comment is not None:
-            self.comment = comment
-        else:
-            self.comment = "/// The " + str(self.swiftName) + " function."
-        self.platforms = platforms
-
-    def params(self, prefix="", suffix=""):
-        return ", ".join(map(lambda a: prefix + a + suffix, self.args))
-
-    def decl(self, type):
-        return self.swiftName + "(" + self.params("_ ", ": " + type) + \
-            ") -> " + type
-
-    def free_decl(self, constraint="T: ElementaryFunctions"):
-        return self.swiftName + "<T>(" + self.params("_ ", ": T") + \
-            ") -> T where " + constraint
-
-    def impl(self, type):
-        if self.kind == "intrinsic":
-            builtin = "Builtin.int_" + self.name + "_FPIEEE" + str(type.bits)
-            return type.stdlib_name + "(" + builtin + "(" + \
-                self.params("", "._value") + "))"
-        return "_swift_stdlib_" + self.name + type.cFuncSuffix + "(" + \
-            self.params() + ")"
-
-
-ElementaryFunctions = [
-    SwiftMathFunction(name="sqrt", kind="intrinsic",
-                      comment="/// The square root of `x`."),
-    SwiftMathFunction(name="cos", kind="intrinsic",
-                      comment="/// The cosine of `x`."),
-    SwiftMathFunction(name="sin", kind="intrinsic",
-                      comment="/// The sine of `x`."),
-    SwiftMathFunction(name="tan",
-                      comment="/// The tangent of `x`."),
-    SwiftMathFunction(name="acos"),
-    SwiftMathFunction(name="asin"),
-    SwiftMathFunction(name="atan"),
-    SwiftMathFunction(name="cosh"),
-    SwiftMathFunction(name="sinh"),
-    SwiftMathFunction(name="tanh"),
-    SwiftMathFunction(name="acosh"),
-    SwiftMathFunction(name="asinh"),
-    SwiftMathFunction(name="atanh"),
-    SwiftMathFunction(name="exp", kind="intrinsic"),
-    SwiftMathFunction(name="exp2", kind="intrinsic"),
-    SwiftMathFunction(name="exp10"),
-    SwiftMathFunction(name="expm1"),
-    SwiftMathFunction(name="log", kind="intrinsic"),
-    SwiftMathFunction(name="log2", kind="intrinsic"),
-    SwiftMathFunction(name="log10", kind="intrinsic"),
-    SwiftMathFunction(name="log1p"),
-    # SwiftMathFunction(name="pow", kind="intrinsic", args="xy"), Handled
-    # separately for edge cases.
-    # SwiftMathFunction(name="root", args="xn"), Handled separately for
-    # implementation.
-]
-
-RealFunctions = [
-    # SwiftMathFunction(name="atan2"), Handled separately for explicit
-    # argument labels.
-    SwiftMathFunction(name="erf"),
-    SwiftMathFunction(name="erfc"),
-    SwiftMathFunction(name="hypot", args="xy"),
-    SwiftMathFunction(name="tgamma", swiftName="gamma"),
-    # SwiftMathFunction(name="lgamma"), Handled separately for sign result.
-]