1 //===-- StringPrinter.cpp ----------------------------------------*- C++
2 //-*-===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/DataFormatters/StringPrinter.h"
11 
12 #include "lldb/Core/Debugger.h"
13 #include "lldb/Core/ValueObject.h"
14 #include "lldb/Target/Language.h"
15 #include "lldb/Target/Process.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Utility/Status.h"
18 
19 #include "llvm/Support/ConvertUTF.h"
20 
21 #include <ctype.h>
22 #include <locale>
23 #include <memory>
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 using namespace lldb_private::formatters;
28 
29 // we define this for all values of type but only implement it for those we
30 // care about that's good because we get linker errors for any unsupported type
31 template <lldb_private::formatters::StringPrinter::StringElementType type>
32 static StringPrinter::StringPrinterBufferPointer<>
33 GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next);
34 
35 // mimic isprint() for Unicode codepoints
36 static bool isprint(char32_t codepoint) {
37   if (codepoint <= 0x1F || codepoint == 0x7F) // C0
38   {
39     return false;
40   }
41   if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
42   {
43     return false;
44   }
45   if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators
46   {
47     return false;
48   }
49   if (codepoint == 0x200E || codepoint == 0x200F ||
50       (codepoint >= 0x202A &&
51        codepoint <= 0x202E)) // bidirectional text control
52   {
53     return false;
54   }
55   if (codepoint >= 0xFFF9 &&
56       codepoint <= 0xFFFF) // interlinears and generally specials
57   {
58     return false;
59   }
60   return true;
61 }
62 
63 template <>
64 StringPrinter::StringPrinterBufferPointer<>
65 GetPrintableImpl<StringPrinter::StringElementType::ASCII>(uint8_t *buffer,
66                                                           uint8_t *buffer_end,
67                                                           uint8_t *&next) {
68   StringPrinter::StringPrinterBufferPointer<> retval = {nullptr};
69 
70   switch (*buffer) {
71   case 0:
72     retval = {"\\0", 2};
73     break;
74   case '\a':
75     retval = {"\\a", 2};
76     break;
77   case '\b':
78     retval = {"\\b", 2};
79     break;
80   case '\f':
81     retval = {"\\f", 2};
82     break;
83   case '\n':
84     retval = {"\\n", 2};
85     break;
86   case '\r':
87     retval = {"\\r", 2};
88     break;
89   case '\t':
90     retval = {"\\t", 2};
91     break;
92   case '\v':
93     retval = {"\\v", 2};
94     break;
95   case '\"':
96     retval = {"\\\"", 2};
97     break;
98   case '\\':
99     retval = {"\\\\", 2};
100     break;
101   default:
102     if (isprint(*buffer))
103       retval = {buffer, 1};
104     else {
105       uint8_t *data = new uint8_t[5];
106       sprintf((char *)data, "\\x%02x", *buffer);
107       retval = {data, 4, [](const uint8_t *c) { delete[] c; }};
108       break;
109     }
110   }
111 
112   next = buffer + 1;
113   return retval;
114 }
115 
116 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1) {
117   return (c0 - 192) * 64 + (c1 - 128);
118 }
119 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
120                                        unsigned char c2) {
121   return (c0 - 224) * 4096 + (c1 - 128) * 64 + (c2 - 128);
122 }
123 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
124                                        unsigned char c2, unsigned char c3) {
125   return (c0 - 240) * 262144 + (c2 - 128) * 4096 + (c2 - 128) * 64 + (c3 - 128);
126 }
127 
128 template <>
129 StringPrinter::StringPrinterBufferPointer<>
130 GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer,
131                                                          uint8_t *buffer_end,
132                                                          uint8_t *&next) {
133   StringPrinter::StringPrinterBufferPointer<> retval{nullptr};
134 
135   unsigned utf8_encoded_len = llvm::getNumBytesForUTF8(*buffer);
136 
137   if (1u + std::distance(buffer, buffer_end) < utf8_encoded_len) {
138     // I don't have enough bytes - print whatever I have left
139     retval = {buffer, static_cast<size_t>(1 + buffer_end - buffer)};
140     next = buffer_end + 1;
141     return retval;
142   }
143 
144   char32_t codepoint = 0;
145   switch (utf8_encoded_len) {
146   case 1:
147     // this is just an ASCII byte - ask ASCII
148     return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
149         buffer, buffer_end, next);
150   case 2:
151     codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
152                                        (unsigned char)*(buffer + 1));
153     break;
154   case 3:
155     codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
156                                        (unsigned char)*(buffer + 1),
157                                        (unsigned char)*(buffer + 2));
158     break;
159   case 4:
160     codepoint = ConvertUTF8ToCodePoint(
161         (unsigned char)*buffer, (unsigned char)*(buffer + 1),
162         (unsigned char)*(buffer + 2), (unsigned char)*(buffer + 3));
163     break;
164   default:
165     // this is probably some bogus non-character thing just print it as-is and
166     // hope to sync up again soon
167     retval = {buffer, 1};
168     next = buffer + 1;
169     return retval;
170   }
171 
172   if (codepoint) {
173     switch (codepoint) {
174     case 0:
175       retval = {"\\0", 2};
176       break;
177     case '\a':
178       retval = {"\\a", 2};
179       break;
180     case '\b':
181       retval = {"\\b", 2};
182       break;
183     case '\f':
184       retval = {"\\f", 2};
185       break;
186     case '\n':
187       retval = {"\\n", 2};
188       break;
189     case '\r':
190       retval = {"\\r", 2};
191       break;
192     case '\t':
193       retval = {"\\t", 2};
194       break;
195     case '\v':
196       retval = {"\\v", 2};
197       break;
198     case '\"':
199       retval = {"\\\"", 2};
200       break;
201     case '\\':
202       retval = {"\\\\", 2};
203       break;
204     default:
205       if (isprint(codepoint))
206         retval = {buffer, utf8_encoded_len};
207       else {
208         uint8_t *data = new uint8_t[11];
209         sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
210         retval = {data, 10, [](const uint8_t *c) { delete[] c; }};
211         break;
212       }
213     }
214 
215     next = buffer + utf8_encoded_len;
216     return retval;
217   }
218 
219   // this should not happen - but just in case.. try to resync at some point
220   retval = {buffer, 1};
221   next = buffer + 1;
222   return retval;
223 }
224 
225 // Given a sequence of bytes, this function returns: a sequence of bytes to
226 // actually print out + a length the following unscanned position of the buffer
227 // is in next
228 static StringPrinter::StringPrinterBufferPointer<>
229 GetPrintable(StringPrinter::StringElementType type, uint8_t *buffer,
230              uint8_t *buffer_end, uint8_t *&next) {
231   if (!buffer)
232     return {nullptr};
233 
234   switch (type) {
235   case StringPrinter::StringElementType::ASCII:
236     return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
237         buffer, buffer_end, next);
238   case StringPrinter::StringElementType::UTF8:
239     return GetPrintableImpl<StringPrinter::StringElementType::UTF8>(
240         buffer, buffer_end, next);
241   default:
242     return {nullptr};
243   }
244 }
245 
246 StringPrinter::EscapingHelper
247 StringPrinter::GetDefaultEscapingHelper(GetPrintableElementType elem_type) {
248   switch (elem_type) {
249   case GetPrintableElementType::UTF8:
250     return [](uint8_t *buffer, uint8_t *buffer_end,
251               uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> {
252       return GetPrintable(StringPrinter::StringElementType::UTF8, buffer,
253                           buffer_end, next);
254     };
255   case GetPrintableElementType::ASCII:
256     return [](uint8_t *buffer, uint8_t *buffer_end,
257               uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> {
258       return GetPrintable(StringPrinter::StringElementType::ASCII, buffer,
259                           buffer_end, next);
260     };
261   }
262   llvm_unreachable("bad element type");
263 }
264 
265 // use this call if you already have an LLDB-side buffer for the data
266 template <typename SourceDataType>
267 static bool DumpUTFBufferToStream(
268     llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
269                                               const SourceDataType *,
270                                               llvm::UTF8 **, llvm::UTF8 *,
271                                               llvm::ConversionFlags),
272     const StringPrinter::ReadBufferAndDumpToStreamOptions &dump_options) {
273   Stream &stream(*dump_options.GetStream());
274   if (dump_options.GetPrefixToken() != nullptr)
275     stream.Printf("%s", dump_options.GetPrefixToken());
276   if (dump_options.GetQuote() != 0)
277     stream.Printf("%c", dump_options.GetQuote());
278   auto data(dump_options.GetData());
279   auto source_size(dump_options.GetSourceSize());
280   if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd()) {
281     const int bufferSPSize = data.GetByteSize();
282     if (dump_options.GetSourceSize() == 0) {
283       const int origin_encoding = 8 * sizeof(SourceDataType);
284       source_size = bufferSPSize / (origin_encoding / 4);
285     }
286 
287     const SourceDataType *data_ptr =
288         (const SourceDataType *)data.GetDataStart();
289     const SourceDataType *data_end_ptr = data_ptr + source_size;
290 
291     const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator();
292 
293     if (zero_is_terminator) {
294       while (data_ptr < data_end_ptr) {
295         if (!*data_ptr) {
296           data_end_ptr = data_ptr;
297           break;
298         }
299         data_ptr++;
300       }
301 
302       data_ptr = (const SourceDataType *)data.GetDataStart();
303     }
304 
305     lldb::DataBufferSP utf8_data_buffer_sp;
306     llvm::UTF8 *utf8_data_ptr = nullptr;
307     llvm::UTF8 *utf8_data_end_ptr = nullptr;
308 
309     if (ConvertFunction) {
310       utf8_data_buffer_sp =
311           std::make_shared<DataBufferHeap>(4 * bufferSPSize, 0);
312       utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
313       utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
314       ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
315                       utf8_data_end_ptr, llvm::lenientConversion);
316       if (!zero_is_terminator)
317         utf8_data_end_ptr = utf8_data_ptr;
318       // needed because the ConvertFunction will change the value of the
319       // data_ptr.
320       utf8_data_ptr =
321           (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
322     } else {
323       // just copy the pointers - the cast is necessary to make the compiler
324       // happy but this should only happen if we are reading UTF8 data
325       utf8_data_ptr = const_cast<llvm::UTF8 *>(
326           reinterpret_cast<const llvm::UTF8 *>(data_ptr));
327       utf8_data_end_ptr = const_cast<llvm::UTF8 *>(
328           reinterpret_cast<const llvm::UTF8 *>(data_end_ptr));
329     }
330 
331     const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
332     lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
333     if (escape_non_printables) {
334       if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
335         escaping_callback = language->GetStringPrinterEscapingHelper(
336             lldb_private::formatters::StringPrinter::GetPrintableElementType::
337                 UTF8);
338       else
339         escaping_callback =
340             lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
341                 lldb_private::formatters::StringPrinter::
342                     GetPrintableElementType::UTF8);
343     }
344 
345     // since we tend to accept partial data (and even partially malformed data)
346     // we might end up with no NULL terminator before the end_ptr hence we need
347     // to take a slower route and ensure we stay within boundaries
348     for (; utf8_data_ptr < utf8_data_end_ptr;) {
349       if (zero_is_terminator && !*utf8_data_ptr)
350         break;
351 
352       if (escape_non_printables) {
353         uint8_t *next_data = nullptr;
354         auto printable =
355             escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data);
356         auto printable_bytes = printable.GetBytes();
357         auto printable_size = printable.GetSize();
358         if (!printable_bytes || !next_data) {
359           // GetPrintable() failed on us - print one byte in a desperate resync
360           // attempt
361           printable_bytes = utf8_data_ptr;
362           printable_size = 1;
363           next_data = utf8_data_ptr + 1;
364         }
365         for (unsigned c = 0; c < printable_size; c++)
366           stream.Printf("%c", *(printable_bytes + c));
367         utf8_data_ptr = (uint8_t *)next_data;
368       } else {
369         stream.Printf("%c", *utf8_data_ptr);
370         utf8_data_ptr++;
371       }
372     }
373   }
374   if (dump_options.GetQuote() != 0)
375     stream.Printf("%c", dump_options.GetQuote());
376   if (dump_options.GetSuffixToken() != nullptr)
377     stream.Printf("%s", dump_options.GetSuffixToken());
378   if (dump_options.GetIsTruncated())
379     stream.Printf("...");
380   return true;
381 }
382 
383 lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions::
384     ReadStringAndDumpToStreamOptions(ValueObject &valobj)
385     : ReadStringAndDumpToStreamOptions() {
386   SetEscapeNonPrintables(
387       valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
388 }
389 
390 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
391     ReadBufferAndDumpToStreamOptions(ValueObject &valobj)
392     : ReadBufferAndDumpToStreamOptions() {
393   SetEscapeNonPrintables(
394       valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
395 }
396 
397 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
398     ReadBufferAndDumpToStreamOptions(
399         const ReadStringAndDumpToStreamOptions &options)
400     : ReadBufferAndDumpToStreamOptions() {
401   SetStream(options.GetStream());
402   SetPrefixToken(options.GetPrefixToken());
403   SetSuffixToken(options.GetSuffixToken());
404   SetQuote(options.GetQuote());
405   SetEscapeNonPrintables(options.GetEscapeNonPrintables());
406   SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
407   SetLanguage(options.GetLanguage());
408 }
409 
410 namespace lldb_private {
411 
412 namespace formatters {
413 
414 template <>
415 bool StringPrinter::ReadStringAndDumpToStream<
416     StringPrinter::StringElementType::ASCII>(
417     const ReadStringAndDumpToStreamOptions &options) {
418   assert(options.GetStream() && "need a Stream to print the string to");
419   Status my_error;
420 
421   ProcessSP process_sp(options.GetProcessSP());
422 
423   if (process_sp.get() == nullptr || options.GetLocation() == 0)
424     return false;
425 
426   size_t size;
427   const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
428   bool is_truncated = false;
429 
430   if (options.GetSourceSize() == 0)
431     size = max_size;
432   else if (!options.GetIgnoreMaxLength()) {
433     size = options.GetSourceSize();
434     if (size > max_size) {
435       size = max_size;
436       is_truncated = true;
437     }
438   } else
439     size = options.GetSourceSize();
440 
441   lldb::DataBufferSP buffer_sp(new DataBufferHeap(size, 0));
442 
443   process_sp->ReadCStringFromMemory(
444       options.GetLocation(), (char *)buffer_sp->GetBytes(), size, my_error);
445 
446   if (my_error.Fail())
447     return false;
448 
449   const char *prefix_token = options.GetPrefixToken();
450   char quote = options.GetQuote();
451 
452   if (prefix_token != nullptr)
453     options.GetStream()->Printf("%s%c", prefix_token, quote);
454   else if (quote != 0)
455     options.GetStream()->Printf("%c", quote);
456 
457   uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize();
458 
459   const bool escape_non_printables = options.GetEscapeNonPrintables();
460   lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
461   if (escape_non_printables) {
462     if (Language *language = Language::FindPlugin(options.GetLanguage()))
463       escaping_callback = language->GetStringPrinterEscapingHelper(
464           lldb_private::formatters::StringPrinter::GetPrintableElementType::
465               ASCII);
466     else
467       escaping_callback =
468           lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
469               lldb_private::formatters::StringPrinter::GetPrintableElementType::
470                   ASCII);
471   }
472 
473   // since we tend to accept partial data (and even partially malformed data)
474   // we might end up with no NULL terminator before the end_ptr hence we need
475   // to take a slower route and ensure we stay within boundaries
476   for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) {
477     if (escape_non_printables) {
478       uint8_t *next_data = nullptr;
479       auto printable = escaping_callback(data, data_end, next_data);
480       auto printable_bytes = printable.GetBytes();
481       auto printable_size = printable.GetSize();
482       if (!printable_bytes || !next_data) {
483         // GetPrintable() failed on us - print one byte in a desperate resync
484         // attempt
485         printable_bytes = data;
486         printable_size = 1;
487         next_data = data + 1;
488       }
489       for (unsigned c = 0; c < printable_size; c++)
490         options.GetStream()->Printf("%c", *(printable_bytes + c));
491       data = (uint8_t *)next_data;
492     } else {
493       options.GetStream()->Printf("%c", *data);
494       data++;
495     }
496   }
497 
498   const char *suffix_token = options.GetSuffixToken();
499 
500   if (suffix_token != nullptr)
501     options.GetStream()->Printf("%c%s", quote, suffix_token);
502   else if (quote != 0)
503     options.GetStream()->Printf("%c", quote);
504 
505   if (is_truncated)
506     options.GetStream()->Printf("...");
507 
508   return true;
509 }
510 
511 template <typename SourceDataType>
512 static bool ReadUTFBufferAndDumpToStream(
513     const StringPrinter::ReadStringAndDumpToStreamOptions &options,
514     llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
515                                               const SourceDataType *,
516                                               llvm::UTF8 **, llvm::UTF8 *,
517                                               llvm::ConversionFlags)) {
518   assert(options.GetStream() && "need a Stream to print the string to");
519 
520   if (options.GetLocation() == 0 ||
521       options.GetLocation() == LLDB_INVALID_ADDRESS)
522     return false;
523 
524   lldb::ProcessSP process_sp(options.GetProcessSP());
525 
526   if (!process_sp)
527     return false;
528 
529   const int type_width = sizeof(SourceDataType);
530   const int origin_encoding = 8 * type_width;
531   if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
532     return false;
533   // if not UTF8, I need a conversion function to return proper UTF8
534   if (origin_encoding != 8 && !ConvertFunction)
535     return false;
536 
537   if (!options.GetStream())
538     return false;
539 
540   uint32_t sourceSize = options.GetSourceSize();
541   bool needs_zero_terminator = options.GetNeedsZeroTermination();
542 
543   bool is_truncated = false;
544   const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
545 
546   if (!sourceSize) {
547     sourceSize = max_size;
548     needs_zero_terminator = true;
549   } else if (!options.GetIgnoreMaxLength()) {
550     if (sourceSize > max_size) {
551       sourceSize = max_size;
552       is_truncated = true;
553     }
554   }
555 
556   const int bufferSPSize = sourceSize * type_width;
557 
558   lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0));
559 
560   if (!buffer_sp->GetBytes())
561     return false;
562 
563   Status error;
564   char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
565 
566   if (needs_zero_terminator)
567     process_sp->ReadStringFromMemory(options.GetLocation(), buffer,
568                                      bufferSPSize, error, type_width);
569   else
570     process_sp->ReadMemoryFromInferior(options.GetLocation(),
571                                        (char *)buffer_sp->GetBytes(),
572                                        bufferSPSize, error);
573 
574   if (error.Fail()) {
575     options.GetStream()->Printf("unable to read data");
576     return true;
577   }
578 
579   DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
580                      process_sp->GetAddressByteSize());
581 
582   StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options);
583   dump_options.SetData(data);
584   dump_options.SetSourceSize(sourceSize);
585   dump_options.SetIsTruncated(is_truncated);
586 
587   return DumpUTFBufferToStream(ConvertFunction, dump_options);
588 }
589 
590 template <>
591 bool StringPrinter::ReadStringAndDumpToStream<
592     StringPrinter::StringElementType::UTF8>(
593     const ReadStringAndDumpToStreamOptions &options) {
594   return ReadUTFBufferAndDumpToStream<llvm::UTF8>(options, nullptr);
595 }
596 
597 template <>
598 bool StringPrinter::ReadStringAndDumpToStream<
599     StringPrinter::StringElementType::UTF16>(
600     const ReadStringAndDumpToStreamOptions &options) {
601   return ReadUTFBufferAndDumpToStream<llvm::UTF16>(options,
602                                                    llvm::ConvertUTF16toUTF8);
603 }
604 
605 template <>
606 bool StringPrinter::ReadStringAndDumpToStream<
607     StringPrinter::StringElementType::UTF32>(
608     const ReadStringAndDumpToStreamOptions &options) {
609   return ReadUTFBufferAndDumpToStream<llvm::UTF32>(options,
610                                                    llvm::ConvertUTF32toUTF8);
611 }
612 
613 template <>
614 bool StringPrinter::ReadBufferAndDumpToStream<
615     StringPrinter::StringElementType::UTF8>(
616     const ReadBufferAndDumpToStreamOptions &options) {
617   assert(options.GetStream() && "need a Stream to print the string to");
618 
619   return DumpUTFBufferToStream<llvm::UTF8>(nullptr, options);
620 }
621 
622 template <>
623 bool StringPrinter::ReadBufferAndDumpToStream<
624     StringPrinter::StringElementType::ASCII>(
625     const ReadBufferAndDumpToStreamOptions &options) {
626   // treat ASCII the same as UTF8
627   // FIXME: can we optimize ASCII some more?
628   return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
629 }
630 
631 template <>
632 bool StringPrinter::ReadBufferAndDumpToStream<
633     StringPrinter::StringElementType::UTF16>(
634     const ReadBufferAndDumpToStreamOptions &options) {
635   assert(options.GetStream() && "need a Stream to print the string to");
636 
637   return DumpUTFBufferToStream(llvm::ConvertUTF16toUTF8, options);
638 }
639 
640 template <>
641 bool StringPrinter::ReadBufferAndDumpToStream<
642     StringPrinter::StringElementType::UTF32>(
643     const ReadBufferAndDumpToStreamOptions &options) {
644   assert(options.GetStream() && "need a Stream to print the string to");
645 
646   return DumpUTFBufferToStream(llvm::ConvertUTF32toUTF8, options);
647 }
648 
649 } // namespace formatters
650 
651 } // namespace lldb_private
652