[flang-commits] [flang] ced631e - [flang][runtime] Handle Fw.0 case that needs to round up to 1.0 (#74384)
via flang-commits
flang-commits at lists.llvm.org
Mon Dec 11 12:11:24 PST 2023
Author: Peter Klausler
Date: 2023-12-11T12:11:20-08:00
New Revision: ced631e0da3443d4afe4b5c1992bc2c438caa8a8
URL: https://github.com/llvm/llvm-project/commit/ced631e0da3443d4afe4b5c1992bc2c438caa8a8
DIFF: https://github.com/llvm/llvm-project/commit/ced631e0da3443d4afe4b5c1992bc2c438caa8a8.diff
LOG: [flang][runtime] Handle Fw.0 case that needs to round up to 1.0 (#74384)
A tricky case in Fw.d output editing is when the value needs to be
rounded either to a signed zero or away from zero to a power of ten
(1.0, 0.1, &c.). A bug report for LLVM on GitHub (#74274) exposed a bug
in this code in the case of Fw.0 editing where a value just over 0.5 was
rounded incorrectly to 0 rather than 1 when no fractional digits were
requested.
Rework that algorithm a little, ensuring that the initial
binary->decimal conversion produces at least one digit, and coping
correctly with the rounding of an exact 0.5 value for Fw.0 editing
(rounding it to the nearest even decimal, namely 0, following
near-universal compiler-dependent behavior in other Fortrans).
Fixes https://github.com/llvm/llvm-project/issues/74274.
Added:
Modified:
flang/runtime/edit-output.cpp
flang/unittests/Runtime/NumericalFormatTest.cpp
Removed:
################################################################################
diff --git a/flang/runtime/edit-output.cpp b/flang/runtime/edit-output.cpp
index 18e2a3f1e537cc..a4ce0b12f91111 100644
--- a/flang/runtime/edit-output.cpp
+++ b/flang/runtime/edit-output.cpp
@@ -433,27 +433,28 @@ bool RealOutputEditing<KIND>::EditFOutput(const DataEdit &edit) {
}
// Multiple conversions may be needed to get the right number of
// effective rounded fractional digits.
- int extraDigits{0};
bool canIncrease{true};
- while (true) {
+ for (int extraDigits{fracDigits == 0 ? 1 : 0};;) {
decimal::ConversionToDecimalResult converted{
ConvertToDecimal(extraDigits + fracDigits, rounding, flags)};
- if (IsInfOrNaN(converted.str, static_cast<int>(converted.length))) {
+ const char *convertedStr{converted.str};
+ if (IsInfOrNaN(convertedStr, static_cast<int>(converted.length))) {
return editWidth > 0 &&
converted.length > static_cast<std::size_t>(editWidth)
? EmitRepeated(io_, '*', editWidth)
: EmitPrefix(edit, converted.length, editWidth) &&
- EmitAscii(io_, converted.str, converted.length) &&
+ EmitAscii(io_, convertedStr, converted.length) &&
EmitSuffix(edit);
}
int expo{converted.decimalExponent + edit.modes.scale /*kP*/};
- int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
+ int signLength{*convertedStr == '-' || *convertedStr == '+' ? 1 : 0};
int convertedDigits{static_cast<int>(converted.length) - signLength};
if (IsZero()) { // don't treat converted "0" as significant digit
expo = 0;
convertedDigits = 0;
}
- int trailingOnes{0};
+ bool isNegative{*convertedStr == '-'};
+ char one[2];
if (expo > extraDigits && extraDigits >= 0 && canIncrease) {
extraDigits = expo;
if (!edit.digits.has_value()) { // F0
@@ -462,24 +463,45 @@ bool RealOutputEditing<KIND>::EditFOutput(const DataEdit &edit) {
canIncrease = false; // only once
continue;
} else if (expo == -fracDigits && convertedDigits > 0) {
- if ((rounding == decimal::FortranRounding::RoundUp &&
- *converted.str != '-') ||
- (rounding == decimal::FortranRounding::RoundDown &&
- *converted.str == '-') ||
- (rounding == decimal::FortranRounding::RoundToZero &&
- rounding != edit.modes.round && // it changed below
- converted.str[signLength] >= '5')) {
- // Round up/down to a scaled 1
+ // Result will be either a signed zero or power of ten, depending
+ // on rounding.
+ char leading{convertedStr[signLength]};
+ bool roundToPowerOfTen{false};
+ switch (edit.modes.round) {
+ case decimal::FortranRounding::RoundUp:
+ roundToPowerOfTen = !isNegative;
+ break;
+ case decimal::FortranRounding::RoundDown:
+ roundToPowerOfTen = isNegative;
+ break;
+ case decimal::FortranRounding::RoundToZero:
+ break;
+ case decimal::FortranRounding::RoundNearest:
+ if (leading == '5' &&
+ rounding == decimal::FortranRounding::RoundNearest) {
+ // Try again, rounding away from zero.
+ rounding = isNegative ? decimal::FortranRounding::RoundDown
+ : decimal::FortranRounding::RoundUp;
+ extraDigits = 1 - fracDigits; // just one digit needed
+ continue;
+ }
+ roundToPowerOfTen = leading > '5';
+ break;
+ case decimal::FortranRounding::RoundCompatible:
+ roundToPowerOfTen = leading >= '5';
+ break;
+ }
+ if (roundToPowerOfTen) {
++expo;
- convertedDigits = 0;
- trailingOnes = 1;
- } else if (rounding != decimal::FortranRounding::RoundToZero) {
- // Convert again with truncation so first digit can be checked
- // on the next iteration by the code above
- rounding = decimal::FortranRounding::RoundToZero;
- continue;
+ convertedDigits = 1;
+ if (signLength > 0) {
+ one[0] = *convertedStr;
+ one[1] = '1';
+ } else {
+ one[0] = '1';
+ }
+ convertedStr = one;
} else {
- // Value rounds down to zero
expo = 0;
convertedDigits = 0;
}
@@ -493,17 +515,14 @@ bool RealOutputEditing<KIND>::EditFOutput(const DataEdit &edit) {
int digitsAfterPoint{convertedDigits - digitsBeforePoint};
int trailingZeroes{flags & decimal::Minimize
? 0
- : std::max(0,
- fracDigits -
- (zeroesAfterPoint + digitsAfterPoint + trailingOnes))};
+ : std::max(0, fracDigits - (zeroesAfterPoint + digitsAfterPoint))};
if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
- digitsAfterPoint + trailingOnes + trailingZeroes ==
+ digitsAfterPoint + trailingZeroes ==
0) {
zeroesBeforePoint = 1; // "." -> "0."
}
int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
- 1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingOnes +
- trailingZeroes};
+ 1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
int width{editWidth > 0 ? editWidth : totalLength};
if (totalLength > width) {
return EmitRepeated(io_, '*', width);
@@ -513,13 +532,12 @@ bool RealOutputEditing<KIND>::EditFOutput(const DataEdit &edit) {
++totalLength;
}
return EmitPrefix(edit, totalLength, width) &&
- EmitAscii(io_, converted.str, signLength + digitsBeforePoint) &&
+ EmitAscii(io_, convertedStr, signLength + digitsBeforePoint) &&
EmitRepeated(io_, '0', zeroesBeforePoint) &&
EmitAscii(io_, edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
EmitRepeated(io_, '0', zeroesAfterPoint) &&
- EmitAscii(io_, converted.str + signLength + digitsBeforePoint,
+ EmitAscii(io_, convertedStr + signLength + digitsBeforePoint,
digitsAfterPoint) &&
- EmitRepeated(io_, '1', trailingOnes) &&
EmitRepeated(io_, '0', trailingZeroes) &&
EmitRepeated(io_, ' ', trailingBlanks_) && EmitSuffix(edit);
}
diff --git a/flang/unittests/Runtime/NumericalFormatTest.cpp b/flang/unittests/Runtime/NumericalFormatTest.cpp
index 219947fe4fbbb7..b5b8eb05943732 100644
--- a/flang/unittests/Runtime/NumericalFormatTest.cpp
+++ b/flang/unittests/Runtime/NumericalFormatTest.cpp
@@ -710,8 +710,12 @@ TEST(IOApiTests, FormatDoubleValues) {
{"(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.0005000000000000000104083408558608425664715468883514404296875,
+ "0.001;"},
+ {"(F5.3,';')",
+ 0.000499999999999999901988123607310399165726266801357269287109375,
+ "0.000;"},
{"(F5.3,';')", 0.000099999, "0.000;"},
{"(F5.3,';')", -99.999, "*****;"},
{"(F5.3,';')", -9.9999, "*****;"},
@@ -719,17 +723,30 @@ TEST(IOApiTests, FormatDoubleValues) {
{"(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.0005000000000000000104083408558608425664715468883514404296875,
+ "-.001;"},
+ {"(F5.3,';')",
+ -0.000499999999999999901988123607310399165726266801357269287109375,
+ "-.000;"},
{"(F5.3,';')", -0.000099999, "-.000;"},
{"(F0.1,';')", 0.0, ".0;"},
+ {"(F5.0,';')", -0.5000000000000001, " -1.;"},
+ {"(F5.0,';')", -0.5, " -0.;"},
+ {"(F5.0,';')", -0.49999999999999994, " -0.;"},
+ {"(F5.0,';')", 0.49999999999999994, " 0.;"},
+ {"(F5.0,';')", 0.5, " 0.;"},
+ {"(F5.0,';')", 0.5000000000000001, " 1.;"},
};
for (auto const &[format, value, expect] : individualTestCases) {
std::string got;
+ char hex[17];
+ std::snprintf(hex, sizeof hex, "%016llx",
+ *reinterpret_cast<const unsigned long long *>(&value));
ASSERT_TRUE(CompareFormatReal(format, value, expect, got))
- << "Failed to format " << format << ", expected '" << expect
- << "', got '" << got << "'";
+ << "Failed to format " << value << " 0x" << hex << " with format "
+ << format << ", expected '" << expect << "', got '" << got << "'";
}
// Problematic EN formatting edge cases with rounding
More information about the flang-commits
mailing list