[flang] Progress on Fortran I/O runtime

Use internal units for internal I/O state

Replace use of virtual functions

reference_wrapper

Internal formatted output to array descriptor

Delete dead code

Begin list-directed internal output

Refactorings and renamings for clarity

List-directed external I/O (character)

COMPLEX list-directed output

Control list items

First cut at unformatted I/O

More OPEN statement work; rename class to ExternalFileUnit

Complete OPEN (exc. for POSITION=), add CLOSE()

OPEN(POSITION=)

Flush buffers on crash and for terminal output; clean up

Documentation

Fix backquote in documentation

Fix typo in comment

Begin implementation of input

Refactor binary floating-point properties to a new header, simplify numeric output editing

Dodge spurious GCC 7.2 build warning

Address review comments

Original-commit: flang-compiler/f18@9c4bba1
Reviewed-on: flang-compiler/f18#982

flang/documentation/FortranForCProgrammers.md

@@ -1,9 +1,9 @@
-<!--===- documentation/FortranForCProgrammers.md 
-  
+<!--===- documentation/FortranForCProgrammers.md
+
    Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
    See https://llvm.org/LICENSE.txt for license information.
    SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-  
+
 -->
 
 Fortran For C Programmers

flang/include/flang/common/real.h

@@ -0,0 +1,86 @@
+//===-- include/flang/common/real.h -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_COMMON_REAL_H_
+#define FORTRAN_COMMON_REAL_H_
+
+// Characteristics of IEEE-754 & related binary floating-point numbers.
+// The various representations are distinguished by their binary precisions
+// (number of explicit significand bits and any implicit MSB in the fraction).
+
+#include <cinttypes>
+
+namespace Fortran::common {
+
+// Total representation size in bits for each type
+static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
+  switch (binaryPrecision) {
+  case 8: return 16;  // IEEE single (truncated): 1+8+7
+  case 11: return 16;  // IEEE half precision: 1+5+10
+  case 24: return 32;  // IEEE single precision: 1+8+23
+  case 53: return 64;  // IEEE double precision: 1+11+52
+  case 64: return 80;  // x87 extended precision: 1+15+64
+  case 106: return 128;  // "double-double": 2*(1+11+52)
+  case 112: return 128;  // IEEE quad precision: 1+16+111
+  default: return -1;
+  }
+}
+
+// Number of significant decimal digits in the fraction of the
+// exact conversion of the least nonzero (subnormal) value
+// in each type; i.e., a 128-bit quad value can be formatted
+// exactly with FORMAT(E0.22981).
+static constexpr int MaxDecimalConversionDigits(int binaryPrecision) {
+  switch (binaryPrecision) {
+  case 8: return 93;
+  case 11: return 17;
+  case 24: return 105;
+  case 53: return 751;
+  case 64: return 11495;
+  case 106: return 2 * 751;
+  case 112: return 22981;
+  default: return -1;
+  }
+}
+
+template<int BINARY_PRECISION> class RealDetails {
+private:
+  // Converts bit widths to whole decimal digits
+  static constexpr int LogBaseTwoToLogBaseTen(int logb2) {
+    constexpr std::int64_t LogBaseTenOfTwoTimesTenToThe12th{301029995664};
+    constexpr std::int64_t TenToThe12th{1000000000000};
+    std::int64_t logb10{
+        (logb2 * LogBaseTenOfTwoTimesTenToThe12th) / TenToThe12th};
+    return static_cast<int>(logb10);
+  }
+
+public:
+  static constexpr int binaryPrecision{BINARY_PRECISION};
+  static constexpr int bits{BitsForBinaryPrecision(binaryPrecision)};
+  static constexpr bool isImplicitMSB{binaryPrecision != 64 /*x87*/};
+  static constexpr int significandBits{binaryPrecision - isImplicitMSB};
+  static constexpr int exponentBits{bits - significandBits - 1 /*sign*/};
+  static constexpr int maxExponent{(1 << exponentBits) - 1};
+  static constexpr int exponentBias{maxExponent / 2};
+
+  static constexpr int decimalPrecision{
+      LogBaseTwoToLogBaseTen(binaryPrecision - 1)};
+  static constexpr int decimalRange{LogBaseTwoToLogBaseTen(exponentBias - 1)};
+
+  // Number of significant decimal digits in the fraction of the
+  // exact conversion of the least nonzero subnormal.
+  static constexpr int maxDecimalConversionDigits{
+      MaxDecimalConversionDigits(binaryPrecision)};
+
+  static_assert(binaryPrecision > 0);
+  static_assert(exponentBits > 1);
+  static_assert(exponentBits <= 16);
+};
+
+}
+#endif  // FORTRAN_COMMON_REAL_H_

