[lldb] Always use APFloat for FP dumping

[labath]

Summary

The DumpDataExtractor function had two branches for printing floating
point values. One branch (APFloat) was used if we had a Target object
around and could query it for the appropriate semantics. If we didn't
have a Target, we used host operations to read and format the value.

This patch changes second path to use APFloat as well. To make it work,
I pick reasonable defaults for different byte size. Notably, I did not
include x87 long double in that list (as it is ambibuous and
architecture-specific). This exposed a bug where we were printing
register values using the target-less branch, even though the registers
definitely belong to a target, and we had it available. Fixing this
prompted the update of several tests for register values due to slightly
different floating point outputs.

The most dubious aspect of this patch is the change in
TypeSystemClang::GetFloatTypeSemantics to recognize 10 as a valid size
for x87 long double. This was necessary because because sizeof(long
double) on x86_64 is 16 even though it only holds 10 bytes of useful
data. This generalizes the hackaround present in the target-free branch
of the dumping function.

[Emmmer]

Confirmed LLDBCoreTests passed after applying this patch on the riscv64 platform.
Superseding D129736

[DavidSpickett]

I'm no float expert but seems fine. Also checked on AArch64 and no failures there.

[DavidSpickett]

@labath Did you forget about this?

[labath]

In D129750#3681676, @DavidSpickett wrote:

@labath Did you forget about this?

Yeah, pretty much that. Committed now.

lldb/include/lldb/Core/DumpRegisterValue.h

 //===-- DumpRegisterValue.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 LLDB_CORE_DUMPREGISTERVALUE_H
 #define LLDB_CORE_DUMPREGISTERVALUE_H
 
 #include "lldb/lldb-enumerations.h"
 #include <cstdint>
 
 namespace lldb_private {
 
+class ExecutionContextScope;
 class RegisterValue;
 struct RegisterInfo;
 class Stream;
 
 // The default value of 0 for reg_name_right_align_at means no alignment at
 // all.
 bool DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
                        const RegisterInfo *reg_info, bool prefix_with_name,
                        bool prefix_with_alt_name, lldb::Format format,
-                       uint32_t reg_name_right_align_at = 0);
+                       uint32_t reg_name_right_align_at = 0,
+                       ExecutionContextScope *exe_scope = nullptr);
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_DUMPREGISTERVALUE_H

lldb/source/Commands/CommandObjectRegister.cpp

