[mlir][AsmPrinter] Fix edge case when printing floating point values.

[rriddle]

Summary

In some edge cases the default APFloat printer will generate something that we can't parse back in. In these cases, fallback to using hex instead.

mlir/lib/IR/AsmPrinter.cpp

static void printFloatValue(const APFloat &apValue, raw_ostream &os) {
   // We would like to output the FP constant value in exponential notation,
   // but we cannot do this if doing so will lose precision.  Check here to
   // make sure that we only output it in exponential format if we can parse
   // the value back and get the same value.
   bool isInf = apValue.isInfinity();
   bool isNaN = apValue.isNaN();
   if (!isInf && !isNaN) {
     SmallString<128> strValue;
-    apValue.toString(strValue, 6, 0, false);
+    apValue.toString(strValue, /*FormatPrecision=*/6, /*FormatMaxPadding=*/0,
+                     /*TruncateZero=*/false);
 
     // Check to make sure that the stringized number is not some string like
     // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
     // that the string matches the "[-+]?[0-9]" regex.
     assert(((strValue[0] >= '0' && strValue[0] <= '9') ||
             ((strValue[0] == '-' || strValue[0] == '+') &&
              (strValue[1] >= '0' && strValue[1] <= '9'))) &&
            "[-+]?[0-9] regex does not match!");
 
     // Parse back the stringized version and check that the value is equal
-    // (i.e., there is no precision loss). If it is not, use the default format
-    // of APFloat instead of the exponential notation.
-    if (!APFloat(apValue.getSemantics(), strValue).bitwiseIsEqual(apValue)) {
-      strValue.clear();
-      apValue.toString(strValue);
-    }
+    // (i.e., there is no precision loss).
+    if (APFloat(apValue.getSemantics(), strValue).bitwiseIsEqual(apValue)) {
+      os << strValue;
+      return;
+    }
+
+    // If it is not, use the default format of APFloat instead of the
+    // exponential notation.
+
+    // Make sure that we can parse the default form as a float.
+    if (StringRef(strValue).contains('.')) {
       os << strValue;
       return;
     }
+  }
 
-  // Print special values in hexadecimal format.  The sign bit should be
-  // included in the literal.
+  // Print special values in hexadecimal format. The sign bit should be included
+  // in the literal.
   SmallVector<char, 16> str;
   APInt apInt = apValue.bitcastToAPInt();
   apInt.toString(str, /*Radix=*/16, /*Signed=*/false,
                  /*formatAsCLiteral=*/true);
   os << str;
 }
 
 void ModulePrinter::printLocation(LocationAttr loc) {

mlir/test/IR/parser.mlir

func @f64_special_values() {
 
   // F64 positive infinity.
   // CHECK: constant 0x7FF0000000000000 : f64
   %4 = constant 0x7FF0000000000000 : f64
   // F64 negative infinity.
   // CHECK: constant 0xFFF0000000000000 : f64
   %5 = constant 0xFFF0000000000000 : f64
 
+  // Check that values that can't be represented with the default format, use
+  // hex instead.
+  // CHECK: constant 0xC1CDC00000000000 : f64
+  %6 = constant 0xC1CDC00000000000 : f64
+
   return
 }
 
 // FIXME: bfloat16 currently uses f64 as a storage format. This test should be
 // changed when that gets fixed.
 // CHECK-LABEL: @bfloat16_special_values
 func @bfloat16_special_values() {
   // bfloat16 signaling NaNs.