SR-106: New floating-point description implementation (#15474)

* SR-106: New floating-point `description` implementation

This replaces the current implementation of `description` and
`debugDescription` for the standard floating-point types with a new
formatting routine based on a variation of Florian Loitsch' Grisu2
algorithm with changes suggested by Andrysco, Jhala, and Lerner's 2016
paper describing Errol3.

Unlike the earlier code based on `sprintf` with a fixed number of
digits, this version always chooses the optimal number of digits.  As
such, we can now use the exact same output for both `description` and
`debugDescription` (except of course that `debugDescription` provides
full detail for NaNs).

The implementation has been extensively commented; people familiar with
Grisu-style algorithms should find the code easy to understand.

This implementation is:

* Fast.  It uses only fixed-width integer arithmetic and has constant
  memory and time requirements.

* Simple. It is only a little more complex than Loitsch' original
  implementation of Grisu2.  The digit decomposition logic for double is
  less than 300 lines of standard C (half of which is common arithmetic
  support routines).

* Always Accurate. Converting the decimal form back to binary (using an
  accurate algorithm such as Clinger's) will always yield exactly the
  original binary value.  For the IEEE 754 formats, the round-trip will
  produce exactly the same bit pattern in memory.  This is an essential
  requirement for JSON serialization, debugging, and logging.

* Always Short.  This always selects an accurate result with the minimum
  number of decimal digits.  (So that `1.0 / 10.0` will always print
  `0.1`.)

* Always Close.  Among all accurate, short results, this always chooses
  the result that is closest to the exact floating-point value. (In case
  of an exact tie, it rounds the last digit even.)

This resolves SR-106 and related issues that have complained
about the floating-point `description` properties being inexact.

* Remove duplicate infinity handling

* Use defined(__SIZEOF_INT128__) to detect uint128_t support

* Separate `extracting` the integer part from `clearing` the integer part

The previous code was unnecessarily obfuscated by the attempt to combine
these two operations.

* Use `UINT32_MAX` to mask off 32 bits of a larger integer

* Correct the expected NaN results for 32-bit i386

* Make the C++ exceptions here consistent

Adding a C source file somehow exposed an issue in an unrelated C++ file.
Thanks to Joe Groff for the fix.

* Rename SwiftDtoa to ".cpp"

Having a C file in stdlib/public/runtime causes strange
build failures on Linux in unrelated C++ files.

As a workaround, rename SwiftDtoa.c to .cpp to see
if that avoids the problems.

* Revert "Make the C++ exceptions here consistent"

This reverts commit 6cd5c20.

Author: tbkka

include/swift/Runtime/SwiftDtoa.h

@@ -0,0 +1,144 @@
+//===--- SwiftDtoa.h ---------------------------------------------*- c -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2018 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
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef SWIFT_DTOA_H
+#define SWIFT_DTOA_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+// This implementation strongly assumes that `float` is
+// IEEE 754 single-precision binary32 format and that
+// `double` is IEEE 754 double-precision binary64 format.
+
+// Essentially all modern platforms use IEEE 754 floating point
+// types now, so enable these by default:
+#define SWIFT_DTOA_FLOAT_SUPPORT 1
+#define SWIFT_DTOA_DOUBLE_SUPPORT 1
+
+// This implementation assumes `long double` is Intel 80-bit extended format.
+#if defined(_WIN32)
+ // Windows has `long double` == `double` on all platforms, so disable this.
+ #undef SWIFT_DTOA_FLOAT80_SUPPORT
+#elif defined(__APPLE__) || defined(__linux__)
+ // macOS and Linux support Float80 on X86 hardware but not on ARM
+ #if defined(__x86_64__) || defined(__i386)
+  #define SWIFT_DTOA_FLOAT80_SUPPORT 1
+ #endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if SWIFT_DTOA_DOUBLE_SUPPORT
+// Compute the optimal decimal digits and exponent for a double.
+//
+// Input:
+// * `d` is the number to be decomposed
+// * `digits` is an array of `digits_length`
+// * `decimalExponent` is a pointer to an `int`
+//
+// Ouput:
+// * `digits` will receive the decimal digits
+// * `decimalExponent` will receive the decimal exponent
+// * function returns the number of digits generated
+// * the sign of the input number is ignored
+//
+// Guarantees:
+//
+// * Accurate. If you parse the result back to a double via an accurate
+//   algorithm (such as Clinger's algorithm), the resulting double will
+//   be exactly equal to the original value.  On most systems, this
+//   implies that using `strtod` to parse the output of
+//   `swift_format_double` will yield exactly the original value.
+//
+// * Short. No other accurate result will have fewer digits.
+//
+// * Close. If there are multiple possible decimal forms that are
+//   both accurate and short, the form computed here will be
+//   closest to the original binary value.
+//
+// Notes:
+//
+// If the input value is infinity or NaN, or `digits_length < 17`, the
+// function returns zero and generates no ouput.
+//
+// If the input value is zero, it will return `decimalExponent = 0` and
+// a single digit of value zero.
+//
+int swift_decompose_double(double d,
+    int8_t *digits, size_t digits_length, int *decimalExponent);
+
+// Format a double as an ASCII string.
+//
+// For infinity, it outputs "inf" or "-inf".
+//
+// For NaN, it outputs a Swift-style detailed dump, including
+// sign, signaling/quiet, and payload (if any).  Typical output:
+// "nan", "-nan", "-snan(0x1234)".
+//
+// For zero, it outputs "0.0" or "-0.0" depending on the sign.
+//
+// For other values, it uses `swift_decompose_double` to compute the
+// digits, then uses either `swift_format_decimal` or
+// `swift_format_exponential` to produce an ASCII string depending on
+// the magnitude of the value.
+//
+// In all cases, it returns the number of ASCII characters actually
+// written, or zero if the buffer was too small.
+size_t swift_format_double(double, char *dest, size_t length);
+#endif
+
+#if SWIFT_DTOA_FLOAT_SUPPORT
+// See swift_decompose_double.  `digits_length` must be at least 9.
+int swift_decompose_float(float f,
+    int8_t *digits, size_t digits_length, int *decimalExponent);
+// See swift_format_double.
+size_t swift_format_float(float, char *dest, size_t length);
+#endif
+
+#if SWIFT_DTOA_FLOAT80_SUPPORT
+// See swift_decompose_double.  `digits_length` must be at least 21.
+int swift_decompose_float80(long double f,
+    int8_t *digits, size_t digits_length, int *decimalExponent);
+// See swift_format_double.
+size_t swift_format_float80(long double, char *dest, size_t length);
+#endif
+
+// Generate an ASCII string from the raw exponent and digit information
+// as generated by `swift_decompose_double`.  Returns the number of
+// bytes actually used.  If `dest` was not big enough, these functions
+// return zero.  The generated string is always terminated with a zero
+// byte unless `length` was zero.
+
+// "Exponential" form uses common exponential format, e.g., "-1.234e+56"
+// The exponent always has a sign and at least two digits.  The
+// generated string is never longer than `digits_count + 9` bytes,
+// including the trailing zero byte.
+size_t swift_format_exponential(char *dest, size_t length,
+    bool negative, const int8_t *digits, int digits_count, int decimalExponent);
+
+// "Decimal" form writes the value without using exponents.  This
+// includes cases such as "0.000001234", "123.456", and "123456000.0".
+// Note that the result always has a decimal point with at least one
+// digit before and one digit after.  The generated string is never
+// longer than `digits_count + abs(exponent) + 4` bytes, including the
+// trailing zero byte.
+size_t swift_format_decimal(char *dest, size_t length,
+    bool negative, const int8_t *digits, int digits_count, int decimalExponent);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -83,15 +83,29 @@ extension ${Self} : CustomStringConvertible {
   /// A textual representation of the value.
   @inlinable // FIXME(sil-serialize-all)
   public var description: String {
-    return _float${bits}ToString(self, debug: false)
+    if isFinite {
+      return _float${bits}ToString(self, debug: false)
+    } else if isNaN {
+      return "nan"
+    } else if sign == .minus {
+      return "-inf"
+    } else {
+      return "inf"
+    }
   }
 }
 
 extension ${Self} : CustomDebugStringConvertible {
   /// A textual representation of the value, suitable for debugging.
   @inlinable // FIXME(sil-serialize-all)
   public var debugDescription: String {
-    return _float${bits}ToString(self, debug: true)
+    if isFinite || isNaN {
+      return _float${bits}ToString(self, debug: true)
+    } else if sign == .minus {
+      return "-inf"
+    } else {
+      return "inf"
+    }
   }
 }
 

stdlib/public/core/Runtime.swift.gyb

@@ -407,32 +407,7 @@ internal func _float${bits}ToStringImpl(
 internal func _float${bits}ToString(
   _ value: Float${bits}, debug: Bool
 ) -> String {
-
-  if !value.isFinite {
-    let significand = value.significandBitPattern
-    if significand == 0 {
-      // Infinity
-      return value.sign == .minus ? "-inf" : "inf"
-    }
-    else {
-      // NaN
-      if !debug {
-        return "nan"
-      }
-      let isSignaling = (significand & Float${bits}._quietNaNMask) == 0
-      let payload = significand & ((Float${bits}._quietNaNMask >> 1) - 1)
-      // FIXME(performance): Inefficient String manipulation. We could move
-      // this to C function.
-      return
-        (value.sign == .minus ? "-" : "")
-        + (isSignaling ? "snan" : "nan")
-        + (payload == 0 ? "" : ("(0x" + String(payload, radix: 16) + ")"))
-    }
-  }
-
   _sanityCheck(MemoryLayout<_Buffer32>.size == 32)
-  _sanityCheck(MemoryLayout<_Buffer72>.size == 72)
-
   var buffer = _Buffer32()
   return buffer.withBytes { (bufferPtr) in
     let actualLength = _float${bits}ToStringImpl(bufferPtr, 32, value, debug)

stdlib/public/runtime/CMakeLists.txt

@@ -65,6 +65,7 @@ set(swift_runtime_sources
     ProtocolConformance.cpp
     RefCount.cpp
     RuntimeInvocationsTracking.cpp
+    SwiftDtoa.cpp
     "${SWIFT_SOURCE_DIR}/lib/Demangling/OldDemangler.cpp"
     "${SWIFT_SOURCE_DIR}/lib/Demangling/Demangler.cpp"
     "${SWIFT_SOURCE_DIR}/lib/Demangling/NodePrinter.cpp"