if (reg_info) {
       RegisterValue reg_value;
 
       if (reg_ctx->ReadRegister(reg_info, reg_value)) {
         strm.Indent();
 
         bool prefix_with_altname = (bool)m_command_options.alternate_name;
         bool prefix_with_name = !prefix_with_altname;
         DumpRegisterValue(reg_value, &strm, reg_info, prefix_with_name,
-                          prefix_with_altname, m_format_options.GetFormat(), 8);
+                          prefix_with_altname, m_format_options.GetFormat(), 8,
+                          exe_ctx.GetBestExecutionContextScope());
         if ((reg_info->encoding == eEncodingUint) ||
             (reg_info->encoding == eEncodingSint)) {
           Process *process = exe_ctx.GetProcessPtr();
           if (process && reg_info->byte_size == process->GetAddressByteSize()) {
             addr_t reg_addr = reg_value.GetAsUInt64(LLDB_INVALID_ADDRESS);
             if (reg_addr != LLDB_INVALID_ADDRESS) {
               Address so_reg_addr;
               if (exe_ctx.GetTargetRef()

lldb/source/Core/DumpDataExtractor.cpp

 #include <bitset>
 #include <sstream>
 
 using namespace lldb_private;
 using namespace lldb;
 
 #define NON_PRINTABLE_CHAR '.'
 
-static float half2float(uint16_t half) {
-  union {
-    float f;
-    uint32_t u;
-  } u;
-  // Sign extend to 4 byte.
-  int32_t sign_extended = static_cast<int16_t>(half);
-  uint32_t v = static_cast<uint32_t>(sign_extended);
-
-  if (0 == (v & 0x7c00)) {
-    u.u = v & 0x80007FFFU;
-    return u.f * ldexpf(1, 125);
-  }
-
-  v <<= 13;
-  u.u = v | 0x70000000U;
-  return u.f * ldexpf(1, -112);
-}
-
 static llvm::Optional<llvm::APInt> GetAPInt(const DataExtractor &data,
                                             lldb::offset_t *offset_ptr,
                                             lldb::offset_t byte_size) {
   if (byte_size == 0)
     return llvm::None;
 
   llvm::SmallVector<uint64_t, 2> uint64_array;
   lldb::offset_t bytes_left = byte_size;
for (auto tag : tags) {
     if (tag)
       s->Printf(" 0x%" PRIx64, *tag);
     else
       s->PutCString(" <no tag>");
   }
   s->PutCString(")");
 }
 
+static const llvm::fltSemantics &GetFloatSemantics(const TargetSP &target_sp,
+                                                   size_t byte_size) {
+  if (target_sp) {
+    if (auto type_system_or_err =
+            target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC))
+      return type_system_or_err->GetFloatTypeSemantics(byte_size);
+    else
+      llvm::consumeError(type_system_or_err.takeError());
+  }
+  // No target, just make a reasonable guess
+  switch(byte_size) {
+    case 2:
+      return llvm::APFloat::IEEEhalf();
+    case 4:
+      return llvm::APFloat::IEEEsingle();
+    case 8:
+      return llvm::APFloat::IEEEdouble();
+  }
+  return llvm::APFloat::Bogus();
+}
+
 lldb::offset_t lldb_private::DumpDataExtractor(
     const DataExtractor &DE, Stream *s, offset_t start_offset,
     lldb::Format item_format, size_t item_byte_size, size_t item_count,
     size_t num_per_line, uint64_t base_addr,
     uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
                               // non-zero, the value is a bitfield
     uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
                               // shift amount to apply to a bitfield
case eFormatHexUppercase: {
           }
         }
       } break;
       }
     } break;
 
     case eFormatFloat: {
       TargetSP target_sp;
-      bool used_upfloat = false;
       if (exe_scope)
         target_sp = exe_scope->CalculateTarget();
-      if (target_sp) {
-        auto type_system_or_err =
-            target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
-        if (!type_system_or_err) {
-          llvm::consumeError(type_system_or_err.takeError());
-        } else {
-          auto &type_system = *type_system_or_err;
-          llvm::SmallVector<char, 256> sv;
-          // Show full precision when printing float values
-          const unsigned format_precision = 0;
-          const unsigned format_max_padding =
-              target_sp->GetMaxZeroPaddingInFloatFormat();
+
+      llvm::Optional<unsigned> format_max_padding;
+      if (target_sp)
+        format_max_padding = target_sp->GetMaxZeroPaddingInFloatFormat();
+
 
-          const auto &semantics =
-              type_system.GetFloatTypeSemantics(item_byte_size);
+      const llvm::fltSemantics &semantics =
+          GetFloatSemantics(target_sp, item_byte_size);
 
-          // Recalculate the byte size in case of a difference. This is possible
-          // when item_byte_size is 16 (128-bit), because you could get back the
-          // x87DoubleExtended semantics which has a byte size of 10 (80-bit).
-          const size_t semantics_byte_size =
-              (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
-          llvm::Optional<llvm::APInt> apint =
-              GetAPInt(DE, &offset, semantics_byte_size);
-          if (apint) {
-            llvm::APFloat apfloat(semantics, apint.value());
-            apfloat.toString(sv, format_precision, format_max_padding);
-            if (!sv.empty()) {
-              s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
-              used_upfloat = true;
-            }
-          }
-        }
-      }
-
-      if (!used_upfloat) {
-        std::ostringstream ss;
-        if (item_byte_size == sizeof(float) || item_byte_size == 2) {
-          float f;
-          if (item_byte_size == 2) {
-            uint16_t half = DE.GetU16(&offset);
-            f = half2float(half);
-          } else {
-            f = DE.GetFloat(&offset);
-          }
-          ss.precision(std::numeric_limits<float>::digits10);
-          DumpFloatingPoint(ss, f);
-        } else if (item_byte_size == sizeof(double)) {
-          ss.precision(std::numeric_limits<double>::digits10);
-          DumpFloatingPoint(ss, DE.GetDouble(&offset));
-        } else if (item_byte_size == sizeof(long double) ||
-                   item_byte_size == 10) {
-          ss.precision(std::numeric_limits<long double>::digits10);
-          DumpFloatingPoint(ss, DE.GetLongDouble(&offset));
-        } else {
-          s->Printf("error: unsupported byte size (%" PRIu64
-                    ") for float format",
-                    (uint64_t)item_byte_size);
-          return offset;
-        }
-        ss.flush();
-        s->Printf("%s", ss.str().c_str());
-      }
+        llvm::SmallVector<char, 256> sv;
+        if (format_max_padding)
+          apfloat.toString(sv, format_precision, *format_max_padding);
+        else
+          apfloat.toString(sv, format_precision);
+        s->AsRawOstream() << sv;
+        s->Format("error: unsupported byte size ({0}) for float format",
+                  item_byte_size);
     } break;
 
     case eFormatUnicode16:
       s->Printf("U+%4.4x", DE.GetU16(&offset));
       break;
 
     case eFormatUnicode32:
       s->Printf("U+0x%8.8x", DE.GetU32(&offset));

lldb/source/Core/DumpRegisterValue.cpp

 #include "lldb/lldb-private-types.h"
 
 using namespace lldb;
 
 bool lldb_private::DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
                                      const RegisterInfo *reg_info,
                                      bool prefix_with_name,
                                      bool prefix_with_alt_name, Format format,
-                                     uint32_t reg_name_right_align_at) {
+                                     uint32_t reg_name_right_align_at,
+                                     ExecutionContextScope *exe_scope) {
   DataExtractor data;
   if (reg_val.GetData(data)) {
     bool name_printed = false;
     // For simplicity, alignment of the register name printing applies only in
     // the most common case where:
     //
     //     prefix_with_name^prefix_with_alt_name is true
     //
if (reg_val.GetData(data)) {
     DumpDataExtractor(data, s,
                       0,                    // Offset in "data"
                       format,               // Format to use when dumping
                       reg_info->byte_size,  // item_byte_size
                       1,                    // item_count
                       UINT32_MAX,           // num_per_line
                       LLDB_INVALID_ADDRESS, // base_addr
                       0,                    // item_bit_size
-                      0);                   // item_bit_offset
+                      0,                    // item_bit_offset
+                      exe_scope);
     return true;
   }
   return false;
 }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 const llvm::fltSemantics &
 TypeSystemClang::GetFloatTypeSemantics(size_t byte_size) {
   clang::ASTContext &ast = getASTContext();
   const size_t bit_size = byte_size * 8;
   if (bit_size == ast.getTypeSize(ast.FloatTy))
     return ast.getFloatTypeSemantics(ast.FloatTy);
   else if (bit_size == ast.getTypeSize(ast.DoubleTy))
     return ast.getFloatTypeSemantics(ast.DoubleTy);
-  else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
+  else if (bit_size == ast.getTypeSize(ast.LongDoubleTy) ||
+           bit_size == llvm::APFloat::semanticsSizeInBits(
+                           ast.getFloatTypeSemantics(ast.LongDoubleTy)))
     return ast.getFloatTypeSemantics(ast.LongDoubleTy);
   else if (bit_size == ast.getTypeSize(ast.HalfTy))
     return ast.getFloatTypeSemantics(ast.HalfTy);
   return llvm::APFloatBase::Bogus();
 }
 
 Optional<uint64_t>
 TypeSystemClang::GetBitSize(lldb::opaque_compiler_type_t type,

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

def test_aarch64_regs(self):
         values["v28"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["v31"] = "{0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30}"
         values["s2"] = "0"
         values["s3"] = "0"
         values["s4"] = "4.5"
         values["s5"] = "5.5"
         values["s6"] = "6.5"
         values["s7"] = "7.5"
-        values["s8"] = "1.14437e-28"
+        values["s8"] = "1.14437421E-28"
         values["s30"] = "0"
-        values["s31"] = "6.40969e-10"
+        values["s31"] = "6.40969056E-10"
         values["d0"] = "0.5"
         values["d1"] = "1.5"
         values["d2"] = "2.5"
         values["d3"] = "3.5"
-        values["d4"] = "5.35161536149201e-315"
-        values["d5"] = "5.36197666906508e-315"
-        values["d6"] = "5.37233797663815e-315"
-        values["d7"] = "5.38269928421123e-315"
-        values["d8"] = "1.80107573659442e-226"
+        values["d4"] = "5.3516153614920076E-315"
+        values["d5"] = "5.3619766690650802E-315"
+        values["d6"] = "5.3723379766381528E-315"
+        values["d7"] = "5.3826992842112254E-315"
+        values["d8"] = "1.8010757365944223E-226"
         values["d30"] = "0"
-        values["d31"] = "1.39804328609529e-76"
+        values["d31"] = "1.3980432860952889E-76"
         values["fpsr"] = "0x00000000"
         values["fpcr"] = "0x00000000"
 
         for regname, value in values.items():
             self.expect("register read {}".format(regname),
                         substrs=["{} = {}".format(regname, value)])
 
         self.expect("register read --all")
def test_aarch64_sve_regs_fpsimd(self):
         values["v28"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["v31"] = "{0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30}"
         values["s2"] = "0"
         values["s3"] = "0"
         values["s4"] = "4.5"
         values["s5"] = "5.5"
         values["s6"] = "6.5"
         values["s7"] = "7.5"
-        values["s8"] = "1.14437e-28"
+        values["s8"] = "1.14437421E-28"
         values["s30"] = "0"
-        values["s31"] = "6.40969e-10"
+        values["s31"] = "6.40969056E-10"
         values["d0"] = "0.5"
         values["d1"] = "1.5"
         values["d2"] = "2.5"
         values["d3"] = "3.5"
-        values["d4"] = "5.35161536149201e-315"
-        values["d5"] = "5.36197666906508e-315"
-        values["d6"] = "5.37233797663815e-315"
-        values["d7"] = "5.38269928421123e-315"
-        values["d8"] = "1.80107573659442e-226"
+        values["d4"] = "5.3516153614920076E-315"
+        values["d5"] = "5.3619766690650802E-315"
+        values["d6"] = "5.3723379766381528E-315"
+        values["d7"] = "5.3826992842112254E-315"
+        values["d8"] = "1.8010757365944223E-226"
         values["d30"] = "0"
-        values["d31"] = "1.39804328609529e-76"
+        values["d31"] = "1.3980432860952889E-76"
         values["fpsr"] = "0x00000000"
         values["fpcr"] = "0x00000000"
         values["vg"] = "0x0000000000000004"
         values["z0"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0xe0 0x3f 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["z1"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0xf8 0x3f 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["z2"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x04 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["z3"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x0c 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["z4"] = "{0x00 0x00 0x90 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
def test_aarch64_sve_regs_full(self):
         values["v3"] = "{0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41}"
         values["s0"] = "7.5"
         values["s1"] = "11.5"
         values["s2"] = "0"
         values["s3"] = "15.5"
         values["d0"] = "65536.0158538818"
         values["d1"] = "1572864.25476074"
         values["d2"] = "0"
-        values["d3"] = "25165828.0917969"
+        values["d3"] = "25165828.091796875"
         values["vg"] = "0x0000000000000004"
         values["z0"] = "{0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40}"
         values["z1"] = "{0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41}"
         values["z2"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
         values["z3"] = "{0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41}"
         values["p0"] = "{0x11 0x11 0x11 0x11}"
         values["p1"] = "{0x11 0x11 0x11 0x11}"
         values["p2"] = "{0x00 0x00 0x00 0x00}"

lldb/unittests/Core/DumpDataExtractorTest.cpp

TEST(DumpDataExtractorTest, Formats) {
 
   TestDump(llvm::StringRef("aardvark"), lldb::Format::eFormatCString,
            "\"aardvark\"");
   TestDump<uint16_t>(99, lldb::Format::eFormatDecimal, "99");
   // Just prints as a signed integer.
   TestDump(-1, lldb::Format::eFormatEnum, "-1");
   TestDump(0xcafef00d, lldb::Format::eFormatHex, "0xcafef00d");
   TestDump(0xcafef00d, lldb::Format::eFormatHexUppercase, "0xCAFEF00D");
-  TestDump(0.456, lldb::Format::eFormatFloat, "0.456");
+  TestDump(0.456, lldb::Format::eFormatFloat, "0.45600000000000002");
   TestDump(9, lldb::Format::eFormatOctal, "011");
   // Chars packed into an integer.
   TestDump<uint32_t>(0x4C4C4442, lldb::Format::eFormatOSType, "'LLDB'");
   // Unicode8 doesn't have a specific formatter.
   TestDump<uint8_t>(0x34, lldb::Format::eFormatUnicode8, "0x34");
   TestDump<uint16_t>(0x1122, lldb::Format::eFormatUnicode16, "U+1122");
   TestDump<uint32_t>(0x12345678, lldb::Format::eFormatUnicode32,
                      "U+0x12345678");
TestDump(std::vector<uint64_t>{0, 0xaaaabbbbccccdddd},
            "{0x0000000000000000 0xaaaabbbbccccdddd}");
 
   // See half2float for format details.
   // Test zeroes.
   TestDump(std::vector<uint16_t>{0x0000, 0x8000},
            lldb::Format::eFormatVectorOfFloat16, "{0 -0}");
   // Some subnormal numbers.
   TestDump(std::vector<uint16_t>{0x0001, 0x8001},
-           lldb::Format::eFormatVectorOfFloat16, "{5.96046e-08 -5.96046e-08}");
+           lldb::Format::eFormatVectorOfFloat16, "{5.9605E-8 -5.9605E-8}");
   // A full mantisse and empty expontent.
   TestDump(std::vector<uint16_t>{0x83ff, 0x03ff},
-           lldb::Format::eFormatVectorOfFloat16, "{-6.09756e-05 6.09756e-05}");
+           lldb::Format::eFormatVectorOfFloat16, "{-6.0976E-5 6.0976E-5}");
   // Some normal numbers.
   TestDump(std::vector<uint16_t>{0b0100001001001000},
-           lldb::Format::eFormatVectorOfFloat16,
-#if defined(_MSC_VER) && _MSC_VER < 1920
-           // FIXME: This should print the same on all platforms.
-           "{3.14063}");
-#else
-           "{3.14062}");
-#endif
+           lldb::Format::eFormatVectorOfFloat16, "{3.1406}");
   // Largest and smallest normal number.
   TestDump(std::vector<uint16_t>{0x0400, 0x7bff},
-           lldb::Format::eFormatVectorOfFloat16, "{6.10352e-05 65504}");
+           lldb::Format::eFormatVectorOfFloat16, "{6.1035E-5 65504}");
   TestDump(std::vector<uint16_t>{0xabcd, 0x1234},
-           lldb::Format::eFormatVectorOfFloat16, "{-0.0609436 0.000757217}");
+           lldb::Format::eFormatVectorOfFloat16, "{-0.060944 7.5722E-4}");
 
   // quiet/signaling NaNs.
   TestDump(std::vector<uint16_t>{0xffff, 0xffc0, 0x7fff, 0x7fc0},
-           lldb::Format::eFormatVectorOfFloat16, "{-nan -nan nan nan}");
+           lldb::Format::eFormatVectorOfFloat16, "{NaN NaN NaN NaN}");
   // +/-Inf.
   TestDump(std::vector<uint16_t>{0xfc00, 0x7c00},
-           lldb::Format::eFormatVectorOfFloat16, "{-inf inf}");
+           lldb::Format::eFormatVectorOfFloat16, "{-Inf +Inf}");
 
   TestDump(std::vector<float>{std::numeric_limits<float>::min(),
                               std::numeric_limits<float>::max()},
-           lldb::Format::eFormatVectorOfFloat32, "{1.17549e-38 3.40282e+38}");
+           lldb::Format::eFormatVectorOfFloat32,
+           "{1.17549435E-38 3.40282347E+38}");
   TestDump(std::vector<float>{std::numeric_limits<float>::quiet_NaN(),
                               std::numeric_limits<float>::signaling_NaN(),
                               -std::numeric_limits<float>::quiet_NaN(),
                               -std::numeric_limits<float>::signaling_NaN()},
-           lldb::Format::eFormatVectorOfFloat32, "{nan nan -nan -nan}");
+           lldb::Format::eFormatVectorOfFloat32, "{NaN NaN NaN NaN}");
   TestDump(std::vector<double>{std::numeric_limits<double>::min(),
                                std::numeric_limits<double>::max()},
            lldb::Format::eFormatVectorOfFloat64,
-           "{2.2250738585072e-308 1.79769313486232e+308}");
+           "{2.2250738585072014E-308 1.7976931348623157E+308}");
   TestDump(
       std::vector<double>{
           std::numeric_limits<double>::quiet_NaN(),
           std::numeric_limits<double>::signaling_NaN(),
           -std::numeric_limits<double>::quiet_NaN(),
           -std::numeric_limits<double>::signaling_NaN(),
       },
-      lldb::Format::eFormatVectorOfFloat64, "{nan nan -nan -nan}");
+      lldb::Format::eFormatVectorOfFloat64, "{NaN NaN NaN NaN}");
 
   // Not sure we can rely on having uint128_t everywhere so emulate with
   // uint64_t.
   TestDump(
       std::vector<uint64_t>{0x1, 0x1111222233334444, 0xaaaabbbbccccdddd, 0x0},
       lldb::Format::eFormatVectorOfUInt128,
       "{0x11112222333344440000000000000001 "
       "0x0000000000000000aaaabbbbccccdddd}");