[lldb] Don't print *trailing* nuls in char arrays

[labath]

Summary

Embedded nul characters are still printed, and they don't terminate the
string. See also D111634.

[kastiglione]

thanks for doing this!

lldb/source/Core/ValueObject.cpp

bool ValueObject::SetData(DataExtractor &data, Status &error) {
   // value.
   SetNeedsUpdate();
   return true;
 }
 
 static bool CopyStringDataToBufferSP(const StreamString &source,
                                      lldb::DataBufferSP &destination) {
   llvm::StringRef src = source.GetString();
-  src.consume_back(llvm::StringRef("\0", 1));
+  src = src.rtrim('\0');
   destination = std::make_shared<DataBufferHeap>(src.size(), 0);
   memcpy(destination->GetBytes(), src.data(), src.size());
   return true;
 }
 
 std::pair<size_t, bool>
 ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
                                uint32_t max_length, bool honor_array,

lldb/test/API/functionalities/data-formatter/builtin-formats/TestBuiltinFormats.py

def test(self):
 
         # binary
         self.assertIn("= 0b00000000000000000000000000000010\n", self.getFormatted("binary", "2"))
         self.assertIn("= 0b01100001\n", self.getFormatted("binary", "'a'"))
         self.assertIn(" = 0b10010001101000101011001111000\n", self.getFormatted("binary", "(__uint128_t)0x12345678ll"))
 
         # Different character arrays.
         # FIXME: Passing a 'const char *' will ignore any given format,
-        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("character array", "cstring"))
-        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("c-string", "cstring"))
+        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09"', self.getFormatted("character array", "cstring"))
+        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09"', self.getFormatted("c-string", "cstring"))
         self.assertIn(' = " \\e\\a\\b\\f\\n\\r\\t\\vaA09" " \\U0000001b\\a\\b\\f\\n\\r\\t\\vaA09"\n',
                       self.getFormatted("c-string", "(char *)cstring"))
         self.assertIn('=\n', self.getFormatted("c-string", "(__UINT64_TYPE__)0"))
 
         # Build a uint128_t that contains a series of characters in each byte.
         # First 8 byte of the uint128_t.
         cstring_chars1 = " \a\b\f\n\r\t\v"
         # Last 8 byte of the uint128_t.
def test(self):
         ostype_expr = "(__UINT64_TYPE__)0x"
         for c in cstring_chars2:
              ostype_expr += format(ord(c), "x").zfill(2)
         self.assertIn("= 'AZaz09\\e\\0'\n", self.getFormatted("OSType", ostype_expr))
 
         self.assertIn('= 0x2007080c0a0d090b415a617a30391b00\n', self.getFormatted("OSType", string_expr))
 
         # bytes
-        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("bytes", "cstring"))
+        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09"', self.getFormatted("bytes", "cstring"))
 
         # bytes with ASCII
-        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09\0"', self.getFormatted("bytes with ASCII", "cstring"))
+        self.assertIn(r'= " \U0000001b\a\b\f\n\r\t\vaA09"', self.getFormatted("bytes with ASCII", "cstring"))
 
         # unicode8
         self.assertIn('= 0x78 0x56 0x34 0x12\n', self.getFormatted("unicode8", "0x12345678"))
 
         # unicode16
         self.assertIn('= U+5678 U+1234\n', self.getFormatted("unicode16", "0x12345678"))
 
         # unicode32

lldb/test/API/functionalities/data-formatter/stringprinter/main.cpp

 struct S {
   int x = 0;
 };
 S<char[5]> Schar5;
 S<char *> Scharstar;
 
 int main (int argc, char const *argv[])
 {
+    const char manytrailingnuls[] = "F\0OO\0BA\0R\0\0\0\0";
     A a, b, c;
     // Deliberately write past the end of data to test that the formatter stops
     // at the end of array.
     memcpy(a.data, "FOOBAR", 7);
     memcpy(b.data, "FO\0BAR", 7);
     memcpy(c.data, "F\0O\0AR", 7);
     std::string stdstring("Hello\t\tWorld\nI am here\t\tto say hello\n"); //%self.addTearDownHook(lambda x: x.runCmd("setting set escape-non-printables true"))
     const char *charwithtabs = stdstring.c_str();
" for science, or something"
     const char* longconstcharstar = longstring.c_str();
     return 0;     //% if self.TraceOn(): self.runCmd('frame variable')
     //%
     //% self.expect_var_path('stdstring', summary='"Hello\\t\\tWorld\\nI am here\\t\\tto say hello\\n"')
     //% self.expect_var_path('charwithtabs', summary='"Hello\\t\\tWorld\\nI am here\\t\\tto say hello\\n"')
     //% self.expect_var_path("a.data", summary='"FOOB"')
     //% self.expect_var_path("b.data", summary=r'"FO\0B"')
     //% self.expect_var_path("c.data", summary=r'"F\0O"')
+    //% self.expect_var_path("manytrailingnuls", summary=r'"F\0OO\0BA\0R"')
     //%
     //% for c in ["", "const"]:
     //%   for v in ["", "volatile"]:
     //%     for s in ["", "unsigned"]:
     //%       summary = '"'+c+v+s+'char"'
     //%       self.expect_var_path(c+v+s+"chararray", summary=summary)
     //% # These should be printed normally
     //%       self.expect_var_path(c+v+s+"charstar", summary=summary)

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s

 ## Variables specified via fixed-size forms. This is typical for gcc (9).
 # CHECK: (unsigned long) data1 = 47
 # CHECK: (unsigned long) data2 = 4742
 # CHECK: (unsigned long) data4 = 47424742
 # CHECK: (unsigned long) data8 = 4742474247424742
 ## Variables specified using string forms. This behavior purely speculative -- I
 ## don't know of any compiler that would represent character strings this way.
 # CHECK: (char[7]) string = "string"
-# CHECK: (char[7]) strp = "strp\0\0"
+# CHECK: (char[7]) strp = "strp"
 ## Bogus attribute form. Let's make sure we don't crash at least.
 # CHECK: (char[7]) ref4 = <empty constant data>
 ## A variable of pointer type.
 # CHECK: (unsigned long *) udata_ptr = 0xdeadbeefbaadf00d
 
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit