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 ↗

(On Diff #35379)

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 ↗

(On Diff #35379)

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

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

ditto

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

355

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

It is better:

CMIUtilString GetValueSummary(CMIUtilString &vrValue) const

[evgeny777]

tools/lldb-mi/MICmnLLDBUtilSBValue.h

58

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

Sorry, I mistyped.

CMIUtilString GetValueSummary() const

[evgeny777]

source/API/SBTypeSummary.cpp

290

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

128

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

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

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

371

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

371

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

128

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/SBTypeSummary.h

public:
         GetOptions ();
         
         void
         SetOptions (uint32_t);
         
         bool
         GetDescription (lldb::SBStream &description, 
                         lldb::DescriptionLevel description_level);
-        
+        bool
+        DoesPrintValue (const SBValue& value);
+        
         lldb::SBTypeSummary &
         operator = (const lldb::SBTypeSummary &rhs);
         
         bool
         IsEqualTo (lldb::SBTypeSummary &rhs);
 
         bool
         operator == (lldb::SBTypeSummary &rhs);
         

source/API/SBTypeSummary.cpp

 //===-- SBTypeSummary.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSummary.h"
 
 #include "lldb/API/SBStream.h"
 
+#include "lldb/API/SBValue.h"
+
 #include "lldb/DataFormatters/DataVisualization.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #ifndef LLDB_DISABLE_PYTHON
 
 SBTypeSummaryOptions::SBTypeSummaryOptions()
if (!CopyOnWrite_Impl())
         return false;
     else {
         description.Printf("%s\n",
                            m_opaque_sp->GetDescription().c_str());
         return true;
     }
 }
 
+bool
+SBTypeSummary::DoesPrintValue(const SBValue& value)
+{
+    if (!IsValid())
+        return false;
+
+    lldb::ValueObjectSP value_sp = value.GetSP();
+    return m_opaque_sp->DoesPrintValue(value_sp.get());
+}
+
+
 lldb::SBTypeSummary &
 SBTypeSummary::operator = (const lldb::SBTypeSummary &rhs)
 {
     if (this != &rhs)
     {
         m_opaque_sp = rhs.m_opaque_sp;
     }
     return *this;

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

+#coding=utf8
 """
 Test lldb-mi -gdb-set and -gdb-show commands for 'print option-name'.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    # evaluates array when char-array-as-string is off
+    def eval_and_check_array(self, var, typ, length):
+        self.runCmd("-var-create - * %s" % var)
+        self.expect('\^done,name="var\d+",numchild="%d",value="\[%d\]",type="%s \[%d\]",thread-id="1",has_more="0"' % (length, length, typ, length))
+
+    # evaluates any type which can be represented as string of characters
+    def eval_and_match_string(self, var, value, typ):
+        value=value.replace("\\", "\\\\").replace("\"", "\\\"")
+        self.runCmd("-var-create - * " + var)
+        self.expect('\^done,name="var\d+",numchild="[0-9]+",value="%s",type="%s",thread-id="1",has_more="0"' % (value, typ))
+
     @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_gdb_set_show_print_char_array_as_string(self):
         """Test that 'lldb-mi --interpreter' can print array of chars as string."""
 
         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_gdb_set_show_print_char_array_as_string_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 that default print char-array-as-string value is "off"
         self.runCmd("-gdb-show print char-array-as-string")
         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_and_match_string("cp", r'0x[0-9a-f]+ \"\\t\\\"hello\\\"\\n\"', r'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_and_check_array("ca", "const char", 10);
 
         # 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_and_match_string("u16p", r'0x[0-9a-f]+ u\"\\t\\\"hello\\\"\\n\"', r'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_and_check_array("u16a", "const char16_t", 10);
 
         # 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_and_match_string("u32p", r'0x[0-9a-f]+ U\"\\t\\\"hello\\\"\\n\"', r'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_and_check_array("u32a", "const char32_t", 10);
 
         # 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")
         self.runCmd("-gdb-set print char-array-as-string 1")
         self.expect("\^done")
         self.runCmd("-gdb-show print char-array-as-string")
         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_and_match_string("cp", r'0x[0-9a-f]+ \"\\t\\\"hello\\\"\\n\"', r'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_and_match_string("ca", r'\"\\t\\\"hello\\\"\\n\"', r'const char \[10\]')
         
         # 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_and_match_string("u16p", r'0x[0-9a-f]+ u\"\\t\\\"hello\\\"\\n\"', r'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_and_match_string("u16a", r'u\"\\t\\\"hello\\\"\\n\"', r'const char16_t \[10\]')
         
         # 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_and_match_string("u32p", r'0x[0-9a-f]+ U\"\\t\\\"hello\\\"\\n\"', r'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_and_match_string("u32a", r'U\"\\t\\\"hello\\\"\\n\"', r'const char32_t \[10\]')
+
+        # Test russian unicode strings
+        self.eval_and_match_string("u16p_rus", r'0x[0-9a-f]+ u\"\\\\Аламо-сквер\"', r'const char16_t \*')
+        self.eval_and_match_string("u16a_rus", r'u\"\\\\Бейвью\"', r'const char16_t \[8\]')
+        self.eval_and_match_string("u32p_rus", r'0x[0-9a-f]+ U\"\\\\Чайнатаун\"', r'const char32_t \*')
+        self.eval_and_match_string("u32a_rus", r'U\"\\\\Догпатч\"', r'const char32_t \[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")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
         # Test that -gdb-set print char-array-as-string fails when option is unknown
         self.runCmd("-gdb-set print char-array-as-string unknown")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
     @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):
         """Test that 'lldb-mi --interpreter' can expand aggregates everywhere."""
 
         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_expand_aggregates
         line = line_number('main.cpp', '// BP_gdb_set_show_print_expand_aggregates')
         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 that default print expand-aggregates value is "off"
         self.runCmd("-gdb-show print expand-aggregates")
         self.expect("\^done,value=\"off\"")
 
         # Test that composite type isn't expanded when print expand-aggregates is "off"
         self.runCmd("-var-create var1 * complx")
         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_and_check_array("complx_array", "complex_type", 2)
 
         # Test that a struct with a char first element is not formatted as a string
         self.runCmd("-var-create - * &nstr")
         self.expect("\^done,name=\"var\d+\",numchild=\"2\",value=\"0x[0-9a-f]+\",type=\"not_str \*\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that -gdb-set can set print expand-aggregates flag
         self.runCmd("-gdb-set print expand-aggregates on")
         self.expect("\^done")
         self.runCmd("-gdb-set print expand-aggregates 1")
         self.expect("\^done")
         self.runCmd("-gdb-show print expand-aggregates")
         self.expect("\^done,value=\"on\"")
 

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

def test_lldbmi_var_list_children(self):
         # FIXME: -1 is treated as unsigned int
         self.runCmd("-var-list-children 0 var_complx 0 -1")
         #self.expect("\^error,msg=\"Command 'var-list-children'\. Variable children range invalid\"")
 
         # Test that a missing low-frame or high-frame is handled
         self.runCmd("-var-list-children 0 var_complx 0")
         self.expect("\^error,msg=\"Command 'var-list-children'. Variable children range invalid\"")
 
+    @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_var_create_for_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.runCmd("-var-create - * std_string")
+        self.expect('\^done,name="var\d+",numchild="[0-9]+",value="\\\\"hello\\\\"",type="std::[\S]*string",thread-id="1",has_more="0"')
+
 if __name__ == '__main__':
     unittest2.main()

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

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdint>
+#include <string>
 
 struct complex_type
 {
     int i;
     struct { long l; } inner;
     complex_type *complex_ptr;
 };
 
 struct pcomplex_type : complex_type
 {

 {
     const char *cp = "\t\"hello\"\n";
     const char ca[] = "\t\"hello\"\n";
     const char16_t *u16p = u"\t\"hello\"\n";
     const char16_t u16a[] = u"\t\"hello\"\n";
     const char32_t *u32p = U"\t\"hello\"\n";
     const char32_t u32a[] = U"\t\"hello\"\n";
 
+    const char16_t* u16p_rus = u"\\Аламо-сквер";
+    const char16_t  u16a_rus[] = u"\\Бейвью";
+    const char32_t* u32p_rus = U"\\Чайнатаун";
+    const char32_t  u32a_rus[] = U"\\Догпатч";
+
     // BP_gdb_set_show_print_char_array_as_string_test
 }
 
+void
+cpp_stl_types_test(void)
+{
+    std::string std_string = "hello";
+    // BP_cpp_stl_types_test
+}
+
 struct not_str
 {
     not_str(char _c, int _f)
         : c(_c), f(_f) { }
     char c;
     int f;
 };
 
 void

 int
 main(int argc, char const *argv[])
 {
     int a = 10, b = 20;
     s_MyVar = a + b;
     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.h

public:
     // Methods:
   private:
     template <typename charT> CMIUtilString ReadCStringFromHostMemory(lldb::SBValue &vrValue, const MIuint vnMaxLen = UINT32_MAX) const;
     bool GetSimpleValue(const bool vbHandleArrayType, CMIUtilString &vrValue) const;
     CMIUtilString GetSimpleValueChar() const;
     CMIUtilString GetSimpleValueCStringPointer() const;
     CMIUtilString GetSimpleValueCStringArray() const;
     bool GetCompositeValue(const bool vbPrintFieldNames, CMICmnMIValueTuple &vwrMiValueTuple, const MIuint vnDepth = 1) const;
-
+    bool TryGetValueSummary(CMIUtilString &vrValue) const;
     // Statics:
   private:
     static bool IsCharBasicType(lldb::BasicType eType);
 
     // Attributes:
   private:
     lldb::SBValue &m_rValue;
     const char *m_pUnkwn;
     const char *m_pComposite;
     bool m_bValidSBValue;    // True = SBValue is a valid object, false = not valid.
     bool m_bHandleCharType;  // True = Yes return text molding to char type, false = just return data.
     bool m_bHandleArrayType; // True = Yes return special stub for array type, false = just return data.
 };

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

 
 // In-house headers:
 #include "MICmnLLDBUtilSBValue.h"
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnMIValueConst.h"
 #include "MICmnMIValueTuple.h"
 #include "MIUtilString.h"
 
+#include "lldb/API/SBTypeSummary.h"
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnLLDBUtilSBValue constructor.
 // Type:    Method.
 // Args:    vrValue             - (R) The LLDB value object.
 //          vbHandleCharType    - (R) True = Yes return text molding to char type,
 //                                    False = just return data.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnLLDBUtilSBValue::CMICmnLLDBUtilSBValue(const lldb::SBValue &vrValue, const bool vbHandleCharType /* = false */,
                                              const bool vbHandleArrayType /* = true */)
     : m_rValue(const_cast<lldb::SBValue &>(vrValue))
else if (IsArrayType())
             return MIstatus::success;
         }
         else if (vbHandleArrayType)
         {
             vwrValue = CMIUtilString::Format("[%u]", nChildren);
             return MIstatus::success;
         }
     }
+    else
+    {
+        // Treat composite value which has registered summary
+        // (for example with AddCXXSummary) as simple value
+        if (TryGetValueSummary(vwrValue))
+            return MIstatus::success;
+    }
 
     // Composite variable type i.e. struct
     return MIstatus::failure;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve from the LLDB SB Value object the char value of the variable.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The char value of the variable.
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueChar() const
 {
+    CMIUtilString summary;
+    if (TryGetValueSummary(summary))
+        return summary;
+
     const uint64_t value = m_rValue.GetValueAsUnsigned();
     if (value == 0)
     {
         const uint64_t nFailValue = 1;
         if (nFailValue == m_rValue.GetValueAsUnsigned(nFailValue))
             return m_pUnkwn;
     }
 

 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueCStringPointer() const
 {
     const char *value = m_rValue.GetValue();
     if (value == nullptr)
         return m_pUnkwn;
 
+    CMIUtilString summary;
+    if (TryGetValueSummary(summary))
+        return summary;
+
     lldb::SBValue child = m_rValue.GetChildAtIndex(0);
     const lldb::BasicType eType = child.GetType().GetBasicType();
     switch (eType)
     {
         default:
             assert(0 && "child must be a char type");
         case lldb::eBasicTypeChar:
         case lldb::eBasicTypeSignedChar:

 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The c-string value of the variable.
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueCStringArray() const
 {
+    CMIUtilString summary;
+    if (TryGetValueSummary(summary))
+        return summary;
+
     const MIuint nChildren = m_rValue.GetNumChildren();
     lldb::SBValue child = m_rValue.GetChildAtIndex(0);
     const lldb::BasicType eType = child.GetType().GetBasicType();
     switch (eType)
     {
         default:
             assert(0 && "value must be a char[] type");
         case lldb::eBasicTypeChar:
for (MIuint i = 0; i < nChildren; ++i)
             const bool bUseSpacing = false;
             vwrMiValueTuple.Add(miValueConst, bUseSpacing);
         }
     }
 
     return MIstatus::success;
 }
 
+bool
+CMICmnLLDBUtilSBValue::TryGetValueSummary(CMIUtilString &vrValue) const
+{
+    if (!m_rValue.IsValid())
+        return false;
+
+    vrValue = m_rValue.GetSummary();
+    if (!vrValue.empty())
+    {
+        lldb::SBTypeSummary summary = m_rValue.GetTypeSummary();
+        if (summary.IsValid() && summary.DoesPrintValue(m_rValue))
+        {
+            CMIUtilString valStr = m_rValue.GetValue();
+            if (!valStr.empty())
+            {
+                vrValue.insert(0, valStr + " ");
+            }
+        }
+        return true;
+    }
+
+    return false;
+}
+
 //++ ------------------------------------------------------------------------------------
 // Details: Check that basic type is a char type. Char type can be signed or unsigned.
 // Type:    Static.
 // Args:    eType   - type to check
 // Return:  bool    - True = Yes is a char type, false = some other type.
 // Throws:  None.
 //--
 bool