Fix evaluation of unicode character array types (char16_t[] and char32_t[])

[evgeny777]

Summary

Suppose we have UTF-16 string

char16_t[] s = u"hello";

If we try to evaluate it with lldb we will get this:

(char16_t [6]) $0 = ([0] = U+0068 u'h', [1] = U+0065 u'e', [2] = U+006c u'l', [3] = U+006c u'l', [4] = U+006f u'o', [5] = U+0000 u'\0')

After applying the patch we'll get this:

(char16_t [6]) $0 = u"hello"

[granata.enrico]

Only thing I would suggest is using LLDB_INVALID_ADDRESS instead of 0 in GetArrayAddressOrPointerValue()

Other than that LGTM!

source/DataFormatters/FormattersHelpers.cpp

302 ↗

(On Diff #35364)

Is there a reason not to use LLDB_INVALID_ADDRESS instead of 0?

lldb/trunk/include/lldb/DataFormatters/FormattersHelpers.h

#endif
         CallSelectorOnObject (ValueObject &valobj,
                               const char* return_type,
                               const char* selector,
                               const char* key);
         
         size_t
         ExtractIndexFromString (const char* item_name);
         
+        lldb::addr_t
+        GetArrayAddressOrPointerValue (ValueObject& valobj);
+
         time_t
         GetOSXEpoch ();
     } // namespace formatters
 } // namespace lldb_private
 
 #endif  // lldb_FormattersHelpers_h_

lldb/trunk/source/DataFormatters/FormattersHelpers.cpp

lldb_private::formatters::ExtractIndexFromString (const char* item_name)
     char* endptr = NULL;
     unsigned long int idx = ::strtoul(item_name, &endptr, 0);
     if (idx == 0 && endptr == item_name)
         return UINT32_MAX;
     if (idx == ULONG_MAX)
         return UINT32_MAX;
     return idx;
 }
+
+lldb::addr_t
+lldb_private::formatters::GetArrayAddressOrPointerValue (ValueObject& valobj)
+{
+    lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
+
+    if (valobj.IsPointerType())
+        data_addr = valobj.GetValueAsUnsigned(0);
+    else if (valobj.IsArrayType())
+        data_addr = valobj.GetAddressOf();
+
+    return data_addr;
+}

lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
     .SetDontShowChildren(true)
     .SetDontShowValue(true)
     .SetShowMembersOneLiner(false)
     .SetHideItemNames(false);
     
 #ifndef LLDB_DISABLE_PYTHON
     // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
+    AddCXXSummary(cpp_category_sp,
+                  lldb_private::formatters::Char16StringSummaryProvider,
+                  "char16_t [] summary provider",
+                  ConstString("char16_t \\[[0-9]+\\]"),
+                  string_array_flags,
+                  true);
     
     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
+    AddCXXSummary(cpp_category_sp,
+                  lldb_private::formatters::Char32StringSummaryProvider,
+                  "char32_t [] summary provider",
+                  ConstString("char32_t \\[[0-9]+\\]"),
+                  string_array_flags,
+                  true);
     
     AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
     AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
     
     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags);
     
     TypeSummaryImpl::Flags widechar_flags;
     widechar_flags.SetDontShowValue(true)

lldb/trunk/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ProcessStructReader.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
 
 #include <algorithm>
 
 #if __ANDROID_NDK__
 #include <sys/types.h>
 #endif
 
 #include "lldb/Host/Time.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 bool
 lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
         return false;
     
-    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
-    
-    if (!valobj_addr)
+    lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj);
+    if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS)
         return false;
     
     StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
     options.SetLocation(valobj_addr);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetPrefixToken('u');
     
     if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options))
     {
         stream.Printf("Summary Unavailable");
         return true;
     }
     
     return true;
 }
 
 bool
 lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
         return false;
     
-    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
-    
-    if (!valobj_addr)
+    lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj);
+    if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS)
         return false;
     
     StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
     options.SetLocation(valobj_addr);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetPrefixToken('U');
     
     if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32>(options))
     {
         stream.Printf("Summary Unavailable");
         return true;
     }
     
     return true;
 }
 
 bool
 lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
         return false;
     
-    lldb::addr_t data_addr = 0;
-    
-    if (valobj.IsPointerType())
-        data_addr = valobj.GetValueAsUnsigned(0);
-    else if (valobj.IsArrayType())
-        data_addr = valobj.GetAddressOf();
-    
-    if (data_addr == 0 || data_addr == LLDB_INVALID_ADDRESS)
+    lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj);
+    if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS)
         return false;
     
     // Get a wchar_t basic type from the current type system
     CompilerType wchar_compiler_type = valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
     
     if (!wchar_compiler_type)
         return false;
     
     const uint32_t wchar_size = wchar_compiler_type.GetBitSize(nullptr); // Safe to pass NULL for exe_scope here
     
     StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
-    options.SetLocation(data_addr);
+    options.SetLocation(valobj_addr);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetPrefixToken('L');
     
     switch (wchar_size)
     {
         case 8:
             return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options);

lldb/trunk/test/lang/cpp/char1632_t/TestChar1632T.py

def char1632(self):
         # Check that we correctly report the const types
         self.expect("frame variable cs16 cs32",
             substrs = ['(const char16_t *) cs16 = ','(const char32_t *) cs32 = ','u"hello world ྒྙྐ"','U"hello world ྒྙྐ"'])
 
         # Check that we correctly report the non-const types
         self.expect("frame variable s16 s32",
             substrs = ['(char16_t *) s16 = ','(char32_t *) s32 = ','u"ﺸﺵۻ"','U"ЕЙРГЖО"'])
 
+        # Check that we correctly report the array types
+        self.expect("frame variable as16 as32",
+            patterns = ['\(char16_t \[[0-9]+\]\) as16 = ', '\(char32_t \[[0-9]+\]\) as32 = '],
+            substrs = ['u"ﺸﺵۻ"','U"ЕЙРГЖО"'])
+
         self.runCmd("next") # step to after the string is nullified
 
         # check that we don't crash on NULL
         self.expect("frame variable s32",
             substrs = ['(char32_t *) s32 = 0x00000000'])
 
         # continue and hit breakpoint2
         self.runCmd("continue")
 
         # check that the new strings show
         self.expect("frame variable s16 s32",
             substrs = ['(char16_t *) s16 = 0x','(char32_t *) s32 = ','"色ハ匂ヘト散リヌルヲ"','"෴"'])
 
+        # check the same as above for arrays
+        self.expect("frame variable as16 as32",
+            patterns = ['\(char16_t \[[0-9]+\]\) as16 = ', '\(char32_t \[[0-9]+\]\) as32 = '],
+            substrs = ['"色ハ匂ヘト散リヌルヲ"','"෴"'])
+
         # check that zero values are properly handles
         self.expect('frame variable cs16_zero', substrs=["U+0000 u'\\0'"])
         self.expect('frame variable cs32_zero', substrs=["U+0x00000000 U'\\0'"])
         self.expect('expression cs16_zero', substrs=["U+0000 u'\\0'"])
         self.expect('expression cs32_zero', substrs=["U+0x00000000 U'\\0'"])
 
         # Check that we can run expressions that return charN_t
         self.expect("expression u'a'",substrs = ['(char16_t) $',"61 u'a'"])
         self.expect("expression U'a'",substrs = ['(char32_t) $',"61 U'a'"])
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

lldb/trunk/test/lang/cpp/char1632_t/main.cpp

 //===-- main.c --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include <assert.h>
+#include <string>
+
+#define UASZ 64
+
+template<class T, int N>
+void copy_char_seq (T (&arr)[N], const T* src)
+{
+    size_t src_len = std::char_traits<T>::length(src);
+    assert(src_len < N);
+
+    std::char_traits<T>::copy(arr, src, src_len);
+    arr[src_len] = 0;
+}
 
 int main (int argc, char const *argv[])
 {
+    char16_t as16[UASZ];
+    char32_t as32[UASZ];
     auto cs16_zero = (char16_t)0;
     auto cs32_zero = (char32_t)0;
     auto cs16 = u"hello world ྒྙྐ";
-  auto cs32 = U"hello world ྒྙྐ";
+    auto cs32 = U"hello world ྒྙྐ";
     char16_t *s16 = (char16_t *)u"ﺸﺵۻ";
     char32_t *s32 = (char32_t *)U"ЕЙРГЖО";
+    copy_char_seq(as16, s16);
+    copy_char_seq(as32, s32);
     s32 = nullptr; // breakpoint1
     s32 = (char32_t *)U"෴";
     s16 = (char16_t *)u"色ハ匂ヘト散リヌルヲ";
+    copy_char_seq(as16, s16);
+    copy_char_seq(as32, s32);
     s32 = nullptr; // breakpoint2
     return 0;
 }