LLDB-MI: Bug when evaluating strings containing characters from non-ascii range

[evgeny777]

Summary

In case string contains characters out of ASCII range, lldb-mi prints them as hexadecimal codes
The correct behaviour should be converting to UTF-8 instead. This patch fixes this making lldb-mi use
registered type summary providers, when they are available

Another problem is incorrect evaluation of some composite types, like std::string, which is also fixed in a way described above (using type summary provider)

[ki.stfu]

Please always add lldb-commits to subscribers

[clayborg]

You can't use std::string in the public API. Use lldb::SBStream as noted in inlined comments.

include/lldb/API/SBValue.h

132–133

You can't use std::string in the public API. You should use a SBStream instead. It can be used here:

bool
GetValueSummary (SBStream &strm);

Then you can get the data and length:

const char *data = strm.GetData();
const size_t data_len = strm.GetSize();

source/API/SBValue.cpp

711

Use SBStream

[granata.enrico]

Is there a reason to explicitly add an API to get the concatenation of value and summary?

We already have APIs to retrieve the pieces:

const char *
GetValue ();

const char *
GetSummary ();

We even already have an API to retrieve the summary in an SBStream:

const char *
GetSummary (lldb::SBStream& stream,
            lldb::SBTypeSummaryOptions& options);

Is there a reason why the MI can't just call these APIs and then process the results as it sees fit?

[clayborg]

As Enrico stated. there is already a SBStream based way to get the summary in "const char * SBValueGetSummary (lldb::SBStream& stream, lldb::SBTypeSummaryOptions& options);" so no need to add anything as I had suggested.

[evgeny777]

Yes I know about GetValue() and stuff
Actually I implemented new method, because I needed TypeSummaryImpl::DoesPrintValue().
In lldb when you evaluate char*, you get both value and summary, for example:

0xdeadbeef "hello"

But when you evaluate char[] array, you get just "hello". Value is not printed, because DoesPrintValue() method returns false
The same is for UTF-16 characters (char16_t). This type has both value and summary, but only summary is printed by lldb

I wanted to replicate the same behavior in lldb-mi. But if adding methods to SBValue should be avoided, I'll think of some workaround inside lldb-mi.
Your opinions are welcome, of course

[granata.enrico]

Gotcha!

My suggestion would be to add the DoesPrintValue() logic to SBTypeSummary. I can't recall if it's there already - but if not, it would be a fine thing to add. Then the MI could use SBValue and SBTypeSummary to make that determination as it sees fit.

[ki.stfu]

Please, next time make a patch with full context:

svn diff --diff-cmd diff -x "-U9999" > mypatch.txt

This will help us to reduce the review time.

test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

14

Probably it should be named like eval_and_check_array()

16–19

Please use '%' operator to format the string.

21

This comment deceives us because you use eval_ap on the line #56 at the time when char-array-as-string is "off".

22

What is ap stands for?

26

This looks like a magic. \t is a part of the variable's value, so please pass it via arguments too.

BTW: Use add_slashes() from MiLibraryLoadedTestCase.test_lldbmi_library_loaded test case to reduce amount of '\' characters.

62

'u' belongs to "hello". Please pass them together.

85

Why the size is a regexp (it was 10)?

100

Please don't use your company name here.

109

Where is it from? It must be removed before merging.

121–143

This test case doesn't relate to gdb-set/gdb-show commands, so it should be in test/tools/lldb-mi/variable/TestMiVar.py

125

Rename to something more specific (test_lldbmi_var_create_for_stl_types, for ex)

143

Looks like "std::__1::string" is a platform-dependent name. Don't use it.

test/tools/lldb-mi/variable/main.cpp

13

Don't use entire namespaces where they aren't needed. Just use std::string on the line #83

70–73

Please don't use your company name here.

83

just use std::string here, and rename please:

std::string std_string = "\t\"hello\"\n";

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

20–24

What is it?

[evgeny777]

Revised according to suggestions from granta.enrico and ki.stfu

