Add Float16 to stdlib (#30130)

Add Float16 (IEEE 754 binary16) to the standard library, plus assorted runtime support operations.

Swift Evolution thread: https://forums.swift.org/t/se-0277-float16/33546

Author: stephentyrone

include/swift/ClangImporter/BuiltinMappedTypes.def

@@ -46,8 +46,10 @@ MAP_BUILTIN_INTEGER_TYPE(Int,       CInt)
 MAP_BUILTIN_INTEGER_TYPE(Long,      CLong)
 MAP_BUILTIN_INTEGER_TYPE(LongLong,  CLongLong)
 MAP_BUILTIN_INTEGER_TYPE(Int128,    CInt128)
-MAP_BUILTIN_TYPE(Float,     CFloat)
-MAP_BUILTIN_TYPE(Double,    CDouble)
+MAP_BUILTIN_TYPE(Float16,    CFloat16)
+MAP_BUILTIN_TYPE(Half,       CFloat16)
+MAP_BUILTIN_TYPE(Float,      CFloat)
+MAP_BUILTIN_TYPE(Double,     CDouble)
 MAP_BUILTIN_TYPE(LongDouble, CLongDouble)
 
 #undef MAP_BUILTIN_TYPE

lib/ClangImporter/ImportType.cpp

@@ -248,8 +248,6 @@ namespace {
       case clang::BuiltinType::SatUShortFract:
       case clang::BuiltinType::SatUFract:
       case clang::BuiltinType::SatULongFract:
-      case clang::BuiltinType::Half:
-      case clang::BuiltinType::Float16:
       case clang::BuiltinType::Float128:
       case clang::BuiltinType::NullPtr:
       case clang::BuiltinType::Char8:

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -995,14 +995,18 @@ struct IEEESemantics {
 
 IEEESemantics getFPSemantics(BuiltinFloatType *fpType) {
   switch (fpType->getFPKind()) {
+  case BuiltinFloatType::IEEE16:
+    return IEEESemantics(16, 5, 10, false);
   case BuiltinFloatType::IEEE32:
     return IEEESemantics(32, 8, 23, false);
   case BuiltinFloatType::IEEE64:
     return IEEESemantics(64, 11, 52, false);
   case BuiltinFloatType::IEEE80:
     return IEEESemantics(80, 15, 63, true);
-  default:
-    llvm_unreachable("Unexpected semantics");
+  case BuiltinFloatType::IEEE128:
+    return IEEESemantics(128, 15, 112, false);
+  case BuiltinFloatType::PPC128:
+    llvm_unreachable("ppc128 is not supported");
   }
 }
 

stdlib/public/SwiftShims/RuntimeShims.h

@@ -44,6 +44,11 @@ const char *_swift_stdlib_strtod_clocale(const char *nptr, double *outResult);
 /// overflow.
 SWIFT_RUNTIME_STDLIB_API
 const char *_swift_stdlib_strtof_clocale(const char *nptr, float *outResult);
+/// Call strtof_l with the C locale, swapping argument and return
+/// types so we can operate consistently on Float80.  Return NULL on
+/// overflow.
+SWIFT_RUNTIME_STDLIB_API
+const char *_swift_stdlib_strtof16_clocale(const char *nptr, __fp16 *outResult);
 
 SWIFT_RUNTIME_STDLIB_API
 void _swift_stdlib_immortalize(void *obj);

stdlib/public/core/CTypes.swift

@@ -56,6 +56,10 @@ public typealias CLong = Int
 /// The C 'long long' type.
 public typealias CLongLong = Int64
 
+/// The C '_Float16' type.
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+public typealias CFloat16 = Float16
+
 /// The C 'float' type.
 public typealias CFloat = Float
 

stdlib/public/core/Codable.swift

@@ -4592,6 +4592,38 @@ extension RawRepresentable where RawValue == Float, Self: Decodable {
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+extension Float16: Codable {
+  /// Creates a new instance by decoding from the given decoder.
+  ///
+  /// This initializer throws an error if reading from the decoder fails, or
+  /// if the data read is corrupted or otherwise invalid.
+  ///
+  /// - Parameter decoder: The decoder to read data from.
+  public init(from decoder: Decoder) throws {
+    let floatValue = try Float(from: decoder)
+    self = Float16(floatValue)
+    if isInfinite && floatValue.isFinite {
+      throw DecodingError.dataCorrupted(
+        DecodingError.Context(
+          codingPath: decoder.codingPath,
+          debugDescription: "Parsed JSON number \(floatValue) does not fit in Float16."
+        )
+      )
+    }
+  }
+
+  /// Encodes this value into the given encoder.
+  ///
+  /// This function throws an error if any values are invalid for the given
+  /// encoder's format.
+  ///
+  /// - Parameter encoder: The encoder to write data to.
+  public func encode(to encoder: Encoder) throws {
+    try Float(self).encode(to: encoder)
+  }
+}
+
 extension Int: Codable {
   /// Creates a new instance by decoding from the given decoder.
   ///

stdlib/public/core/FloatingPointParsing.swift.gyb

@@ -14,17 +14,19 @@ import SwiftShims
 
 %{
 
-allFloatBits = [32, 64, 80]
+allFloatBits = [16, 32, 64, 80]
 
 def floatName(bits):
+    if bits == 16:
+        return 'Float16'
     if bits == 32:
         return 'Float'
     if bits == 64:
         return 'Double'
     if bits == 80:
         return 'Float80'
 
-cFuncSuffix2 = {32: 'f', 64: 'd', 80: 'ld'}
+cFuncSuffix2 = {16: 'f16', 32: 'f', 64: 'd', 80: 'ld'}
 
 }%
 
@@ -43,6 +45,9 @@ internal func _isspace_clocale(_ u: UTF16.CodeUnit) -> Bool {
 % end
 
 //===--- Parsing ----------------------------------------------------------===//
+%if bits == 16:
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+%end
 extension ${Self}: LosslessStringConvertible {
   /// Creates a new instance from the given string.
   ///
@@ -126,6 +131,9 @@ extension ${Self}: LosslessStringConvertible {
   ///   is `nil`.
   @inlinable
   public init?<S: StringProtocol>(_ text: S) {
+  %if bits == 16:
+    self.init(Substring(text))
+  %else:
     if #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) {
       self.init(Substring(text))
     } else {
@@ -149,6 +157,7 @@ extension ${Self}: LosslessStringConvertible {
         return nil
       }
     }
+  %end
   }
 
   // Caveat:  This implementation used to be inlineable.