contrib/llvm/tools/lldb/source/Core/DumpDataExtractor.cpp

   1 //===-- DumpDataExtractor.cpp -----------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/DumpDataExtractor.h"
  11
  12 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
  13 #include "lldb/lldb-forward.h" // for TargetSP, DisassemblerSP
  14
  15 #include "lldb/Core/Address.h" // for Address
  16 #include "lldb/Core/Disassembler.h"
  17 #include "lldb/Core/ModuleList.h" // for ModuleList
  18 #include "lldb/Symbol/ClangASTContext.h"
  19 #include "lldb/Target/ExecutionContext.h"
  20 #include "lldb/Target/ExecutionContextScope.h"
  21 #include "lldb/Target/SectionLoadList.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Utility/DataExtractor.h"
  24 #include "lldb/Utility/Stream.h"
  25
  26 #include "clang/AST/ASTContext.h"    // for ASTContext
  27 #include "clang/AST/CanonicalType.h" // for CanQualType
  28
  29 #include "llvm/ADT/APFloat.h"     // for APFloat, APFloatBase:...
  30 #include "llvm/ADT/APInt.h"       // for APInt
  31 #include "llvm/ADT/ArrayRef.h"    // for ArrayRef
  32 #include "llvm/ADT/SmallVector.h" // for SmallVector
  33
  34 #include <limits> // for numeric_limits, numer...
  35 #include <memory> // for shared_ptr
  36 #include <string> // for string, basic_string
  37
  38 #include <assert.h>   // for assert
  39 #include <ctype.h>    // for isprint
  40 #include <inttypes.h> // for PRIu64, PRIx64, PRIX64
  41 #include <math.h>     // for ldexpf
  42
  43 #include <bitset>
  44 #include <sstream>
  45
  46 using namespace lldb_private;
  47 using namespace lldb;
  48
  49 #define NON_PRINTABLE_CHAR '.'
  50
  51 static float half2float(uint16_t half) {
  52   union {
  53     float f;
  54     uint32_t u;
  55   } u;
  56   int32_t v = (int16_t)half;
  57
  58   if (0 == (v & 0x7c00)) {
  59     u.u = v & 0x80007FFFU;
  60     return u.f * ldexpf(1, 125);
  61   }
  62
  63   v <<= 13;
  64   u.u = v | 0x70000000U;
  65   return u.f * ldexpf(1, -112);
  66 }
  67
  68 static bool GetAPInt(const DataExtractor &data, lldb::offset_t *offset_ptr,
  69                      lldb::offset_t byte_size, llvm::APInt &result) {
  70   llvm::SmallVector<uint64_t, 2> uint64_array;
  71   lldb::offset_t bytes_left = byte_size;
  72   uint64_t u64;
  73   const lldb::ByteOrder byte_order = data.GetByteOrder();
  74   if (byte_order == lldb::eByteOrderLittle) {
  75     while (bytes_left > 0) {
  76       if (bytes_left >= 8) {
  77         u64 = data.GetU64(offset_ptr);
  78         bytes_left -= 8;
  79       } else {
  80         u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left);
  81         bytes_left = 0;
  82       }
  83       uint64_array.push_back(u64);
  84     }
  85     result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
  86     return true;
  87   } else if (byte_order == lldb::eByteOrderBig) {
  88     lldb::offset_t be_offset = *offset_ptr + byte_size;
  89     lldb::offset_t temp_offset;
  90     while (bytes_left > 0) {
  91       if (bytes_left >= 8) {
  92         be_offset -= 8;
  93         temp_offset = be_offset;
  94         u64 = data.GetU64(&temp_offset);
  95         bytes_left -= 8;
  96       } else {
  97         be_offset -= bytes_left;
  98         temp_offset = be_offset;
  99         u64 = data.GetMaxU64(&temp_offset, (uint32_t)bytes_left);
 100         bytes_left = 0;
 101       }
 102       uint64_array.push_back(u64);
 103     }
 104     *offset_ptr += byte_size;
 105     result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
 106     return true;
 107   }
 108   return false;
 109 }
 110
 111 static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data,
 112                                 lldb::offset_t offset, lldb::offset_t byte_size,
 113                                 bool is_signed, unsigned radix) {
 114   llvm::APInt apint;
 115   if (GetAPInt(data, &offset, byte_size, apint)) {
 116     std::string apint_str(apint.toString(radix, is_signed));
 117     switch (radix) {
 118     case 2:
 119       s->Write("0b", 2);
 120       break;
 121     case 8:
 122       s->Write("0", 1);
 123       break;
 124     case 10:
 125       break;
 126     }
 127     s->Write(apint_str.c_str(), apint_str.size());
 128   }
 129   return offset;
 130 }
 131
 132 lldb::offset_t lldb_private::DumpDataExtractor(
 133     const DataExtractor &DE, Stream *s, offset_t start_offset,
 134     lldb::Format item_format, size_t item_byte_size, size_t item_count,
 135     size_t num_per_line, uint64_t base_addr,
 136     uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
 137                               // non-zero, the value is a bitfield
 138     uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
 139                               // shift amount to apply to a bitfield
 140     ExecutionContextScope *exe_scope) {
 141   if (s == nullptr)
 142     return start_offset;
 143
 144   if (item_format == eFormatPointer) {
 145     if (item_byte_size != 4 && item_byte_size != 8)
 146       item_byte_size = s->GetAddressByteSize();
 147   }
 148
 149   offset_t offset = start_offset;
 150
 151   if (item_format == eFormatInstruction) {
 152     TargetSP target_sp;
 153     if (exe_scope)
 154       target_sp = exe_scope->CalculateTarget();
 155     if (target_sp) {
 156       DisassemblerSP disassembler_sp(Disassembler::FindPlugin(
 157           target_sp->GetArchitecture(),
 158           target_sp->GetDisassemblyFlavor(), nullptr));
 159       if (disassembler_sp) {
 160         lldb::addr_t addr = base_addr + start_offset;
 161         lldb_private::Address so_addr;
 162         bool data_from_file = true;
 163         if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
 164           data_from_file = false;
 165         } else {
 166           if (target_sp->GetSectionLoadList().IsEmpty() ||
 167               !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
 168             so_addr.SetRawAddress(addr);
 169         }
 170
 171         size_t bytes_consumed = disassembler_sp->DecodeInstructions(
 172             so_addr, DE, start_offset, item_count, false, data_from_file);
 173
 174         if (bytes_consumed) {
 175           offset += bytes_consumed;
 176           const bool show_address = base_addr != LLDB_INVALID_ADDRESS;
 177           const bool show_bytes = true;
 178           ExecutionContext exe_ctx;
 179           exe_scope->CalculateExecutionContext(exe_ctx);
 180           disassembler_sp->GetInstructionList().Dump(s, show_address,
 181                                                      show_bytes, &exe_ctx);
 182         }
 183       }
 184     } else
 185       s->Printf("invalid target");
 186
 187     return offset;
 188   }
 189
 190   if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) &&
 191       item_byte_size > 8)
 192     item_format = eFormatHex;
 193
 194   lldb::offset_t line_start_offset = start_offset;
 195   for (uint32_t count = 0; DE.ValidOffset(offset) && count < item_count;
 196        ++count) {
 197     if ((count % num_per_line) == 0) {
 198       if (count > 0) {
 199         if (item_format == eFormatBytesWithASCII &&
 200             offset > line_start_offset) {
 201           s->Printf("%*s",
 202                     static_cast<int>(
 203                         (num_per_line - (offset - line_start_offset)) * 3 + 2),
 204                     "");
 205           DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
 206                             offset - line_start_offset, SIZE_MAX,
 207                             LLDB_INVALID_ADDRESS, 0, 0);
 208         }
 209         s->EOL();
 210       }
 211       if (base_addr != LLDB_INVALID_ADDRESS)
 212         s->Printf("0x%8.8" PRIx64 ": ",
 213                   (uint64_t)(base_addr +
 214                              (offset - start_offset) / DE.getTargetByteSize()));
 215
 216       line_start_offset = offset;
 217     } else if (item_format != eFormatChar &&
 218                item_format != eFormatCharPrintable &&
 219                item_format != eFormatCharArray && count > 0) {
 220       s->PutChar(' ');
 221     }
 222
 223     switch (item_format) {
 224     case eFormatBoolean:
 225       if (item_byte_size <= 8)
 226         s->Printf("%s", DE.GetMaxU64Bitfield(&offset, item_byte_size,
 227                                              item_bit_size, item_bit_offset)
 228                             ? "true"
 229                             : "false");
 230       else {
 231         s->Printf("error: unsupported byte size (%" PRIu64
 232                   ") for boolean format",
 233                   (uint64_t)item_byte_size);
 234         return offset;
 235       }
 236       break;
 237
 238     case eFormatBinary:
 239       if (item_byte_size <= 8) {
 240         uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
 241                                                item_bit_size, item_bit_offset);
 242         // Avoid std::bitset<64>::to_string() since it is missing in
 243         // earlier C++ libraries
 244         std::string binary_value(64, '0');
 245         std::bitset<64> bits(uval64);
 246         for (uint32_t i = 0; i < 64; ++i)
 247           if (bits[i])
 248             binary_value[64 - 1 - i] = '1';
 249         if (item_bit_size > 0)
 250           s->Printf("0b%s", binary_value.c_str() + 64 - item_bit_size);
 251         else if (item_byte_size > 0 && item_byte_size <= 8)
 252           s->Printf("0b%s", binary_value.c_str() + 64 - item_byte_size * 8);
 253       } else {
 254         const bool is_signed = false;
 255         const unsigned radix = 2;
 256         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
 257       }
 258       break;
 259
 260     case eFormatBytes:
 261     case eFormatBytesWithASCII:
 262       for (uint32_t i = 0; i < item_byte_size; ++i) {
 263         s->Printf("%2.2x", DE.GetU8(&offset));
 264       }
 265
 266       // Put an extra space between the groups of bytes if more than one
 267       // is being dumped in a group (item_byte_size is more than 1).
 268       if (item_byte_size > 1)
 269         s->PutChar(' ');
 270       break;
 271
 272     case eFormatChar:
 273     case eFormatCharPrintable:
 274     case eFormatCharArray: {
 275       // Reject invalid item_byte_size.
 276       if (item_byte_size > 8) {
 277         s->Printf("error: unsupported byte size (%" PRIu64 ") for char format",
 278                   (uint64_t)item_byte_size);
 279         return offset;
 280       }
 281
 282       // If we are only printing one character surround it with single
 283       // quotes
 284       if (item_count == 1 && item_format == eFormatChar)
 285         s->PutChar('\'');
 286
 287       const uint64_t ch = DE.GetMaxU64Bitfield(&offset, item_byte_size,
 288                                                item_bit_size, item_bit_offset);
 289       if (isprint(ch))
 290         s->Printf("%c", (char)ch);
 291       else if (item_format != eFormatCharPrintable) {
 292         switch (ch) {
 293         case '\033':
 294           s->Printf("\\e");
 295           break;
 296         case '\a':
 297           s->Printf("\\a");
 298           break;
 299         case '\b':
 300           s->Printf("\\b");
 301           break;
 302         case '\f':
 303           s->Printf("\\f");
 304           break;
 305         case '\n':
 306           s->Printf("\\n");
 307           break;
 308         case '\r':
 309           s->Printf("\\r");
 310           break;
 311         case '\t':
 312           s->Printf("\\t");
 313           break;
 314         case '\v':
 315           s->Printf("\\v");
 316           break;
 317         case '\0':
 318           s->Printf("\\0");
 319           break;
 320         default:
 321           if (item_byte_size == 1)
 322             s->Printf("\\x%2.2x", (uint8_t)ch);
 323           else
 324             s->Printf("%" PRIu64, ch);
 325           break;
 326         }
 327       } else {
 328         s->PutChar(NON_PRINTABLE_CHAR);
 329       }
 330
 331       // If we are only printing one character surround it with single quotes
 332       if (item_count == 1 && item_format == eFormatChar)
 333         s->PutChar('\'');
 334     } break;
 335
 336     case eFormatEnum: // Print enum value as a signed integer when we don't get
 337                       // the enum type
 338     case eFormatDecimal:
 339       if (item_byte_size <= 8)
 340         s->Printf("%" PRId64,
 341                   DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
 342                                        item_bit_offset));
 343       else {
 344         const bool is_signed = true;
 345         const unsigned radix = 10;
 346         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
 347       }
 348       break;
 349
 350     case eFormatUnsigned:
 351       if (item_byte_size <= 8)
 352         s->Printf("%" PRIu64,
 353                   DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
 354                                        item_bit_offset));
 355       else {
 356         const bool is_signed = false;
 357         const unsigned radix = 10;
 358         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
 359       }
 360       break;
 361
 362     case eFormatOctal:
 363       if (item_byte_size <= 8)
 364         s->Printf("0%" PRIo64,
 365                   DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
 366                                        item_bit_offset));
 367       else {
 368         const bool is_signed = false;
 369         const unsigned radix = 8;
 370         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
 371       }
 372       break;
 373
 374     case eFormatOSType: {
 375       uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
 376                                              item_bit_size, item_bit_offset);
 377       s->PutChar('\'');
 378       for (uint32_t i = 0; i < item_byte_size; ++i) {
 379         uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
 380         if (isprint(ch))
 381           s->Printf("%c", ch);
 382         else {
 383           switch (ch) {
 384           case '\033':
 385             s->Printf("\\e");
 386             break;
 387           case '\a':
 388             s->Printf("\\a");
 389             break;
 390           case '\b':
 391             s->Printf("\\b");
 392             break;
 393           case '\f':
 394             s->Printf("\\f");
 395             break;
 396           case '\n':
 397             s->Printf("\\n");
 398             break;
 399           case '\r':
 400             s->Printf("\\r");
 401             break;
 402           case '\t':
 403             s->Printf("\\t");
 404             break;
 405           case '\v':
 406             s->Printf("\\v");
 407             break;
 408           case '\0':
 409             s->Printf("\\0");
 410             break;
 411           default:
 412             s->Printf("\\x%2.2x", ch);
 413             break;
 414           }
 415         }
 416       }
 417       s->PutChar('\'');
 418     } break;
 419
 420     case eFormatCString: {
 421       const char *cstr = DE.GetCStr(&offset);
 422
 423       if (!cstr) {
 424         s->Printf("NULL");
 425         offset = LLDB_INVALID_OFFSET;
 426       } else {
 427         s->PutChar('\"');
 428
 429         while (const char c = *cstr) {
 430           if (isprint(c)) {
 431             s->PutChar(c);
 432           } else {
 433             switch (c) {
 434             case '\033':
 435               s->Printf("\\e");
 436               break;
 437             case '\a':
 438               s->Printf("\\a");
 439               break;
 440             case '\b':
 441               s->Printf("\\b");
 442               break;
 443             case '\f':
 444               s->Printf("\\f");
 445               break;
 446             case '\n':
 447               s->Printf("\\n");
 448               break;
 449             case '\r':
 450               s->Printf("\\r");
 451               break;
 452             case '\t':
 453               s->Printf("\\t");
 454               break;
 455             case '\v':
 456               s->Printf("\\v");
 457               break;
 458             default:
 459               s->Printf("\\x%2.2x", c);
 460               break;
 461             }
 462           }
 463
 464           ++cstr;
 465         }
 466
 467         s->PutChar('\"');
 468       }
 469     } break;
 470
 471     case eFormatPointer:
 472       s->Address(DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
 473                                       item_bit_offset),
 474                  sizeof(addr_t));
 475       break;
 476
 477     case eFormatComplexInteger: {
 478       size_t complex_int_byte_size = item_byte_size / 2;
 479
 480       if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) {
 481         s->Printf("%" PRIu64,
 482                   DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
 483         s->Printf(" + %" PRIu64 "i",
 484                   DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
 485       } else {
 486         s->Printf("error: unsupported byte size (%" PRIu64
 487                   ") for complex integer format",
 488                   (uint64_t)item_byte_size);
 489         return offset;
 490       }
 491     } break;
 492
 493     case eFormatComplex:
 494       if (sizeof(float) * 2 == item_byte_size) {
 495         float f32_1 = DE.GetFloat(&offset);
 496         float f32_2 = DE.GetFloat(&offset);
 497
 498         s->Printf("%g + %gi", f32_1, f32_2);
 499         break;
 500       } else if (sizeof(double) * 2 == item_byte_size) {
 501         double d64_1 = DE.GetDouble(&offset);
 502         double d64_2 = DE.GetDouble(&offset);
 503
 504         s->Printf("%lg + %lgi", d64_1, d64_2);
 505         break;
 506       } else if (sizeof(long double) * 2 == item_byte_size) {
 507         long double ld64_1 = DE.GetLongDouble(&offset);
 508         long double ld64_2 = DE.GetLongDouble(&offset);
 509         s->Printf("%Lg + %Lgi", ld64_1, ld64_2);
 510         break;
 511       } else {
 512         s->Printf("error: unsupported byte size (%" PRIu64
 513                   ") for complex float format",
 514                   (uint64_t)item_byte_size);
 515         return offset;
 516       }
 517       break;
 518
 519     default:
 520     case eFormatDefault:
 521     case eFormatHex:
 522     case eFormatHexUppercase: {
 523       bool wantsuppercase = (item_format == eFormatHexUppercase);
 524       switch (item_byte_size) {
 525       case 1:
 526       case 2:
 527       case 4:
 528       case 8:
 529         s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64,
 530                   (int)(2 * item_byte_size), (int)(2 * item_byte_size),
 531                   DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
 532                                        item_bit_offset));
 533         break;
 534       default: {
 535         assert(item_bit_size == 0 && item_bit_offset == 0);
 536         const uint8_t *bytes =
 537             (const uint8_t *)DE.GetData(&offset, item_byte_size);
 538         if (bytes) {
 539           s->PutCString("0x");
 540           uint32_t idx;
 541           if (DE.GetByteOrder() == eByteOrderBig) {
 542             for (idx = 0; idx < item_byte_size; ++idx)
 543               s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]);
 544           } else {
 545             for (idx = 0; idx < item_byte_size; ++idx)
 546               s->Printf(wantsuppercase ? "%2.2X" : "%2.2x",
 547                         bytes[item_byte_size - 1 - idx]);
 548           }
 549         }
 550       } break;
 551       }
 552     } break;
 553
 554     case eFormatFloat: {
 555       TargetSP target_sp;
 556       bool used_apfloat = false;
 557       if (exe_scope)
 558         target_sp = exe_scope->CalculateTarget();
 559       if (target_sp) {
 560         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
 561         if (clang_ast) {
 562           clang::ASTContext *ast = clang_ast->getASTContext();
 563           if (ast) {
 564             llvm::SmallVector<char, 256> sv;
 565             // Show full precision when printing float values
 566             const unsigned format_precision = 0;
 567             const unsigned format_max_padding = 100;
 568             size_t item_bit_size = item_byte_size * 8;
 569
 570             if (item_bit_size == ast->getTypeSize(ast->FloatTy)) {
 571               llvm::APInt apint(item_bit_size,
 572                                 DE.GetMaxU64(&offset, item_byte_size));
 573               llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->FloatTy),
 574                                     apint);
 575               apfloat.toString(sv, format_precision, format_max_padding);
 576             } else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) {
 577               llvm::APInt apint;
 578               if (GetAPInt(DE, &offset, item_byte_size, apint)) {
 579                 llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy),
 580                                       apint);
 581                 apfloat.toString(sv, format_precision, format_max_padding);
 582               }
 583             } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) {
 584               const auto &semantics =
 585                   ast->getFloatTypeSemantics(ast->LongDoubleTy);
 586               const auto byte_size =
 587                   (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
 588
 589               llvm::APInt apint;
 590               if (GetAPInt(DE, &offset, byte_size, apint)) {
 591                 llvm::APFloat apfloat(semantics, apint);
 592                 apfloat.toString(sv, format_precision, format_max_padding);
 593               }
 594             } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) {
 595               llvm::APInt apint(item_bit_size, DE.GetU16(&offset));
 596               llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->HalfTy),
 597                                     apint);
 598               apfloat.toString(sv, format_precision, format_max_padding);
 599             }
 600
 601             if (!sv.empty()) {
 602               s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
 603               used_apfloat = true;
 604             }
 605           }
 606         }
 607       }
 608
 609       if (!used_apfloat) {
 610         std::ostringstream ss;
 611         if (item_byte_size == sizeof(float) || item_byte_size == 2) {
 612           float f;
 613           if (item_byte_size == 2) {
 614             uint16_t half = DE.GetU16(&offset);
 615             f = half2float(half);
 616           } else {
 617             f = DE.GetFloat(&offset);
 618           }
 619           ss.precision(std::numeric_limits<float>::digits10);
 620           ss << f;
 621         } else if (item_byte_size == sizeof(double)) {
 622           ss.precision(std::numeric_limits<double>::digits10);
 623           ss << DE.GetDouble(&offset);
 624         } else if (item_byte_size == sizeof(long double) ||
 625                    item_byte_size == 10) {
 626           ss.precision(std::numeric_limits<long double>::digits10);
 627           ss << DE.GetLongDouble(&offset);
 628         } else {
 629           s->Printf("error: unsupported byte size (%" PRIu64
 630                     ") for float format",
 631                     (uint64_t)item_byte_size);
 632           return offset;
 633         }
 634         ss.flush();
 635         s->Printf("%s", ss.str().c_str());
 636       }
 637     } break;
 638
 639     case eFormatUnicode16:
 640       s->Printf("U+%4.4x", DE.GetU16(&offset));
 641       break;
 642
 643     case eFormatUnicode32:
 644       s->Printf("U+0x%8.8x", DE.GetU32(&offset));
 645       break;
 646
 647     case eFormatAddressInfo: {
 648       addr_t addr = DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
 649                                          item_bit_offset);
 650       s->Printf("0x%*.*" PRIx64, (int)(2 * item_byte_size),
 651                 (int)(2 * item_byte_size), addr);
 652       if (exe_scope) {
 653         TargetSP target_sp(exe_scope->CalculateTarget());
 654         lldb_private::Address so_addr;
 655         if (target_sp) {
 656           if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr,
 657                                                                  so_addr)) {
 658             s->PutChar(' ');
 659             so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription,
 660                          Address::DumpStyleModuleWithFileAddress);
 661           } else {
 662             so_addr.SetOffset(addr);
 663             so_addr.Dump(s, exe_scope,
 664                          Address::DumpStyleResolvedPointerDescription);
 665           }
 666         }
 667       }
 668     } break;
 669
 670     case eFormatHexFloat:
 671       if (sizeof(float) == item_byte_size) {
 672         char float_cstr[256];
 673         llvm::APFloat ap_float(DE.GetFloat(&offset));
 674         ap_float.convertToHexString(float_cstr, 0, false,
 675                                     llvm::APFloat::rmNearestTiesToEven);
 676         s->Printf("%s", float_cstr);
 677         break;
 678       } else if (sizeof(double) == item_byte_size) {
 679         char float_cstr[256];
 680         llvm::APFloat ap_float(DE.GetDouble(&offset));
 681         ap_float.convertToHexString(float_cstr, 0, false,
 682                                     llvm::APFloat::rmNearestTiesToEven);
 683         s->Printf("%s", float_cstr);
 684         break;
 685       } else {
 686         s->Printf("error: unsupported byte size (%" PRIu64
 687                   ") for hex float format",
 688                   (uint64_t)item_byte_size);
 689         return offset;
 690       }
 691       break;
 692
 693     // please keep the single-item formats below in sync with
 694     // FormatManager::GetSingleItemFormat
 695     // if you fail to do so, users will start getting different outputs
 696     // depending on internal
 697     // implementation details they should not care about ||
 698     case eFormatVectorOfChar: //   ||
 699       s->PutChar('{');        //   \/
 700       offset =
 701           DumpDataExtractor(DE, s, offset, eFormatCharArray, 1, item_byte_size,
 702                             item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
 703       s->PutChar('}');
 704       break;
 705
 706     case eFormatVectorOfSInt8:
 707       s->PutChar('{');
 708       offset =
 709           DumpDataExtractor(DE, s, offset, eFormatDecimal, 1, item_byte_size,
 710                             item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
 711       s->PutChar('}');
 712       break;
 713
 714     case eFormatVectorOfUInt8:
 715       s->PutChar('{');
 716       offset = DumpDataExtractor(DE, s, offset, eFormatHex, 1, item_byte_size,
 717                                  item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
 718       s->PutChar('}');
 719       break;
 720
 721     case eFormatVectorOfSInt16:
 722       s->PutChar('{');
 723       offset = DumpDataExtractor(
 724           DE, s, offset, eFormatDecimal, sizeof(uint16_t),
 725           item_byte_size / sizeof(uint16_t), item_byte_size / sizeof(uint16_t),
 726           LLDB_INVALID_ADDRESS, 0, 0);
 727       s->PutChar('}');
 728       break;
 729
 730     case eFormatVectorOfUInt16:
 731       s->PutChar('{');
 732       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint16_t),
 733                                  item_byte_size / sizeof(uint16_t),
 734                                  item_byte_size / sizeof(uint16_t),
 735                                  LLDB_INVALID_ADDRESS, 0, 0);
 736       s->PutChar('}');
 737       break;
 738
 739     case eFormatVectorOfSInt32:
 740       s->PutChar('{');
 741       offset = DumpDataExtractor(
 742           DE, s, offset, eFormatDecimal, sizeof(uint32_t),
 743           item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t),
 744           LLDB_INVALID_ADDRESS, 0, 0);
 745       s->PutChar('}');
 746       break;
 747
 748     case eFormatVectorOfUInt32:
 749       s->PutChar('{');
 750       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint32_t),
 751                                  item_byte_size / sizeof(uint32_t),
 752                                  item_byte_size / sizeof(uint32_t),
 753                                  LLDB_INVALID_ADDRESS, 0, 0);
 754       s->PutChar('}');
 755       break;
 756
 757     case eFormatVectorOfSInt64:
 758       s->PutChar('{');
 759       offset = DumpDataExtractor(
 760           DE, s, offset, eFormatDecimal, sizeof(uint64_t),
 761           item_byte_size / sizeof(uint64_t), item_byte_size / sizeof(uint64_t),
 762           LLDB_INVALID_ADDRESS, 0, 0);
 763       s->PutChar('}');
 764       break;
 765
 766     case eFormatVectorOfUInt64:
 767       s->PutChar('{');
 768       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint64_t),
 769                                  item_byte_size / sizeof(uint64_t),
 770                                  item_byte_size / sizeof(uint64_t),
 771                                  LLDB_INVALID_ADDRESS, 0, 0);
 772       s->PutChar('}');
 773       break;
 774
 775     case eFormatVectorOfFloat16:
 776       s->PutChar('{');
 777       offset =
 778           DumpDataExtractor(DE, s, offset, eFormatFloat, 2, item_byte_size / 2,
 779                             item_byte_size / 2, LLDB_INVALID_ADDRESS, 0, 0);
 780       s->PutChar('}');
 781       break;
 782
 783     case eFormatVectorOfFloat32:
 784       s->PutChar('{');
 785       offset =
 786           DumpDataExtractor(DE, s, offset, eFormatFloat, 4, item_byte_size / 4,
 787                             item_byte_size / 4, LLDB_INVALID_ADDRESS, 0, 0);
 788       s->PutChar('}');
 789       break;
 790
 791     case eFormatVectorOfFloat64:
 792       s->PutChar('{');
 793       offset =
 794           DumpDataExtractor(DE, s, offset, eFormatFloat, 8, item_byte_size / 8,
 795                             item_byte_size / 8, LLDB_INVALID_ADDRESS, 0, 0);
 796       s->PutChar('}');
 797       break;
 798
 799     case eFormatVectorOfUInt128:
 800       s->PutChar('{');
 801       offset =
 802           DumpDataExtractor(DE, s, offset, eFormatHex, 16, item_byte_size / 16,
 803                             item_byte_size / 16, LLDB_INVALID_ADDRESS, 0, 0);
 804       s->PutChar('}');
 805       break;
 806     }
 807   }
 808
 809   if (item_format == eFormatBytesWithASCII && offset > line_start_offset) {
 810     s->Printf("%*s", static_cast<int>(
 811                          (num_per_line - (offset - line_start_offset)) * 3 + 2),
 812               "");
 813     DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
 814                       offset - line_start_offset, SIZE_MAX,
 815                       LLDB_INVALID_ADDRESS, 0, 0);
 816   }
 817   return offset; // Return the offset at which we ended up
 818 }
 819
 820 void lldb_private::DumpHexBytes(Stream *s, const void *src, size_t src_len,
 821                                 uint32_t bytes_per_line,
 822                                 lldb::addr_t base_addr) {
 823   DataExtractor data(src, src_len, lldb::eByteOrderLittle, 4);
 824   DumpDataExtractor(data, s,
 825                     0,                  // Offset into "src"
 826                     lldb::eFormatBytes, // Dump as hex bytes
 827                     1,              // Size of each item is 1 for single bytes
 828                     src_len,        // Number of bytes
 829                     bytes_per_line, // Num bytes per line
 830                     base_addr,      // Base address
 831                     0, 0);          // Bitfield info
 832 }