flang/include/flang/decimal/binary-floating-point.h

@@ -12,6 +12,7 @@
 // Access and manipulate the fields of an IEEE-754 binary
 // floating-point value via a generalized template.
 
+#include "flang/common/real.h"
 #include "flang/common/uint128.h"
 #include <cinttypes>
 #include <climits>
@@ -20,34 +21,24 @@
 
 namespace Fortran::decimal {
 
-static constexpr int BitsForPrecision(int prec) {
-  switch (prec) {
-  case 8: return 16;
-  case 11: return 16;
-  case 24: return 32;
-  case 53: return 64;
-  case 64: return 80;
-  case 112: return 128;
-  default: return -1;
-  }
-}
+template<int BINARY_PRECISION>
+struct BinaryFloatingPointNumber
+  : public common::RealDetails<BINARY_PRECISION> {
 
-// LOG10(2.)*1E12
-static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
+  using Details = common::RealDetails<BINARY_PRECISION>;
+  using Details::bits;
+  using Details::decimalPrecision;
+  using Details::decimalRange;
+  using Details::exponentBias;
+  using Details::exponentBits;
+  using Details::isImplicitMSB;
+  using Details::maxDecimalConversionDigits;
+  using Details::maxExponent;
+  using Details::significandBits;
 
-template<int PRECISION> struct BinaryFloatingPointNumber {
-  static constexpr int precision{PRECISION};
-  static constexpr int bits{BitsForPrecision(precision)};
   using RawType = common::HostUnsignedIntType<bits>;
   static_assert(CHAR_BIT * sizeof(RawType) >= bits);
-  static constexpr bool implicitMSB{precision != 64 /*x87*/};
-  static constexpr int significandBits{precision - implicitMSB};
-  static constexpr int exponentBits{bits - 1 - significandBits};
-  static constexpr int maxExponent{(1 << exponentBits) - 1};
-  static constexpr int exponentBias{maxExponent / 2};
   static constexpr RawType significandMask{(RawType{1} << significandBits) - 1};
-  static constexpr int RANGE{static_cast<int>(
-      (exponentBias - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
 
   constexpr BinaryFloatingPointNumber() {}  // zero
   constexpr BinaryFloatingPointNumber(
@@ -76,7 +67,7 @@ template<int PRECISION> struct BinaryFloatingPointNumber {
   constexpr RawType Significand() const { return raw & significandMask; }
   constexpr RawType Fraction() const {
     RawType sig{Significand()};
-    if (implicitMSB && BiasedExponent() > 0) {
+    if (isImplicitMSB && BiasedExponent() > 0) {
       sig |= RawType{1} << significandBits;
     }
     return sig;

flang/include/flang/decimal/decimal.h

@@ -62,6 +62,15 @@ enum DecimalConversionFlags {
   AlwaysSign = 2, /* emit leading '+' if not negative */
 };
 
+/*
+ * When allocating decimal conversion output buffers, use the maximum
+ * number of significant decimal digits in the representation of the
+ * least nonzero value, and add this extra space for a sign, a NUL, and
+ * some extra due to the library working internally in base 10**16
+ * and computing its output size in multiples of 16.
+ */
+#define EXTRA_DECIMAL_CONVERSION_SPACE (1 + 1 + 16 - 1)
+
 #ifdef __cplusplus
 template<int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *, size_t,

flang/include/flang/evaluate/common.h

@@ -130,9 +130,9 @@ struct Rounding {
 static constexpr Rounding defaultRounding;
 
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-constexpr bool IsHostLittleEndian{false};
+constexpr bool isHostLittleEndian{false};
 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-constexpr bool IsHostLittleEndian{true};
+constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif

flang/include/flang/evaluate/complex.h

@@ -95,7 +95,7 @@ extern template class Complex<Real<Integer<16>, 11>>;
 extern template class Complex<Real<Integer<16>, 8>>;
 extern template class Complex<Real<Integer<32>, 24>>;
 extern template class Complex<Real<Integer<64>, 53>>;
-extern template class Complex<Real<Integer<80>, 64, false>>;
+extern template class Complex<Real<Integer<80>, 64>>;
 extern template class Complex<Real<Integer<128>, 112>>;
 }
 #endif  // FORTRAN_EVALUATE_COMPLEX_H_

flang/include/flang/evaluate/integer.h

@@ -49,7 +49,7 @@ namespace Fortran::evaluate::value {
 // Member functions that correspond to Fortran intrinsic functions are
 // named accordingly in ALL CAPS so that they can be referenced easily in
 // the language standard.
-template<int BITS, bool IS_LITTLE_ENDIAN = IsHostLittleEndian,
+template<int BITS, bool IS_LITTLE_ENDIAN = isHostLittleEndian,
     int PARTBITS = BITS <= 32 ? BITS : 32,
     typename PART = HostUnsignedInt<PARTBITS>,
     typename BIGPART = HostUnsignedInt<PARTBITS * 2>>

flang/include/flang/evaluate/real.h

@@ -12,6 +12,7 @@
 #include "formatting.h"
 #include "integer.h"
 #include "rounding-bits.h"
+#include "flang/common/real.h"
 #include "flang/evaluate/common.h"
 #include <cinttypes>
 #include <limits>
@@ -30,26 +31,25 @@ static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
 // Models IEEE binary floating-point numbers (IEEE 754-2008,
 // ISO/IEC/IEEE 60559.2011).  The first argument to this
 // class template must be (or look like) an instance of Integer<>;
-// the second specifies the number of effective bits in the fraction;
-// the third, if true, indicates that the most significant position of the
-// fraction is an implicit bit whose value is assumed to be 1 in a finite
-// normal number.
-template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
+// the second specifies the number of effective bits (binary precision)
+// in the fraction.
+template<typename WORD, int PREC>
+class Real : public common::RealDetails<PREC> {
 public:
   using Word = WORD;
+  static constexpr int binaryPrecision{PREC};
+  using Details = common::RealDetails<PREC>;
+  using Details::exponentBias;
+  using Details::exponentBits;
+  using Details::isImplicitMSB;
+  using Details::maxExponent;
+  using Details::significandBits;
+
   static constexpr int bits{Word::bits};
-  static constexpr int precision{PREC};
-  using Fraction = Integer<precision>;  // all bits made explicit
-  static constexpr bool implicitMSB{IMPLICIT_MSB};
-  static constexpr int significandBits{precision - implicitMSB};
-  static constexpr int exponentBits{bits - significandBits - 1 /*sign*/};
-  static_assert(precision > 0);
-  static_assert(exponentBits > 1);
-  static_assert(exponentBits <= 16);
-  static constexpr int maxExponent{(1 << exponentBits) - 1};
-  static constexpr int exponentBias{maxExponent / 2};
-
-  template<typename W, int P, bool I> friend class Real;
+  static_assert(bits >= Details::bits);
+  using Fraction = Integer<binaryPrecision>;  // all bits made explicit
+
+  template<typename W, int P> friend class Real;
 
   constexpr Real() {}  // +0.0
   constexpr Real(const Real &) = default;
@@ -130,12 +130,13 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
 
   static constexpr Real EPSILON() {
     Real epsilon;
-    epsilon.Normalize(false, exponentBias - precision, Fraction::MASKL(1));
+    epsilon.Normalize(
+        false, exponentBias - binaryPrecision, Fraction::MASKL(1));
     return epsilon;
   }
   static constexpr Real HUGE() {
     Real huge;
-    huge.Normalize(false, maxExponent - 1, Fraction::MASKR(precision));
+    huge.Normalize(false, maxExponent - 1, Fraction::MASKR(binaryPrecision));
     return huge;
   }
   static constexpr Real TINY() {
@@ -144,11 +145,9 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     return tiny;
   }
 
-  static constexpr int DIGITS{precision};
-  static constexpr int PRECISION{static_cast<int>(
-      (precision - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
-  static constexpr int RANGE{static_cast<int>(
-      (exponentBias - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
+  static constexpr int DIGITS{binaryPrecision};
+  static constexpr int PRECISION{Details::decimalPrecision};
+  static constexpr int RANGE{Details::decimalRange};
   static constexpr int MAXEXPONENT{maxExponent - 1 - exponentBias};
   static constexpr int MINEXPONENT{1 - exponentBias};
 
@@ -190,7 +189,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + absN.bits - leadz - 1};
-    int bitsNeeded{absN.bits - (leadz + implicitMSB)};
+    int bitsNeeded{absN.bits - (leadz + isImplicitMSB)};
     int bitsLost{bitsNeeded - significandBits};
     if (bitsLost <= 0) {
       Fraction fraction{Fraction::ConvertUnsigned(absN).value};
@@ -224,7 +223,8 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     result.flags.set(
         RealFlag::Overflow, exponent >= exponentBias + result.value.bits);
     result.flags |= intPart.flags;
-    int shift{exponent - exponentBias - precision + 1};  // positive -> left
+    int shift{
+        exponent - exponentBias - binaryPrecision + 1};  // positive -> left
     result.value =
         result.value.ConvertUnsigned(intPart.value.GetFraction().SHIFTR(-shift))
             .value.SHIFTL(shift);
@@ -252,7 +252,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + x.UnbiasedExponent()};
-    int bitsLost{A::precision - precision};
+    int bitsLost{A::binaryPrecision - binaryPrecision};
     if (exponent < 1) {
       bitsLost += 1 - exponent;
       exponent = 1;
@@ -282,7 +282,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
   // Extracts the fraction; any implied bit is made explicit.
   constexpr Fraction GetFraction() const {
     Fraction result{Fraction::ConvertUnsigned(word_).value};
-    if constexpr (!implicitMSB) {
+    if constexpr (!isImplicitMSB) {
       return result;
     } else {
       int exponent{Exponent()};
@@ -366,7 +366,7 @@ extern template class Real<Integer<16>, 11>;  // IEEE half format
 extern template class Real<Integer<16>, 8>;  // the "other" half format
 extern template class Real<Integer<32>, 24>;  // IEEE single
 extern template class Real<Integer<64>, 53>;  // IEEE double
-extern template class Real<Integer<80>, 64, false>;  // 80387 extended precision
+extern template class Real<Integer<80>, 64>;  // 80387 extended precision
 extern template class Real<Integer<128>, 112>;  // IEEE quad
 // N.B. No "double-double" support.
 }

flang/include/flang/evaluate/type.h

@@ -268,7 +268,7 @@ class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
 template<>
 class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
 public:
-  using Scalar = value::Real<value::Integer<80>, 64, false>;
+  using Scalar = value::Real<value::Integer<80>, 64>;
 };
 
 // REAL(KIND=16) is IEEE quad precision (128 bits)

flang/lib/decimal/big-radix-floating-point.h

@@ -58,7 +58,8 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 
   // The base-2 logarithm of the least significant bit that can arise
   // in a subnormal IEEE floating-point number.
-  static constexpr int minLog2AnyBit{-Real::exponentBias - Real::precision};
+  static constexpr int minLog2AnyBit{
+      -Real::exponentBias - Real::binaryPrecision};
 
   // The number of Digits needed to represent the smallest subnormal.
   static constexpr int maxDigits{3 - minLog2AnyBit / log10Radix};