[evgeny777]

Revised, removed dependencies from D13094

[ki.stfu]

include/lldb/API/SBTypeSummary.h

125–126 ↗

(On Diff #35618)

You can use clang-format to follow the LLDB coding style, or just do the following:

bool
DoesPrintValue (const SBValue &value);

source/API/SBTypeSummary.cpp

290 ↗

(On Diff #35618)

ditto

test/tools/lldb-mi/variable/TestMiVar.py

355 ↗

(On Diff #35618)

Use lazy regex:

self.expect('\^done,name="var\d+",numchild="[0-9]+",value="\\\\"hello\\\\"",type="std::[\S]*?string",thread-id="1",has_more="0"')

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

173–174

vwrValue = GetValueSummary();
if (!vwrValue.empty)
  return MIstatus::success;

191–193

const CMIUtilString summary = GetValueSummary();
if (!summary.empty())
    return summary;

242–244

const CMIUtilString summary = GetValueSummary();
if (!summary.empty())
    return summary;

285–287

const CMIUtilString summary = GetValueSummary();
if (!summary.empty())
    return summary;

tools/lldb-mi/MICmnLLDBUtilSBValue.h

58 ↗

(On Diff #35618)

It is better:

CMIUtilString GetValueSummary(CMIUtilString &vrValue) const

[evgeny777]

tools/lldb-mi/MICmnLLDBUtilSBValue.h

58 ↗

(On Diff #35618)

Really?

Did you mean
const CMIUtilString& GetValueSummary(void) const ?

[evgeny777]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

191–193

const CMIUtilString& summary = GetValueSummary(); ???

[ki.stfu]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

191–193

Yes, it's ok.

tools/lldb-mi/MICmnLLDBUtilSBValue.h

58 ↗

(On Diff #35618)

Sorry, I mistyped.

CMIUtilString GetValueSummary() const

[evgeny777]

source/API/SBTypeSummary.cpp

290 ↗

(On Diff #35618)

I used clang-format with style file taken from lldb directory here, but formatting didn't change. So I'm curious what's the problem is

[evgeny777]

Revised with changes requested by ki.stfu

[ki.stfu]

lgtm

[ki.stfu]

But you still should get lgtm from @clayborg and @granata.enrico before landing.

[jasonmolenda]

NB: Greg is out for the next nine days, Enrico for the next five days.

[granata.enrico]

Sorry, I didn't realize you were still waiting on me to land this patch.

I have a few extra comments before this is ready to land.

include/lldb/API/SBTypeSummary.h

125 ↗

(On Diff #35725)

Can you please change this to

bool
DoesPrintValue (lldb::SBValue value);

There is no need to pass the SBValue by reference since you're not actually altering it - and since SBValue wraps a (glorified) pointer to a ValueObject you're not really copying much data over. I don't see the need to classify the function as const (only IsValid() seems to be marked thusly in that file), and definitely no need for the SBValue to be a const

source/API/SBTypeSummary.cpp

289 ↗

(On Diff #35725)

Of course change this in the C++ file as well

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

372

I might be missing something, but how is this going to work when an SBValue has a value but no summary (something as simple as int x = 1;)?

GetSummary() is free to return NULL, and I only see you fetching the value here when there is a summary. Your logic should be more like

GetSummary()
if (!summary || summary && DoesPrintValue())
append value

A very long-term goal of mine is for all of this logic to exist in the ValueObjectPrinter and clients to simply be able to ask it to print a ValueObject according to some specification of theirs, in the middle of an existing stream. But that is way beyond the scope of your patch, so if you just clean up the logic here to do the right thing for values without summaries, I am happy.

[evgeny777]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

372

Short answer:
Yes types without summary work, please look at CMICmnLLDBUtilSBValue::GetSimpleValue() function

Longer anser:
This patch only addresses specific issues

• Correct UTF-16/32 handling for characters and strings
• Correct handling of composite types, like std::string

The patch logic is: if summary is available use it (optionally combined with value). If it is not then fall back to MI default formatting (see ConvertToPrintableASCII for example).
For other simple types, like int and float GetValueSummary() is never called (MI calls GetValue() instead)

Probably refactoring MI will provide better code, but this looks like to be out of this patch scope

[evgeny777]

include/lldb/API/SBTypeSummary.h

125 ↗

(On Diff #35725)

Ok.
Just curious - why const is bad?

[evgeny777]

Changed DoesPrintValue() function prototype

[granata.enrico]

I am not deeply involved in MI internals, so I am going to assume you ran the test suite, and that you actually verified that types without summaries still work

In general, once you opt into data formatters, you get a lot more than simply UTF handling. I understand that this is your rationale for the change, but you may want to make sure that MI still does the right thing if users define formatters for types that have nothing to do with strings (e.g. what if somebody does define a summary for int or float?)

With that said, this looks reasonable, and an MI refactoring would be outside of my realm anyway.

[dawn]

You can use clang-format to follow the LLDB coding style, or just do the following:

So we've been telling folks to use clang-format, but it's not working correctly (my version is clang-format version 3.6.0 (217927)). It's turns:

bool
DoesPrintValue (lldb::SBValue value);

into:

bool DoesPrintValue (lldb::SBValue value);

We have AlwaysBreakAfterDefinitionReturnType set to true, but that only works on function definitions. I see there is a patch for AlwaysBreakAfterDeclarationReturnType at http://reviews.llvm.org/D10370?id=27471, but it's not been accepted yet.

So for now, we can't rely on clang-format for function declarations :(

[dawn]

This patch is good to commit now right? It's not marked "accepted" for some reason.

[granata.enrico]

I Thought I had marked it as good to go.
My bad if I have not.

• Enrico

[evgeny777]

Thanks for a good point.
MI formatting refactoring will likely come soon as a separate review

[ki.stfu]

In D13058#258903, @dawn wrote:

This patch is good to commit now right? It's not marked "accepted" for some reason.

It's not "accepted" because @clayborg rejected this CL and hasn't changed his decision. But I think he will not mind if you go ahead.

[clayborg]

Back from vacation, sorry for the delay. Looks good if Enrico is happy.

include/lldb/API/SBValue.h

     const char *
     GetLocation ();
 
+    bool
+    PrintValueSummary (std::string& valsum);
+
     // Deprecated - use the one that takes SBError&
     bool
     SetValueFromCString (const char *value_str);

source/API/SBValue.cpp

     return cstr;
 }
 
+// Used by LLDB-MI to print characters and strings
+bool
+SBValue::PrintValueSummary (std::string& valsum)
+{
+    std::string val;
+    ValueLocker locker;
+    lldb_private::TypeSummaryOptions options;
+
+    lldb::ValueObjectSP value_sp(GetSP(locker));
+    if (value_sp && value_sp->UpdateValueIfNeeded(true))
+    {
+        lldb::TypeSummaryImplSP summary = value_sp->GetSummaryFormat();
+        if (summary && summary->FormatObject(value_sp.get(), valsum, options))
+        {
+            if (summary->DoesPrintValue(value_sp.get()) &&
+                value_sp->GetValueAsCString(lldb::eFormatDefault, val) &&
+                !val.empty())
+            {
+                valsum = val + " " + valsum;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
 // Deprecated - use the one that takes an lldb::SBError
 bool
 SBValue::SetValueFromCString (const char *value_str)

test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

+# coding=utf8
 """
 Test lldb-mi -gdb-set and -gdb-show commands for 'print option-name'.
 """

 class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    # evaluates array when char-array-as-string is off
+    def eval_array(self, name, length, typ):
+        self.runCmd("-var-create - * " + name)
+        self.expect("\^done,name=\"var\d+\",numchild=\"" + 
+            str(length) +
+            "\",value=\"\[" + str(length) + "\]\",type=\"" +
+            typ + " \[" + str(length) + "\]\",thread-id=\"1\",has_more=\"0\"")
+
+    # evaluates array or pointer when char-array-as-string is on
+    def eval_ap(self, name, value, sum_part, typ):
+        self.runCmd("-var-create - * " + name)
+        self.expect("\^done,name=\"var\d+\",numchild=\"[0-9]+\",value=\"" +
+            value +
+            "\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\""+ sum_part +"\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"" +
+            typ +
+            "\",thread-id=\"1\",has_more=\"0\"")
 
     @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows

         self.expect("\^done,value=\"off\"")
 
         # Test that an char* is expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * cp")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("cp", "0x[0-9a-f]+ ", "hello", "const char \\*")
 
         # Test that an char[] isn't expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * ca")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_array("ca", 10, "const char");
 
         # Test that an char16_t* is expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * u16p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u16p", "0x[0-9a-f]+ u", "hello", "const char16_t \\*")
 
         # Test that an char16_t[] isn't expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * u16a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char16_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_array("u16a", 10, "const char16_t");
 
         # Test that an char32_t* is expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * u32p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u32p", "0x[0-9a-f]+ U", "hello", "const char32_t \\*")
 
         # Test that an char32_t[] isn't expanded to string when print char-array-as-string is "off"
-        self.runCmd("-var-create - * u32a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char32_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_array("u32a", 10, "const char32_t");
 
         # Test that -gdb-set can set print char-array-as-string flag
         self.runCmd("-gdb-set print char-array-as-string on")

         self.expect("\^done,value=\"on\"")
 
         # Test that an char* with escape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * cp")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("cp", "0x[0-9a-f]+ ", "hello", "const char \\*")
         
         # Test that an char[] with escape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * ca")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("ca", "", "hello", "const char \\[[0-9]+\\]")
         
         # Test that an char16_t* with esc1ape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * u16p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u16p", "0x[0-9a-f]+ u", "hello", "const char16_t \\*")
         
         # Test that an char16_t[] with escape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * u16a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u16a", "u", "hello", "const char16_t \\[[0-9]+\\]")
         
         # Test that an char32_t* with escape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * u32p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u32p", "0x[0-9a-f]+ U", "hello", "const char32_t \\*")
         
         # Test that an char32_t[] with escape chars is expanded to string when print char-array-as-string is "on"
-        self.runCmd("-var-create - * u32a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_ap("u32a", "U", "hello", "const char32_t \\[[0-9]+\\]")
+
+        # Test russian unicode strings
+        rval = "Эмбаркадеро"
+        self.eval_ap("u16p_rus", "0x[0-9a-f]+ u", rval, "const char16_t \\*")
+        self.eval_ap("u16a_rus", "u", rval, "const char16_t \\[[0-9]+\\]")
+        self.eval_ap("u32p_rus", "0x[0-9a-f]+ U", rval, "const char32_t \\*")
+        self.eval_ap("u32a_rus", "U", rval, "const char32_t \\[[0-9]+\\]")
+
+        # Additional test for escaping
+        # \\\\\\\" \\n -> \\\" \n
+        # in python regex \\\\ -> \
+        rval = '\\\\' * 7 + '" ' + '\\\\' * 2 + 'n'
+        self.eval_ap("u16p_esc", "0x[0-9a-f]+ u", rval, "const char16_t \\*")
+        self.eval_ap("u16a_esc", "u", rval, "const char16_t \\[[0-9]+\\]")
 
         # Test that -gdb-set print char-array-as-string fails if "on"/"off" isn't specified
         self.runCmd("-gdb-set print char-array-as-string")

 
     @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
+    def test_lldbmi_stl_types(self):
+        """Test that 'lldb-mi --interpreter' print summary for STL types."""
+
+        self.spawnLldbMi(args = None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Run to BP_gdb_set_show_print_char_array_as_string_test
+        line = line_number('main.cpp', '// BP_cpp_stl_types_test')
+        self.runCmd("-break-insert main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"1\"")
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+        # Test for std::string
+        self.eval_ap("mi_string", "", "hello", "std::__1::string")
+
+    @lldbmi_test
+    @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @expectedFailureGcc("https://llvm.org/bugs/show_bug.cgi?id=23357")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_show_print_expand_aggregates(self):

         self.expect("\^done,name=\"var1\",numchild=\"3\",value=\"{\.\.\.}\",type=\"complex_type\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that composite type[] isn't expanded when print expand-aggregates is "off"
-        self.runCmd("-var-create var2 * complx_array")
-        self.expect("\^done,name=\"var2\",numchild=\"2\",value=\"\[2\]\",type=\"complex_type \[2\]\",thread-id=\"1\",has_more=\"0\"")
+        self.eval_array("complx_array", 2, "complex_type")
 
         # Test that a struct with a char first element is not formatted as a string
         self.runCmd("-var-create - * &nstr")

test/tools/lldb-mi/variable/main.cpp

 //===----------------------------------------------------------------------===//
 
 #include <cstdint>
+#include <string>
+
+using namespace std;
 
 struct complex_type
 {

     const char32_t *u32p = U"\t\"hello\"\n";
     const char32_t u32a[] = U"\t\"hello\"\n";
 
+    const char16_t* u16p_rus = u"\t\"Эмбаркадеро\"\n";
+    const char16_t  u16a_rus[] = u"\t\"Эмбаркадеро\"\n";
+    const char32_t* u32p_rus = U"\t\"Эмбаркадеро\"\n";
+    const char32_t  u32a_rus[] = U"\t\"Эмбаркадеро\"\n";
+
+    const char16_t* u16p_esc = u"\t\"\\\" \n\"\n";
+    const char16_t u16a_esc[] = u"\t\"\\\" \n\"\n";
     // BP_gdb_set_show_print_char_array_as_string_test
 }
 
+void
+cpp_stl_types_test(void)
+{
+    string mi_string = "\t\"hello\"\n";
+    // BP_cpp_stl_types_test
+}
+
 struct not_str
 {
     not_str(char _c, int _f)

     var_update_test();
     var_list_children_test();
     gdb_set_show_print_char_array_as_string_test();
+    cpp_stl_types_test();
     gdb_set_show_print_expand_aggregates();
     gdb_set_show_print_aggregate_field_names();
     return 0; // BP_return

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

 #include "MICmnMIValueTuple.h"
 #include "MIUtilString.h"
 
+#if 0
+#include "lldb/Core/ValueObject.h"
+#include "lldb/DataFormatters/TypeSummary.h"
+#endif
+
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnLLDBUtilSBValue constructor.
 // Type:    Method.

             return MIstatus::success;
         }
     }
+    else
+    {
+        // Treat composite value which has registered summary
+        // (for example with AddCXXSummary) as simple value
+        std::string result;
+        if (m_rValue.PrintValueSummary(result))
+        {
+            vwrValue = result.c_str();
+            return MIstatus::success;
+        }
+    }
 
     // Composite variable type i.e. struct
     return MIstatus::failure;

 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueChar() const
 {
+    std::string result;
+    if (m_rValue.PrintValueSummary(result))
+        return result.c_str();
+
     const uint64_t value = m_rValue.GetValueAsUnsigned();
     if (value == 0)
     {

 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueCStringPointer() const
 {
+    std::string result;
     const char *value = m_rValue.GetValue();
     if (value == nullptr)
         return m_pUnkwn;
 
+    if (m_rValue.PrintValueSummary(result))
+        return result.c_str();
+
     lldb::SBValue child = m_rValue.GetChildAtIndex(0);
     const lldb::BasicType eType = child.GetType().GetBasicType();
     switch (eType)

 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueCStringArray() const
 {
+    std::string result;
+    if (m_rValue.PrintValueSummary(result))
+        return result.c_str();
+
     const MIuint nChildren = m_rValue.GetNumChildren();
     lldb::SBValue child = m_rValue.GetChildAtIndex(0);
     const lldb::BasicType eType = child.GetType().GetBasicType();