[flang] Fix rounding edge case in F output editing

[klausler]

Summary

When an Fw.d output edit descriptor has a "d" value exactly
equal to the number of zeroes after the decimal point for a value
(e.g., 0.07 with F5.1), the Fw.d output editing code needs to
do the rounding itself to either 0.0 or 0.1 after performing
a conversion without rounding (to avoid 0.04999 rounding up twice).

flang/runtime/edit-output.h

private:
   bool EditFOutput(const DataEdit &);
   DataEdit EditForGOutput(DataEdit); // returns an E or F edit
   bool EditEXOutput(const DataEdit &);
   bool EditListDirectedOutput(const DataEdit &);
 
   bool IsZero() const { return x_.IsZero(); }
 
   decimal::ConversionToDecimalResult Convert(
-      int significantDigits, const DataEdit &, int flags = 0);
+      int significantDigits, enum decimal::FortranRounding, int flags = 0);
 
   BinaryFloatingPoint x_;
   char buffer_[BinaryFloatingPoint::maxDecimalConversionDigits +
       EXTRA_DECIMAL_CONVERSION_SPACE];
 };
 
 bool ListDirectedLogicalOutput(
     IoStatementState &, ListDirectedStatementState<Direction::Output> &, bool);

flang/runtime/edit-output.cpp

if (edit.descriptor == DataEdit::ListDirectedRealPart) {
     return io_.Emit(")", 1);
   } else {
     return true;
   }
 }
 
 template <int binaryPrecision>
 decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
-    int significantDigits, const DataEdit &edit, int flags) {
-  if (edit.modes.editingFlags & signPlus) {
-    flags |= decimal::AlwaysSign;
-  }
+    int significantDigits, enum decimal::FortranRounding rounding, int flags) {
   auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
       sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
-      significantDigits, edit.modes.round, x_)};
+      significantDigits, rounding, x_)};
   if (!converted.str) { // overflow
     io_.GetIoErrorHandler().Crash(
         "RealOutputEditing::Convert : buffer size %zd was insufficient",
         sizeof buffer_);
   }
   return converted;
 }
 
 // 13.7.2.3.3 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   int editDigits{edit.digits.value_or(0)}; // 'd' field
   int editWidth{edit.width.value_or(0)}; // 'w' field
   int significantDigits{editDigits};
   int flags{0};
+  if (edit.modes.editingFlags & signPlus) {
+    flags |= decimal::AlwaysSign;
+  }
   if (editWidth == 0) { // "the processor selects the field width"
     if (edit.digits.has_value()) { // E0.d
       editWidth = editDigits + 6; // -.666E+ee
     } else { // E0
       flags |= decimal::Minimize;
       significantDigits =
           sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling
     }
   }
   bool isEN{edit.variation == 'N'};
   bool isES{edit.variation == 'S'};
   int scale{isEN || isES ? 1 : edit.modes.scale}; // 'kP' value
   int zeroesAfterPoint{0};
   if (scale < 0) {
     zeroesAfterPoint = -scale;
     significantDigits = std::max(0, significantDigits - zeroesAfterPoint);
   } else if (scale > 0) {
     ++significantDigits;
     scale = std::min(scale, significantDigits + 1);
   }
   // In EN editing, multiple attempts may be necessary, so it's in a loop.
   while (true) {
     decimal::ConversionToDecimalResult converted{
-        Convert(significantDigits, edit, flags)};
+        Convert(significantDigits, edit.modes.round, flags)};
     if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     if (!IsZero()) {
       converted.decimalExponent -= scale;
     }
     if (isEN && scale < 3 && (converted.decimalExponent % 3) != 0) {
bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   }
 }
 
 // 13.7.2.3.2 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   int fracDigits{edit.digits.value_or(0)}; // 'd' field
   const int editWidth{edit.width.value_or(0)}; // 'w' field
+  enum decimal::FortranRounding rounding{edit.modes.round};
   int flags{0};
+  if (edit.modes.editingFlags & signPlus) {
+    flags |= decimal::AlwaysSign;
+  }
   if (editWidth == 0) { // "the processor selects the field width"
     if (!edit.digits.has_value()) { // F0
       flags |= decimal::Minimize;
       fracDigits = sizeof buffer_ - 2; // sign & NUL
     }
   }
   // Multiple conversions may be needed to get the right number of
   // effective rounded fractional digits.
   int extraDigits{0};
   bool canIncrease{true};
   while (true) {
     decimal::ConversionToDecimalResult converted{
-        Convert(extraDigits + fracDigits, edit, flags)};
+        Convert(extraDigits + fracDigits, rounding, flags)};
     if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     int scale{IsZero() ? 1 : edit.modes.scale}; // kP
     int expo{converted.decimalExponent + scale};
