First non-intrinsic functions.

Author: stephentyrone

stdlib/public/Maths/Maths.swift.gyb

@@ -42,7 +42,7 @@ public func fmod<T>(_ x: T, _ y: T) -> T where T: FloatingPoint {
 
 // MARK: - Free functions defined on Mathsable
 %from SwiftMathsFunctions import *
-%for func in MathFunctions:
+%for func in MathsFunctions:
 
 @_alwaysEmitIntoClient
 public func ${func.free_decl()} {

stdlib/public/SwiftShims/LibcShims.h

@@ -127,33 +127,108 @@ static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {
 
 // Math library functions
 static inline SWIFT_ALWAYS_INLINE
-float _stdlib_remainderf(float _self, float _other) {
+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_remainderf(float _self, float _other) {
   return __builtin_remainderf(_self, _other);
 }
 
 static inline SWIFT_ALWAYS_INLINE
-float _stdlib_squareRootf(float _self) {
+float _swift_stdlib_squareRootf(float _self) {
   return __builtin_sqrtf(_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 _stdlib_remainder(double _self, double _other) {
+double _swift_stdlib_remainder(double _self, double _other) {
   return __builtin_remainder(_self, _other);
 }
 
 static inline SWIFT_ALWAYS_INLINE
-double _stdlib_squareRoot(double _self) {
+double _swift_stdlib_squareRoot(double _self) {
   return __builtin_sqrt(_self);
 }
 
 #if !defined _WIN32 && (defined __i386__ || defined __x86_64__)
 static inline SWIFT_ALWAYS_INLINE
-long double _stdlib_remainderl(long double _self, long double _other) {
+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_remainderl(long double _self, long double _other) {
   return __builtin_remainderl(_self, _other);
 }
 
 static inline SWIFT_ALWAYS_INLINE
-long double _stdlib_squareRootl(long double _self) {
+long double _swift_stdlib_squareRootl(long double _self) {
   return __builtin_sqrtl(_self);
 }
 #endif

stdlib/public/core/BuiltinMath.swift.gyb

@@ -45,10 +45,7 @@ def cFuncSuffix(bits):
 # 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',
+  'nearbyint', 'rint',
 ]
 
 def TypedUnaryIntrinsicFunctions():

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 = _stdlib_remainder${cFuncSuffix}(self, other)
+    self = _swift_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 = _stdlib_squareRoot${cFuncSuffix}(self)
+    self = _swift_stdlib_squareRoot${cFuncSuffix}(self)
   }
 
   /// Adds the product of the two given values to this value in place, computed

stdlib/public/core/Mathsable.swift.gyb

@@ -10,55 +10,61 @@
 //
 //===----------------------------------------------------------------------===//
 
-//  We are omitting the following for now, which could also be defined on
-//  FloatingPoint, as it's not obvious that we want free function
-//  implementations:
-//
-//    fabs - use Swift.abs instead.
-//
-//    scalbn, frexp, ldexp, ilogb - we should provide a better technique
-//    for safely rescaling floating-point computations instead of these
-//    poorly named and easy to misuse functions.
+import SwiftShims
 
 %{
 from SwiftMathsFunctions import *
 }%
 
+/// A type that has basic maths functions available.
+///
+/// "Basic maths functions" means roughly "the usual transcendental
+/// functions provided by `<math.h>` in C-family langauges."
 public protocol Mathsable {
   associatedtype Maths: MathsImplementations where Maths.Value == Self
 }
 
+/// A type that provides the implementation trampolines for maths functions
+/// on the related `Value` type.
 public protocol MathsImplementations {
   associatedtype Value
-%for func in MathFunctions:
+%for func in MathsFunctions:
   static func ${func.decl("Value")}
 %end
 }
 
 %for type in all_floating_point_types():
+% if type.bits == 80:
+#if (arch(i386) || arch(x86_64)) && !os(Windows)
+% end
 extension ${type.stdlib_name}: Mathsable {
+  /// Defines basic maths functions for ${type.stdlib_name}
   @_frozen
   public enum Maths: MathsImplementations {
     public typealias Value = ${type.stdlib_name}
-% for func in MathFunctions:
+% for func in MathsFunctions:
     @_alwaysEmitIntoClient
     public static func ${func.decl("Value")} {
       return ${func.impl(type)}
     }
 % end
   }
 }
- 
+
+% if type.bits == 80:
+#endif
+% end
 %end
 
+/// Defines basic maths functions operating elementwise on SIMD vector types.
 @_fixed_layout
 public struct _SIMDMaths<V>: MathsImplementations
 where V: SIMD, V.Scalar: Mathsable {
 
   public typealias Value = V
-%for func in MathFunctions:
+%for func in MathsFunctions:
 
-  @inlinable
+  @_alwaysEmitIntoClient
   public static func ${func.decl("V")} {
     var r = V()
     for i in x.indices {

utils/SwiftMathsFunctions.py

@@ -1,10 +1,10 @@
 from SwiftFloatingPointTypes import all_floating_point_types
 
 class SwiftMathsFunction(object):
-  def __init__(self, name, cName=None, intrinsic=False, args="x"):
+  def __init__(self, name, kind=None, swiftName=None, args="x"):
     self.name = name
-    self.cName = cName if cName is not None else name
-    self.intrinsic = intrinsic
+    self.swiftName = swiftName if swiftName is not None else name
+    self.kind = kind if kind is not None else "library"
     self.args = args
 
   def params(self, prefix="", suffix=""):
@@ -13,25 +13,34 @@ def params(self, prefix="", suffix=""):
     )
 
   def decl(self, type):
-    return self.name + "(" + self.params("_ ", ": " + type) + ") -> " + type
+    return self.swiftName + "(" + self.params("_ ", ": " + type) + ") -> " + type
 
   def free_decl(self, protocol="Mathsable"):
-    return self.name + "<T>(" + self.params("_ ", ": T") + ") -> T where T: " + protocol
+    return self.swiftName + "<T>(" + self.params("_ ", ": T") + ") -> T where T: " + protocol
 
   def impl(self, type):
-    if self.intrinsic:
+    if self.kind == "intrinsic":
       builtin = "Builtin.int_" + self.name + "_FPIEEE" + str(type.bits)
       return type.stdlib_name + "(" + builtin + "(" + self.params("","._value") + "))"
-    return self.cName + type.cFuncSuffix + "(" + self.params() + ")"
+    if self.kind == "builtin":
+      builtin = "Builtin." + self.name + "_FPIEEE" + str(type.bits)
+      return type.stdlib_name + "(" + builtin + "(" + self.params("","._value") + "))"
+    return "_swift_stdlib_" + self.name + type.cFuncSuffix + "(" + self.params() + ")"
 
-MathFunctions = [
-  SwiftMathsFunction(name="cos", intrinsic=True),
-  SwiftMathsFunction(name="sin", intrinsic=True),
-  SwiftMathsFunction(name="exp", intrinsic=True),
-  SwiftMathsFunction(name="exp2", intrinsic=True),
-  SwiftMathsFunction(name="log", intrinsic=True),
-  SwiftMathsFunction(name="log10", intrinsic=True),
-  SwiftMathsFunction(name="log2", intrinsic=True),
+MathsFunctions = [
+  SwiftMathsFunction(name="cos", kind="intrinsic"),
+  SwiftMathsFunction(name="sin", kind="intrinsic"),
+  SwiftMathsFunction(name="tan"),
+  SwiftMathsFunction(name="acos"),
+  SwiftMathsFunction(name="asin"),
+  SwiftMathsFunction(name="atan"),
+  SwiftMathsFunction(name="atan2", args="yx"),
+  SwiftMathsFunction(name="exp", kind="intrinsic"),
+  SwiftMathsFunction(name="exp2", kind="intrinsic"),
+  SwiftMathsFunction(name="log", kind="intrinsic"),
+  SwiftMathsFunction(name="log10", kind="intrinsic"),
+  SwiftMathsFunction(name="log2", kind="intrinsic"),
+  SwiftMathsFunction(name="pow", kind="intrinsic", args="xy"),
 ]