1 //===-- DumpDataExtractor.cpp ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Core/DumpDataExtractor.h"
10 
11 #include "lldb/lldb-defines.h"
12 #include "lldb/lldb-forward.h"
13 
14 #include "lldb/Core/Address.h"
15 #include "lldb/Core/Disassembler.h"
16 #include "lldb/Core/ModuleList.h"
17 #include "lldb/Target/ABI.h"
18 #include "lldb/Target/ExecutionContext.h"
19 #include "lldb/Target/ExecutionContextScope.h"
20 #include "lldb/Target/MemoryRegionInfo.h"
21 #include "lldb/Target/MemoryTagManager.h"
22 #include "lldb/Target/MemoryTagMap.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/SectionLoadList.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Utility/DataExtractor.h"
27 #include "lldb/Utility/Log.h"
28 #include "lldb/Utility/Stream.h"
29 
30 #include "llvm/ADT/APFloat.h"
31 #include "llvm/ADT/APInt.h"
32 #include "llvm/ADT/ArrayRef.h"
33 #include "llvm/ADT/Optional.h"
34 #include "llvm/ADT/SmallVector.h"
35 
36 #include <limits>
37 #include <memory>
38 #include <string>
39 
40 #include <cassert>
41 #include <cctype>
42 #include <cinttypes>
43 #include <cmath>
44 
45 #include <bitset>
46 #include <sstream>
47 
48 using namespace lldb_private;
49 using namespace lldb;
50 
51 #define NON_PRINTABLE_CHAR '.'
52 
half2float(uint16_t half)53 static float half2float(uint16_t half) {
54   union {
55     float f;
56     uint32_t u;
57   } u;
58   // Sign extend to 4 byte.
59   int32_t sign_extended = static_cast<int16_t>(half);
60   uint32_t v = static_cast<uint32_t>(sign_extended);
61 
62   if (0 == (v & 0x7c00)) {
63     u.u = v & 0x80007FFFU;
64     return u.f * ldexpf(1, 125);
65   }
66 
67   v <<= 13;
68   u.u = v | 0x70000000U;
69   return u.f * ldexpf(1, -112);
70 }
71 
GetAPInt(const DataExtractor & data,lldb::offset_t * offset_ptr,lldb::offset_t byte_size)72 static llvm::Optional<llvm::APInt> GetAPInt(const DataExtractor &data,
73                                             lldb::offset_t *offset_ptr,
74                                             lldb::offset_t byte_size) {
75   if (byte_size == 0)
76     return llvm::None;
77 
78   llvm::SmallVector<uint64_t, 2> uint64_array;
79   lldb::offset_t bytes_left = byte_size;
80   uint64_t u64;
81   const lldb::ByteOrder byte_order = data.GetByteOrder();
82   if (byte_order == lldb::eByteOrderLittle) {
83     while (bytes_left > 0) {
84       if (bytes_left >= 8) {
85         u64 = data.GetU64(offset_ptr);
86         bytes_left -= 8;
87       } else {
88         u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left);
89         bytes_left = 0;
90       }
91       uint64_array.push_back(u64);
92     }
93     return llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
94   } else if (byte_order == lldb::eByteOrderBig) {
95     lldb::offset_t be_offset = *offset_ptr + byte_size;
96     lldb::offset_t temp_offset;
97     while (bytes_left > 0) {
98       if (bytes_left >= 8) {
99         be_offset -= 8;
100         temp_offset = be_offset;
101         u64 = data.GetU64(&temp_offset);
102         bytes_left -= 8;
103       } else {
104         be_offset -= bytes_left;
105         temp_offset = be_offset;
106         u64 = data.GetMaxU64(&temp_offset, (uint32_t)bytes_left);
107         bytes_left = 0;
108       }
109       uint64_array.push_back(u64);
110     }
111     *offset_ptr += byte_size;
112     return llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
113   }
114   return llvm::None;
115 }
116 
DumpAPInt(Stream * s,const DataExtractor & data,lldb::offset_t offset,lldb::offset_t byte_size,bool is_signed,unsigned radix)117 static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data,
118                                 lldb::offset_t offset, lldb::offset_t byte_size,
119                                 bool is_signed, unsigned radix) {
120   llvm::Optional<llvm::APInt> apint = GetAPInt(data, &offset, byte_size);
121   if (apint) {
122     std::string apint_str = toString(apint.value(), radix, is_signed);
123     switch (radix) {
124     case 2:
125       s->Write("0b", 2);
126       break;
127     case 8:
128       s->Write("0", 1);
129       break;
130     case 10:
131       break;
132     }
133     s->Write(apint_str.c_str(), apint_str.size());
134   }
135   return offset;
136 }
137 
138 /// Dumps decoded instructions to a stream.
DumpInstructions(const DataExtractor & DE,Stream * s,ExecutionContextScope * exe_scope,offset_t start_offset,uint64_t base_addr,size_t number_of_instructions)139 static lldb::offset_t DumpInstructions(const DataExtractor &DE, Stream *s,
140                                        ExecutionContextScope *exe_scope,
141                                        offset_t start_offset,
142                                        uint64_t base_addr,
143                                        size_t number_of_instructions) {
144   offset_t offset = start_offset;
145 
146   TargetSP target_sp;
147   if (exe_scope)
148     target_sp = exe_scope->CalculateTarget();
149   if (target_sp) {
150     DisassemblerSP disassembler_sp(
151         Disassembler::FindPlugin(target_sp->GetArchitecture(),
152                                  target_sp->GetDisassemblyFlavor(), nullptr));
153     if (disassembler_sp) {
154       lldb::addr_t addr = base_addr + start_offset;
155       lldb_private::Address so_addr;
156       bool data_from_file = true;
157       if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
158         data_from_file = false;
159       } else {
160         if (target_sp->GetSectionLoadList().IsEmpty() ||
161             !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
162           so_addr.SetRawAddress(addr);
163       }
164 
165       size_t bytes_consumed = disassembler_sp->DecodeInstructions(
166           so_addr, DE, start_offset, number_of_instructions, false,
167           data_from_file);
168 
169       if (bytes_consumed) {
170         offset += bytes_consumed;
171         const bool show_address = base_addr != LLDB_INVALID_ADDRESS;
172         const bool show_bytes = true;
173         const bool show_control_flow_kind = true;
174         ExecutionContext exe_ctx;
175         exe_scope->CalculateExecutionContext(exe_ctx);
176         disassembler_sp->GetInstructionList().Dump(
177             s, show_address, show_bytes, show_control_flow_kind, &exe_ctx);
178       }
179     }
180   } else
181     s->Printf("invalid target");
182 
183   return offset;
184 }
185 
186 /// Prints the specific escape sequence of the given character to the stream.
187 /// If the character doesn't have a known specific escape sequence (e.g., '\a',
188 /// '\n' but not generic escape sequences such as'\x12'), this function will
189 /// not modify the stream and return false.
TryDumpSpecialEscapedChar(Stream & s,const char c)190 static bool TryDumpSpecialEscapedChar(Stream &s, const char c) {
191   switch (c) {
192   case '\033':
193     // Common non-standard escape code for 'escape'.
194     s.Printf("\\e");
195     return true;
196   case '\a':
197     s.Printf("\\a");
198     return true;
199   case '\b':
200     s.Printf("\\b");
201     return true;
202   case '\f':
203     s.Printf("\\f");
204     return true;
205   case '\n':
206     s.Printf("\\n");
207     return true;
208   case '\r':
209     s.Printf("\\r");
210     return true;
211   case '\t':
212     s.Printf("\\t");
213     return true;
214   case '\v':
215     s.Printf("\\v");
216     return true;
217   case '\0':
218     s.Printf("\\0");
219     return true;
220   default:
221     return false;
222   }
223 }
224 
225 /// Dump the character to a stream. A character that is not printable will be
226 /// represented by its escape sequence.
DumpCharacter(Stream & s,const char c)227 static void DumpCharacter(Stream &s, const char c) {
228   if (TryDumpSpecialEscapedChar(s, c))
229     return;
230   if (llvm::isPrint(c)) {
231     s.PutChar(c);
232     return;
233   }
234   s.Printf("\\x%2.2x", c);
235 }
236 
237 /// Dump a floating point type.
238 template <typename FloatT>
DumpFloatingPoint(std::ostringstream & ss,FloatT f)239 void DumpFloatingPoint(std::ostringstream &ss, FloatT f) {
240   static_assert(std::is_floating_point<FloatT>::value,
241                 "Only floating point types can be dumped.");
242   // NaN and Inf are potentially implementation defined and on Darwin it
243   // seems NaNs are printed without their sign. Manually implement dumping them
244   // here to avoid having to deal with platform differences.
245   if (std::isnan(f)) {
246     if (std::signbit(f))
247       ss << '-';
248     ss << "nan";
249     return;
250   }
251   if (std::isinf(f)) {
252     if (std::signbit(f))
253       ss << '-';
254     ss << "inf";
255     return;
256   }
257   ss << f;
258 }
259 
260 static llvm::Optional<MemoryTagMap>
GetMemoryTags(lldb::addr_t addr,size_t length,ExecutionContextScope * exe_scope)261 GetMemoryTags(lldb::addr_t addr, size_t length,
262               ExecutionContextScope *exe_scope) {
263   assert(addr != LLDB_INVALID_ADDRESS);
264 
265   if (!exe_scope)
266     return llvm::None;
267 
268   TargetSP target_sp = exe_scope->CalculateTarget();
269   if (!target_sp)
270     return llvm::None;
271 
272   ProcessSP process_sp = target_sp->CalculateProcess();
273   if (!process_sp)
274     return llvm::None;
275 
276   llvm::Expected<const MemoryTagManager *> tag_manager_or_err =
277       process_sp->GetMemoryTagManager();
278   if (!tag_manager_or_err) {
279     llvm::consumeError(tag_manager_or_err.takeError());
280     return llvm::None;
281   }
282 
283   MemoryRegionInfos memory_regions;
284   // Don't check return status, list will be just empty if an error happened.
285   process_sp->GetMemoryRegions(memory_regions);
286 
287   llvm::Expected<std::vector<MemoryTagManager::TagRange>> tagged_ranges_or_err =
288       (*tag_manager_or_err)
289           ->MakeTaggedRanges(addr, addr + length, memory_regions);
290   // Here we know that our range will not be inverted but we must still check
291   // for an error.
292   if (!tagged_ranges_or_err) {
293     llvm::consumeError(tagged_ranges_or_err.takeError());
294     return llvm::None;
295   }
296   if (tagged_ranges_or_err->empty())
297     return llvm::None;
298 
299   MemoryTagMap memory_tag_map(*tag_manager_or_err);
300   for (const MemoryTagManager::TagRange &range : *tagged_ranges_or_err) {
301     llvm::Expected<std::vector<lldb::addr_t>> tags_or_err =
302         process_sp->ReadMemoryTags(range.GetRangeBase(), range.GetByteSize());
303 
304     if (tags_or_err)
305       memory_tag_map.InsertTags(range.GetRangeBase(), *tags_or_err);
306     else
307       llvm::consumeError(tags_or_err.takeError());
308   }
309 
310   if (memory_tag_map.Empty())
311     return llvm::None;
312 
313   return memory_tag_map;
314 }
315 
316 static void
printMemoryTags(const DataExtractor & DE,Stream * s,lldb::addr_t addr,size_t len,const llvm::Optional<MemoryTagMap> & memory_tag_map)317 printMemoryTags(const DataExtractor &DE, Stream *s, lldb::addr_t addr,
318                 size_t len,
319                 const llvm::Optional<MemoryTagMap> &memory_tag_map) {
320   std::vector<llvm::Optional<lldb::addr_t>> tags =
321       memory_tag_map->GetTags(addr, len);
322 
323   // Only print if there is at least one tag for this line
324   if (tags.empty())
325     return;
326 
327   s->Printf(" (tag%s:", tags.size() > 1 ? "s" : "");
328   // Some granules may not be tagged but print something for them
329   // so that the ordering remains intact.
330   for (auto tag : tags) {
331     if (tag)
332       s->Printf(" 0x%" PRIx64, *tag);
333     else
334       s->PutCString(" <no tag>");
335   }
336   s->PutCString(")");
337 }
338 
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,uint32_t item_bit_offset,ExecutionContextScope * exe_scope,bool show_memory_tags)339 lldb::offset_t lldb_private::DumpDataExtractor(
340     const DataExtractor &DE, Stream *s, offset_t start_offset,
341     lldb::Format item_format, size_t item_byte_size, size_t item_count,
342     size_t num_per_line, uint64_t base_addr,
343     uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
344                               // non-zero, the value is a bitfield
345     uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
346                               // shift amount to apply to a bitfield
347     ExecutionContextScope *exe_scope, bool show_memory_tags) {
348   if (s == nullptr)
349     return start_offset;
350 
351   if (item_format == eFormatPointer) {
352     if (item_byte_size != 4 && item_byte_size != 8)
353       item_byte_size = s->GetAddressByteSize();
354   }
355 
356   offset_t offset = start_offset;
357 
358   llvm::Optional<MemoryTagMap> memory_tag_map = llvm::None;
359   if (show_memory_tags && base_addr != LLDB_INVALID_ADDRESS)
360     memory_tag_map =
361         GetMemoryTags(base_addr, DE.GetByteSize() - offset, exe_scope);
362 
363   if (item_format == eFormatInstruction)
364     return DumpInstructions(DE, s, exe_scope, start_offset, base_addr,
365                             item_count);
366 
367   if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) &&
368       item_byte_size > 8)
369     item_format = eFormatHex;
370 
371   lldb::offset_t line_start_offset = start_offset;
372   for (uint32_t count = 0; DE.ValidOffset(offset) && count < item_count;
373        ++count) {
374     // If we are at the beginning or end of a line
375     // Note that the last line is handled outside this for loop.
376     if ((count % num_per_line) == 0) {
377       // If we are at the end of a line
378       if (count > 0) {
379         if (item_format == eFormatBytesWithASCII &&
380             offset > line_start_offset) {
381           s->Printf("%*s",
382                     static_cast<int>(
383                         (num_per_line - (offset - line_start_offset)) * 3 + 2),
384                     "");
385           DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
386                             offset - line_start_offset, SIZE_MAX,
387                             LLDB_INVALID_ADDRESS, 0, 0);
388         }
389 
390         if (base_addr != LLDB_INVALID_ADDRESS && memory_tag_map) {
391           size_t line_len = offset - line_start_offset;
392           lldb::addr_t line_base =
393               base_addr +
394               (offset - start_offset - line_len) / DE.getTargetByteSize();
395           printMemoryTags(DE, s, line_base, line_len, memory_tag_map);
396         }
397 
398         s->EOL();
399       }
400       if (base_addr != LLDB_INVALID_ADDRESS)
401         s->Printf("0x%8.8" PRIx64 ": ",
402                   (uint64_t)(base_addr +
403                              (offset - start_offset) / DE.getTargetByteSize()));
404 
405       line_start_offset = offset;
406     } else if (item_format != eFormatChar &&
407                item_format != eFormatCharPrintable &&
408                item_format != eFormatCharArray && count > 0) {
409       s->PutChar(' ');
410     }
411 
412     switch (item_format) {
413     case eFormatBoolean:
414       if (item_byte_size <= 8)
415         s->Printf("%s", DE.GetMaxU64Bitfield(&offset, item_byte_size,
416                                              item_bit_size, item_bit_offset)
417                             ? "true"
418                             : "false");
419       else {
420         s->Printf("error: unsupported byte size (%" PRIu64
421                   ") for boolean format",
422                   (uint64_t)item_byte_size);
423         return offset;
424       }
425       break;
426 
427     case eFormatBinary:
428       if (item_byte_size <= 8) {
429         uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
430                                                item_bit_size, item_bit_offset);
431         // Avoid std::bitset<64>::to_string() since it is missing in earlier
432         // C++ libraries
433         std::string binary_value(64, '0');
434         std::bitset<64> bits(uval64);
435         for (uint32_t i = 0; i < 64; ++i)
436           if (bits[i])
437             binary_value[64 - 1 - i] = '1';
438         if (item_bit_size > 0)
439           s->Printf("0b%s", binary_value.c_str() + 64 - item_bit_size);
440         else if (item_byte_size > 0 && item_byte_size <= 8)
441           s->Printf("0b%s", binary_value.c_str() + 64 - item_byte_size * 8);
442       } else {
443         const bool is_signed = false;
444         const unsigned radix = 2;
445         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
446       }
447       break;
448 
449     case eFormatBytes:
450     case eFormatBytesWithASCII:
451       for (uint32_t i = 0; i < item_byte_size; ++i) {
452         s->Printf("%2.2x", DE.GetU8(&offset));
453       }
454 
455       // Put an extra space between the groups of bytes if more than one is
456       // being dumped in a group (item_byte_size is more than 1).
457       if (item_byte_size > 1)
458         s->PutChar(' ');
459       break;
460 
461     case eFormatChar:
462     case eFormatCharPrintable:
463     case eFormatCharArray: {
464       // Reject invalid item_byte_size.
465       if (item_byte_size > 8) {
466         s->Printf("error: unsupported byte size (%" PRIu64 ") for char format",
467                   (uint64_t)item_byte_size);
468         return offset;
469       }
470 
471       // If we are only printing one character surround it with single quotes
472       if (item_count == 1 && item_format == eFormatChar)
473         s->PutChar('\'');
474 
475       const uint64_t ch = DE.GetMaxU64Bitfield(&offset, item_byte_size,
476                                                item_bit_size, item_bit_offset);
477       if (llvm::isPrint(ch))
478         s->Printf("%c", (char)ch);
479       else if (item_format != eFormatCharPrintable) {
480         if (!TryDumpSpecialEscapedChar(*s, ch)) {
481           if (item_byte_size == 1)
482             s->Printf("\\x%2.2x", (uint8_t)ch);
483           else
484             s->Printf("%" PRIu64, ch);
485         }
486       } else {
487         s->PutChar(NON_PRINTABLE_CHAR);
488       }
489 
490       // If we are only printing one character surround it with single quotes
491       if (item_count == 1 && item_format == eFormatChar)
492         s->PutChar('\'');
493     } break;
494 
495     case eFormatEnum: // Print enum value as a signed integer when we don't get
496                       // the enum type
497     case eFormatDecimal:
498       if (item_byte_size <= 8)
499         s->Printf("%" PRId64,
500                   DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
501                                        item_bit_offset));
502       else {
503         const bool is_signed = true;
504         const unsigned radix = 10;
505         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
506       }
507       break;
508 
509     case eFormatUnsigned:
510       if (item_byte_size <= 8)
511         s->Printf("%" PRIu64,
512                   DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
513                                        item_bit_offset));
514       else {
515         const bool is_signed = false;
516         const unsigned radix = 10;
517         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
518       }
519       break;
520 
521     case eFormatOctal:
522       if (item_byte_size <= 8)
523         s->Printf("0%" PRIo64,
524                   DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
525                                        item_bit_offset));
526       else {
527         const bool is_signed = false;
528         const unsigned radix = 8;
529         offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
530       }
531       break;
532 
533     case eFormatOSType: {
534       uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
535                                              item_bit_size, item_bit_offset);
536       s->PutChar('\'');
537       for (uint32_t i = 0; i < item_byte_size; ++i) {
538         uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
539         DumpCharacter(*s, ch);
540       }
541       s->PutChar('\'');
542     } break;
543 
544     case eFormatCString: {
545       const char *cstr = DE.GetCStr(&offset);
546 
547       if (!cstr) {
548         s->Printf("NULL");
549         offset = LLDB_INVALID_OFFSET;
550       } else {
551         s->PutChar('\"');
552 
553         while (const char c = *cstr) {
554           DumpCharacter(*s, c);
555           ++cstr;
556         }
557 
558         s->PutChar('\"');
559       }
560     } break;
561 
562     case eFormatPointer:
563       DumpAddress(s->AsRawOstream(),
564                   DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
565                                        item_bit_offset),
566                   sizeof(addr_t));
567       break;
568 
569     case eFormatComplexInteger: {
570       size_t complex_int_byte_size = item_byte_size / 2;
571 
572       if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) {
573         s->Printf("%" PRIu64,
574                   DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
575         s->Printf(" + %" PRIu64 "i",
576                   DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
577       } else {
578         s->Printf("error: unsupported byte size (%" PRIu64
579                   ") for complex integer format",
580                   (uint64_t)item_byte_size);
581         return offset;
582       }
583     } break;
584 
585     case eFormatComplex:
586       if (sizeof(float) * 2 == item_byte_size) {
587         float f32_1 = DE.GetFloat(&offset);
588         float f32_2 = DE.GetFloat(&offset);
589 
590         s->Printf("%g + %gi", f32_1, f32_2);
591         break;
592       } else if (sizeof(double) * 2 == item_byte_size) {
593         double d64_1 = DE.GetDouble(&offset);
594         double d64_2 = DE.GetDouble(&offset);
595 
596         s->Printf("%lg + %lgi", d64_1, d64_2);
597         break;
598       } else if (sizeof(long double) * 2 == item_byte_size) {
599         long double ld64_1 = DE.GetLongDouble(&offset);
600         long double ld64_2 = DE.GetLongDouble(&offset);
601         s->Printf("%Lg + %Lgi", ld64_1, ld64_2);
602         break;
603       } else {
604         s->Printf("error: unsupported byte size (%" PRIu64
605                   ") for complex float format",
606                   (uint64_t)item_byte_size);
607         return offset;
608       }
609       break;
610 
611     default:
612     case eFormatDefault:
613     case eFormatHex:
614     case eFormatHexUppercase: {
615       bool wantsuppercase = (item_format == eFormatHexUppercase);
616       switch (item_byte_size) {
617       case 1:
618       case 2:
619       case 4:
620       case 8:
621         s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64,
622                   (int)(2 * item_byte_size), (int)(2 * item_byte_size),
623                   DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
624                                        item_bit_offset));
625         break;
626       default: {
627         assert(item_bit_size == 0 && item_bit_offset == 0);
628         const uint8_t *bytes =
629             (const uint8_t *)DE.GetData(&offset, item_byte_size);
630         if (bytes) {
631           s->PutCString("0x");
632           uint32_t idx;
633           if (DE.GetByteOrder() == eByteOrderBig) {
634             for (idx = 0; idx < item_byte_size; ++idx)
635               s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]);
636           } else {
637             for (idx = 0; idx < item_byte_size; ++idx)
638               s->Printf(wantsuppercase ? "%2.2X" : "%2.2x",
639                         bytes[item_byte_size - 1 - idx]);
640           }
641         }
642       } break;
643       }
644     } break;
645 
646     case eFormatFloat: {
647       TargetSP target_sp;
648       bool used_upfloat = false;
649       if (exe_scope)
650         target_sp = exe_scope->CalculateTarget();
651       if (target_sp) {
652         auto type_system_or_err =
653             target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
654         if (!type_system_or_err) {
655           llvm::consumeError(type_system_or_err.takeError());
656         } else {
657           auto &type_system = *type_system_or_err;
658           llvm::SmallVector<char, 256> sv;
659           // Show full precision when printing float values
660           const unsigned format_precision = 0;
661           const unsigned format_max_padding =
662               target_sp->GetMaxZeroPaddingInFloatFormat();
663 
664           const auto &semantics =
665               type_system.GetFloatTypeSemantics(item_byte_size);
666 
667           // Recalculate the byte size in case of a difference. This is possible
668           // when item_byte_size is 16 (128-bit), because you could get back the
669           // x87DoubleExtended semantics which has a byte size of 10 (80-bit).
670           const size_t semantics_byte_size =
671               (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
672           llvm::Optional<llvm::APInt> apint =
673               GetAPInt(DE, &offset, semantics_byte_size);
674           if (apint) {
675             llvm::APFloat apfloat(semantics, apint.value());
676             apfloat.toString(sv, format_precision, format_max_padding);
677             if (!sv.empty()) {
678               s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
679               used_upfloat = true;
680             }
681           }
682         }
683       }
684 
685       if (!used_upfloat) {
686         std::ostringstream ss;
687         if (item_byte_size == sizeof(float) || item_byte_size == 2) {
688           float f;
689           if (item_byte_size == 2) {
690             uint16_t half = DE.GetU16(&offset);
691             f = half2float(half);
692           } else {
693             f = DE.GetFloat(&offset);
694           }
695           ss.precision(std::numeric_limits<float>::digits10);
696           DumpFloatingPoint(ss, f);
697         } else if (item_byte_size == sizeof(double)) {
698           ss.precision(std::numeric_limits<double>::digits10);
699           DumpFloatingPoint(ss, DE.GetDouble(&offset));
700         } else if (item_byte_size == sizeof(long double) ||
701                    item_byte_size == 10) {
702           ss.precision(std::numeric_limits<long double>::digits10);
703           DumpFloatingPoint(ss, DE.GetLongDouble(&offset));
704         } else {
705           s->Printf("error: unsupported byte size (%" PRIu64
706                     ") for float format",
707                     (uint64_t)item_byte_size);
708           return offset;
709         }
710         ss.flush();
711         s->Printf("%s", ss.str().c_str());
712       }
713     } break;
714 
715     case eFormatUnicode16:
716       s->Printf("U+%4.4x", DE.GetU16(&offset));
717       break;
718 
719     case eFormatUnicode32:
720       s->Printf("U+0x%8.8x", DE.GetU32(&offset));
721       break;
722 
723     case eFormatAddressInfo: {
724       addr_t addr = DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
725                                          item_bit_offset);
726       s->Printf("0x%*.*" PRIx64, (int)(2 * item_byte_size),
727                 (int)(2 * item_byte_size), addr);
728       if (exe_scope) {
729         TargetSP target_sp(exe_scope->CalculateTarget());
730         lldb_private::Address so_addr;
731         if (target_sp) {
732           if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr,
733                                                                  so_addr)) {
734             s->PutChar(' ');
735             so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription,
736                          Address::DumpStyleModuleWithFileAddress);
737           } else {
738             so_addr.SetOffset(addr);
739             so_addr.Dump(s, exe_scope,
740                          Address::DumpStyleResolvedPointerDescription);
741             if (ProcessSP process_sp = exe_scope->CalculateProcess()) {
742               if (ABISP abi_sp = process_sp->GetABI()) {
743                 addr_t addr_fixed = abi_sp->FixCodeAddress(addr);
744                 if (target_sp->GetSectionLoadList().ResolveLoadAddress(
745                         addr_fixed, so_addr)) {
746                   s->PutChar(' ');
747                   s->Printf("(0x%*.*" PRIx64 ")", (int)(2 * item_byte_size),
748                             (int)(2 * item_byte_size), addr_fixed);
749                   s->PutChar(' ');
750                   so_addr.Dump(s, exe_scope,
751                                Address::DumpStyleResolvedDescription,
752                                Address::DumpStyleModuleWithFileAddress);
753                 }
754               }
755             }
756           }
757         }
758       }
759     } break;
760 
761     case eFormatHexFloat:
762       if (sizeof(float) == item_byte_size) {
763         char float_cstr[256];
764         llvm::APFloat ap_float(DE.GetFloat(&offset));
765         ap_float.convertToHexString(float_cstr, 0, false,
766                                     llvm::APFloat::rmNearestTiesToEven);
767         s->Printf("%s", float_cstr);
768         break;
769       } else if (sizeof(double) == item_byte_size) {
770         char float_cstr[256];
771         llvm::APFloat ap_float(DE.GetDouble(&offset));
772         ap_float.convertToHexString(float_cstr, 0, false,
773                                     llvm::APFloat::rmNearestTiesToEven);
774         s->Printf("%s", float_cstr);
775         break;
776       } else {
777         s->Printf("error: unsupported byte size (%" PRIu64
778                   ") for hex float format",
779                   (uint64_t)item_byte_size);
780         return offset;
781       }
782       break;
783 
784     // please keep the single-item formats below in sync with
785     // FormatManager::GetSingleItemFormat if you fail to do so, users will
786     // start getting different outputs depending on internal implementation
787     // details they should not care about ||
788     case eFormatVectorOfChar: //   ||
789       s->PutChar('{');        //   \/
790       offset =
791           DumpDataExtractor(DE, s, offset, eFormatCharArray, 1, item_byte_size,
792                             item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
793       s->PutChar('}');
794       break;
795 
796     case eFormatVectorOfSInt8:
797       s->PutChar('{');
798       offset =
799           DumpDataExtractor(DE, s, offset, eFormatDecimal, 1, item_byte_size,
800                             item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
801       s->PutChar('}');
802       break;
803 
804     case eFormatVectorOfUInt8:
805       s->PutChar('{');
806       offset = DumpDataExtractor(DE, s, offset, eFormatHex, 1, item_byte_size,
807                                  item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
808       s->PutChar('}');
809       break;
810 
811     case eFormatVectorOfSInt16:
812       s->PutChar('{');
813       offset = DumpDataExtractor(
814           DE, s, offset, eFormatDecimal, sizeof(uint16_t),
815           item_byte_size / sizeof(uint16_t), item_byte_size / sizeof(uint16_t),
816           LLDB_INVALID_ADDRESS, 0, 0);
817       s->PutChar('}');
818       break;
819 
820     case eFormatVectorOfUInt16:
821       s->PutChar('{');
822       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint16_t),
823                                  item_byte_size / sizeof(uint16_t),
824                                  item_byte_size / sizeof(uint16_t),
825                                  LLDB_INVALID_ADDRESS, 0, 0);
826       s->PutChar('}');
827       break;
828 
829     case eFormatVectorOfSInt32:
830       s->PutChar('{');
831       offset = DumpDataExtractor(
832           DE, s, offset, eFormatDecimal, sizeof(uint32_t),
833           item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t),
834           LLDB_INVALID_ADDRESS, 0, 0);
835       s->PutChar('}');
836       break;
837 
838     case eFormatVectorOfUInt32:
839       s->PutChar('{');
840       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint32_t),
841                                  item_byte_size / sizeof(uint32_t),
842                                  item_byte_size / sizeof(uint32_t),
843                                  LLDB_INVALID_ADDRESS, 0, 0);
844       s->PutChar('}');
845       break;
846 
847     case eFormatVectorOfSInt64:
848       s->PutChar('{');
849       offset = DumpDataExtractor(
850           DE, s, offset, eFormatDecimal, sizeof(uint64_t),
851           item_byte_size / sizeof(uint64_t), item_byte_size / sizeof(uint64_t),
852           LLDB_INVALID_ADDRESS, 0, 0);
853       s->PutChar('}');
854       break;
855 
856     case eFormatVectorOfUInt64:
857       s->PutChar('{');
858       offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint64_t),
859                                  item_byte_size / sizeof(uint64_t),
860                                  item_byte_size / sizeof(uint64_t),
861                                  LLDB_INVALID_ADDRESS, 0, 0);
862       s->PutChar('}');
863       break;
864 
865     case eFormatVectorOfFloat16:
866       s->PutChar('{');
867       offset =
868           DumpDataExtractor(DE, s, offset, eFormatFloat, 2, item_byte_size / 2,
869                             item_byte_size / 2, LLDB_INVALID_ADDRESS, 0, 0);
870       s->PutChar('}');
871       break;
872 
873     case eFormatVectorOfFloat32:
874       s->PutChar('{');
875       offset =
876           DumpDataExtractor(DE, s, offset, eFormatFloat, 4, item_byte_size / 4,
877                             item_byte_size / 4, LLDB_INVALID_ADDRESS, 0, 0);
878       s->PutChar('}');
879       break;
880 
881     case eFormatVectorOfFloat64:
882       s->PutChar('{');
883       offset =
884           DumpDataExtractor(DE, s, offset, eFormatFloat, 8, item_byte_size / 8,
885                             item_byte_size / 8, LLDB_INVALID_ADDRESS, 0, 0);
886       s->PutChar('}');
887       break;
888 
889     case eFormatVectorOfUInt128:
890       s->PutChar('{');
891       offset =
892           DumpDataExtractor(DE, s, offset, eFormatHex, 16, item_byte_size / 16,
893                             item_byte_size / 16, LLDB_INVALID_ADDRESS, 0, 0);
894       s->PutChar('}');
895       break;
896     }
897   }
898 
899   // If anything was printed we want to catch the end of the last line.
900   // Since we will exit the for loop above before we get a chance to append to
901   // it normally.
902   if (offset > line_start_offset) {
903     if (item_format == eFormatBytesWithASCII) {
904       s->Printf("%*s",
905                 static_cast<int>(
906                     (num_per_line - (offset - line_start_offset)) * 3 + 2),
907                 "");
908       DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
909                         offset - line_start_offset, SIZE_MAX,
910                         LLDB_INVALID_ADDRESS, 0, 0);
911     }
912 
913     if (base_addr != LLDB_INVALID_ADDRESS && memory_tag_map) {
914       size_t line_len = offset - line_start_offset;
915       lldb::addr_t line_base = base_addr + (offset - start_offset - line_len) /
916                                                DE.getTargetByteSize();
917       printMemoryTags(DE, s, line_base, line_len, memory_tag_map);
918     }
919   }
920 
921   return offset; // Return the offset at which we ended up
922 }
923 
DumpHexBytes(Stream * s,const void * src,size_t src_len,uint32_t bytes_per_line,lldb::addr_t base_addr)924 void lldb_private::DumpHexBytes(Stream *s, const void *src, size_t src_len,
925                                 uint32_t bytes_per_line,
926                                 lldb::addr_t base_addr) {
927   DataExtractor data(src, src_len, lldb::eByteOrderLittle, 4);
928   DumpDataExtractor(data, s,
929                     0,                  // Offset into "src"
930                     lldb::eFormatBytes, // Dump as hex bytes
931                     1,              // Size of each item is 1 for single bytes
932                     src_len,        // Number of bytes
933                     bytes_per_line, // Num bytes per line
934                     base_addr,      // Base address
935                     0, 0);          // Bitfield info
936 }
937