+    int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
+    int convertedDigits{static_cast<int>(converted.length) - signLength};
+    int trailingOnes{0};
     if (expo > extraDigits && extraDigits >= 0 && canIncrease) {
       extraDigits = expo;
       if (!edit.digits.has_value()) { // F0
         fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
       }
       canIncrease = false; // only once
       continue;
+    } else if (expo == -fracDigits && convertedDigits > 0) {
+      if (rounding != decimal::FortranRounding::RoundToZero) {
+        // Convert again without rounding so that we can round here
+        rounding = decimal::FortranRounding::RoundToZero;
+        continue;
+      } else if (converted.str[signLength] >= '5') {
+        // Value rounds up to a scaled 1 (e.g., 0.06 for F5.1 -> 0.1)
+        ++expo;
+        convertedDigits = 0;
+        trailingOnes = 1;
+      } else {
+        // Value rounds down to zero
+        expo = 0;
+        convertedDigits = 0;
+      }
     } else if (expo < extraDigits && extraDigits > -fracDigits) {
       extraDigits = std::max(expo, -fracDigits);
       continue;
     }
-    int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
-    int convertedDigits{static_cast<int>(converted.length) - signLength};
     int digitsBeforePoint{std::max(0, std::min(expo, convertedDigits))};
     int zeroesBeforePoint{std::max(0, expo - digitsBeforePoint)};
     int zeroesAfterPoint{std::min(fracDigits, std::max(0, -expo))};
     int digitsAfterPoint{convertedDigits - digitsBeforePoint};
     int trailingZeroes{flags & decimal::Minimize
             ? 0
-            : std::max(0, fracDigits - (zeroesAfterPoint + digitsAfterPoint))};
+            : std::max(0,
+                  fracDigits -
+                      (zeroesAfterPoint + digitsAfterPoint + trailingOnes))};
     if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
-            digitsAfterPoint + trailingZeroes ==
+            digitsAfterPoint + trailingOnes + trailingZeroes ==
         0) {
       zeroesBeforePoint = 1; // "." -> "0."
     }
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
-        1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
+        1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingOnes +
+        trailingZeroes};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width) {
       return io_.EmitRepeated('*', width);
     }
     if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
     return EmitPrefix(edit, totalLength, width) &&
         io_.Emit(converted.str, signLength + digitsBeforePoint) &&
         io_.EmitRepeated('0', zeroesBeforePoint) &&
         io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
         io_.EmitRepeated('0', zeroesAfterPoint) &&
         io_.Emit(
             converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
+        io_.EmitRepeated('1', trailingOnes) &&
         io_.EmitRepeated('0', trailingZeroes) &&
         io_.EmitRepeated(' ', trailingBlanks_) && EmitSuffix(edit);
   }
 }
 
 // 13.7.5.2.3 in F'2018
 template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   int significantDigits{
       edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
   if (!edit.width.has_value() || (*edit.width > 0 && significantDigits == 0)) {
     return edit; // Gw.0 -> Ew.0 for w > 0
   }
+  int flags{0};
+  if (edit.modes.editingFlags & signPlus) {
+    flags |= decimal::AlwaysSign;
+  }
   decimal::ConversionToDecimalResult converted{
-      Convert(significantDigits, edit)};
+      Convert(significantDigits, edit.modes.round, flags)};
   if (IsInfOrNaN(converted)) {
     return edit;
   }
   int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   if (expo < 0 || expo > significantDigits) {
     return edit; // Ew.d
   }
   edit.descriptor = 'F';
DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   }
   return edit;
 }
 
 // 13.10.4 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
     const DataEdit &edit) {
-  decimal::ConversionToDecimalResult converted{Convert(1, edit)};
+  decimal::ConversionToDecimalResult converted{Convert(1, edit.modes.round)};
   if (IsInfOrNaN(converted)) {
     return EditEorDOutput(edit);
   }
   int expo{converted.decimalExponent};
   if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) {
     DataEdit copy{edit};
     copy.modes.scale = 1; // 1P
     return EditEorDOutput(copy);

flang/unittests/Runtime/NumericalFormatTest.cpp

static const std::vector<IndividualTestCaseTy> individualTestCases{
       {"(F5.3,';')", -0.00025, "-.000;"},
       {"(F5.3,';')", -0.000025, "-.000;"},
       {"(F5.3,';')", 99.999, "*****;"},
       {"(F5.3,';')", 9.9999, "*****;"},
       {"(F5.3,';')", 0.99999, "1.000;"},
       {"(F5.3,';')", 0.099999, "0.100;"},
       {"(F5.3,';')", 0.0099999, "0.010;"},
       {"(F5.3,';')", 0.00099999, "0.001;"},
+      {"(F5.3,';')", 0.0005, "0.001;"},
+      {"(F5.3,';')", 0.00049999, "0.000;"},
       {"(F5.3,';')", 0.000099999, "0.000;"},
       {"(F5.3,';')", -99.999, "*****;"},
       {"(F5.3,';')", -9.9999, "*****;"},
       {"(F5.3,';')", -0.99999, "*****;"},
       {"(F5.3,';')", -0.099999, "-.100;"},
       {"(F5.3,';')", -0.0099999, "-.010;"},
       {"(F5.3,';')", -0.00099999, "-.001;"},
+      {"(F5.3,';')", -0.0005, "-.001;"},
+      {"(F5.3,';')", -0.00049999, "-.000;"},
       {"(F5.3,';')", -0.000099999, "-.000;"},
   };
 
   for (auto const &[format, value, expect] : individualTestCases) {
     ASSERT_TRUE(CompareFormatReal(format, value, expect))
         << "Failed to format " << format << ", expected " << expect;
   }
 }