[lldb-mi] display summary for simple types + refactor (use lldb formatting for all cases)

[evgeny777]

Summary

Current revision do not use lldb type summaries for simple types with no children (like function pointers). So this patch makes MI use lldb type summaries for evaluation of all types of objects, so MI own formatters are no longer needed.

[granata.enrico]

tools/lldb-mi/MICmnLLDBDebugger.cpp

37

I would definitely not stop the revision for this but I wonder if it would make sense to try and discover whether "char" is signed or unsigned from the type itself?

841

Should you also cover "signed char" and "unsigned char" here?

[evgeny777]

tools/lldb-mi/MICmnLLDBDebugger.cpp

841

Hmm. I thought that if regex is false, exact match will be done, won't it? If yes than simple char type should be signed, right?

[evgeny777]

tools/lldb-mi/MICmnLLDBDebugger.cpp

37

To my understanding this is not needed (see comment below)

841

unsigned - not. signed -yes. One question: if I register summary for "char" - it will not be called for "unsigned char" and "signed char", right?
If so I will need adding "signed char" and no checks for signed/unsigned inside summary provider are required, correct?

[granata.enrico]

tools/lldb-mi/MICmnLLDBDebugger.cpp

841

I think the signedness of char depends on the implementation. Which means that "char" will cover one of them, but not the other. Which is why I was suggesting adding "char", "signed char" and "unsigned char". Just to cover all bases.

841

Correct. It will only be called for an exactly matching type name. We strip "useless" qualifiers like "volatile" and "restrict" before doing format matching. But, for obvious reasons, not signed and unsigned.

Well, if you add separate formatters for signed char vs. unsigned char, then they will know of course
The one for plain "char" might still need to figure it out though. Because given just "char", the signedness depends on the underlying compiler. I know internally we have support for this. If we don't in the SB API, we may need to add support. But that seems like it can be done in a subsequent revision.

[abidh]

Please also indicate if a revision is dependent on some other revisions that has not yet been committed as this one is on D13657.

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

126–127

As the condition is changed, can you explain a little bit in which scenario, you want to pass true/false here for first parameter.

131–132

Same as above.

[evgeny777]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

126–127

This is "get summary whenever possible, unless explicitly told otherwise".
For example this change of condition allows getting summary for function pointers (currently only hexadecimal pointer value is printed).

So false is only passed when character type is evaluated and m_bHandleCharType is false. I do not fully understand why this boolean flag exists - may be performance reasons?

131–132

In case one day someone create summary provider for some pointer type which is not char*, wchar_t* and related, it will be handled by MI correctly. The only exception is if we have char pointer and explicitly told not to handle char type

[evgeny777]

Review updated to reflect Enrico comments regarding signed/unsigned char.
Now all character types are evaluated as ASCII code (signed or unsigned) + value.

Additional method introduced to SBValue to check if type is signed or unsigned integer

[granata.enrico]

include/lldb/API/SBValue.h

372

Greg pointed me to SBType::GetBasicType() - this will return to you one of

eBasicTypeSignedChar,
eBasicTypeUnsignedChar,

such that you don't need to add new API to get this information

Also, even if this were necessary, it would go on SBType, definitely not SBValue

[evgeny777]

include/lldb/API/SBValue.h

372

This method exists in ValueObject, so I thought it makes sense having it in SBValue also. But ok, let's use GetBasicType

[evgeny777]

Update according to suggestions from granata.enrico

[abidh]

Apart from some inline comments, looks ok to me.

tools/lldb-mi/MICmnLLDBDebugger.cpp

831

Please change it to 'true' and 'false'.

include/lldb/API/SBValue.h

#endif
 
     bool
     GetExpressionPath (lldb::SBStream &description);
     
     bool
     GetExpressionPath (lldb::SBStream &description, 
                        bool qualify_cxx_base_classes);
 
+    bool
+    IsIntegerType(bool& is_signed);
+
     SBValue (const lldb::ValueObjectSP &value_sp);
 
     //------------------------------------------------------------------
     /// Watch this value if it resides in memory.
     ///
     /// Sets a watchpoint on the value.
     ///
     /// @param[in] resolve_location

source/API/SBValue.cpp

SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
     {
         value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
         return true;
     }
     return false;
 }
 
 bool
+SBValue::IsIntegerType(bool& is_signed)
+{    
+    ValueLocker locker;
+    lldb::ValueObjectSP value_sp(GetSP(locker));
+    return value_sp && value_sp->IsIntegerType(is_signed);
+}
+
+bool
 SBValue::GetDescription (SBStream &description)
 {
     Stream &strm = description.ref();
     
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
         value_sp->Dump(strm);

test/tools/lldb-mi/data/TestMiData.py

def test_lldbmi_data_disassemble(self):
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Get an address for disassembling: use main
         self.runCmd("-data-evaluate-expression main")
-        self.expect("\^done,value=\"0x[0-9a-f]+\"")
-        addr = int(self.child.after.split("\"")[1], 16)
+        self.expect("\^done,value=\"0x[0-9a-f]+ \(a.out`main at main.cpp:[0-9]+\)\"")
+        addr = int(self.child.after.split("\"")[1].split(" ")[0], 16)
 
         # Test -data-disassemble: try to disassemble some address
         self.runCmd("-data-disassemble -s %#x -e %#x -- 0" % (addr, addr + 0x10))
         self.expect("\^done,asm_insns=\[{address=\"0x0*%x\",func-name=\"main\",offset=\"0\",size=\"[1-9]+\",inst=\".+?\"}," % addr)
 
         # Run to hello_world
         self.runCmd("-break-insert -f hello_world")
         self.expect("\^done,bkpt={number=\"2\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Get an address for disassembling: use hello_world
         self.runCmd("-data-evaluate-expression hello_world")
-        self.expect("\^done,value=\"0x[0-9a-f]+\"")
-        addr = int(self.child.after.split("\"")[1], 16)
+        self.expect("\^done,value=\"0x[0-9a-f]+ \(a.out`hello_world\(\) at main.cpp:[0-9]+\)\"")
+        addr = int(self.child.after.split("\"")[1].split(" ")[0], 16)
 
         # Test -data-disassemble: try to disassemble some address
         self.runCmd("-data-disassemble -s %#x -e %#x -- 0" % (addr, addr + 0x10))
 
         # This matches a line similar to:
         # Darwin: {address="0x0000000100000f18",func-name="hello_world()",offset="8",size="7",inst="leaq 0x65(%rip), %rdi; \"Hello, World!\\n\""},
         # Linux:  {address="0x0000000000400642",func-name="hello_world()",offset="18",size="5",inst="callq 0x4004d0; symbol stub for: printf"}
         # To match the escaped characters in the ouptut, we must use four backslashes per matches backslash
def test_lldbmi_data_info_line(self):
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Get the address of main and its line
         self.runCmd("-data-evaluate-expression main")
-        self.expect("\^done,value=\"0x[0-9a-f]+\"")
-        addr = int(self.child.after.split("\"")[1], 16)
+        self.expect("\^done,value=\"0x[0-9a-f]+ \(a.out`main at main.cpp:[0-9]+\)\"")
+        addr = int(self.child.after.split("\"")[1].split(" ")[0], 16)
         line = line_number('main.cpp', '// FUNC_main')
 
         # Test that -data-info-line works for address
         self.runCmd("-data-info-line *%#x" % addr)
         self.expect("\^done,start=\"0x0*%x\",end=\"0x[0-9a-f]+\",file=\".+?main.cpp\",line=\"%d\"" % (addr, line))
 
         # Test that -data-info-line works for file:line
         self.runCmd("-data-info-line main.cpp:%d" % line)

test/tools/lldb-mi/symbol/TestMiSymbol.py

def test_lldbmi_symbol_list_lines_file(self):
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Get address of main and its line
         self.runCmd("-data-evaluate-expression main")
-        self.expect("\^done,value=\"0x[0-9a-f]+\"")
-        addr = int(self.child.after.split("\"")[1], 16)
+        self.expect("\^done,value=\"0x[0-9a-f]+ \(a.out`main at main.cpp:[0-9]+\)\"")
+        addr = int(self.child.after.split("\"")[1].split(" ")[0], 16)
         line = line_number('main.cpp', '// FUNC_main')
 
         # Test that -symbol-list-lines works on valid data
         self.runCmd("-symbol-list-lines main.cpp")
         self.expect("\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % (addr, line))
 
         # Test that -symbol-list-lines doesn't include lines from other sources
         # by checking the first and last line, and making sure the other lines

tools/lldb-mi/MICmnLLDBDebugger.h

private:
     bool BroadcasterGetMask(const CMIUtilString &vBroadcasterClass, MIuint &vEventMask) const;
     bool BroadcasterRemoveMask(const CMIUtilString &vBroadcasterClass);
     bool BroadcasterSaveMask(const CMIUtilString &vBroadcasterClass, const MIuint vEventMask);
 
     MIuint ClientGetMaskForAllClients(const CMIUtilString &vBroadcasterClass) const;
     bool ClientSaveMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, const MIuint vEventMask);
     bool ClientRemoveTheirMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass);
     bool ClientGetTheirMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, MIuint &vwEventMask);
-
+    bool RegisterMISummaryProviders();
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ ~CMICmnLLDBDebugger() override;
 
     // Attributes:
   private:
     CMIDriverBase *m_pClientDriver;  // The driver that wants to use *this LLDB debugger

tools/lldb-mi/MICmnLLDBDebugger.cpp

 //===-- MICmnLLDBDebugger.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Third party headers:
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBTypeSummary.h"
+#include "lldb/API/SBTypeCategory.h"
+#include "lldb/API/SBTypeNameSpecifier.h"
+#include "lldb/API/SBStream.h"
 
 // In-house headers:
 #include "MICmnLLDBDebugger.h"
 #include "MICmnResources.h"
 #include "MICmnLog.h"
 #include "MIDriverBase.h"
 #include "MICmnThreadMgrStd.h"
 #include "MICmnLLDBDebuggerHandleEvents.h"
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MIUtilSingletonHelper.h"
 
 //++ ------------------------------------------------------------------------------------
+// MI private summary providers
+static inline bool
+MI_char_summary_provider(lldb::SBValue value, lldb::SBTypeSummaryOptions options, lldb::SBStream &stream)
+{
+    bool is_signed;
+    if (!value.IsValid() || !value.IsIntegerType(is_signed))
+        return false;
+
+    if (is_signed)
+        stream.Printf("%d '%c'", (int)value.GetValueAsSigned(), (char)value.GetValueAsSigned());
+    else
+        stream.Printf("%u '%c'", (unsigned)value.GetValueAsUnsigned(), (char)value.GetValueAsUnsigned());
+    
+    return true;
+}
+
+//++ ------------------------------------------------------------------------------------
+// MI summary helper routines
+static inline bool
+MI_add_summary(lldb::SBTypeCategory category, const char *typeName, lldb::SBTypeSummary::FormatCallback cb,
+               uint32_t options, bool regex = false)
+{
+    lldb::SBTypeSummary summary = lldb::SBTypeSummary::CreateWithCallback(cb, options);
+    return summary.IsValid() ? category.AddTypeSummary(lldb::SBTypeNameSpecifier(typeName, regex), summary) : false;
+} 
+
+//++ ------------------------------------------------------------------------------------
 // Details: CMICmnLLDBDebugger constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnLLDBDebugger::CMICmnLLDBDebugger()
     : m_constStrThisThreadId("MI debugger event")
CMICmnLLDBDebugger::Initialize()
     if (bOk && !InitSBListener())
     {
         bOk = false;
         if (!errMsg.empty())
             errMsg += ", ";
         errMsg += GetErrorDescription().c_str();
     }
     bOk = bOk && InitStdStreams();
-
+    bOk = bOk && RegisterMISummaryProviders();
     m_bInitialized = bOk;
 
     if (!bOk && !HaveErrorDescription())
     {
         CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_LLDBDEBUGGER), errMsg.c_str()));
         SetErrorDescription(strInitError);
     }
 

 // Return:  CMIUtilString & - Text.
 // Throws:  None.
 //--
 const CMIUtilString &
 CMICmnLLDBDebugger::ThreadGetName() const
 {
     return m_constStrThisThreadId;
 }
+
+//++ ------------------------------------------------------------------------------------
+// Details: Registers lldb-mi custom summary providers
+// Type:    Method.
+// Args:    None.
+// Return:  MIstatus::success - Functionality succeeded.
+//          MIstatus::failure - Functionality failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebugger::RegisterMISummaryProviders()
+{
+    static const char* miCategoryName = "lldb-mi";
+    lldb::SBTypeCategory miCategory = m_lldbDebugger.CreateCategory(miCategoryName);
+    if (!miCategory.IsValid())
+        return false;
+
+    if (MI_add_summary(miCategory, "char", MI_char_summary_provider,
+                        lldb::eTypeOptionHideValue | lldb::eTypeOptionSkipPointers))
+    {    
+        if (MI_add_summary(miCategory, "unsigned char", MI_char_summary_provider,
+                        lldb::eTypeOptionHideValue | lldb::eTypeOptionSkipPointers))
+        {
+            if (MI_add_summary(miCategory, "signed char", MI_char_summary_provider,
+                        lldb::eTypeOptionHideValue | lldb::eTypeOptionSkipPointers))
+            {    
+                miCategory.SetEnabled(true);            
+                return true;
+            }
+        }
+    }
+
+    m_lldbDebugger.DeleteCategory(miCategoryName);
+    return false;
+}

tools/lldb-mi/MICmnLLDBUtilSBValue.h

public:
     bool IsValueUnknown() const;
     bool IsValid() const;
     bool HasName() const;
 
     // 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;
-    CMIUtilString GetValueSummary() const;
+    CMIUtilString GetValueSummary(bool valueOnly, const CMIUtilString& failVal = CMIUtilString()) 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

 // Throws:  None.
 //--
 bool
 CMICmnLLDBUtilSBValue::GetSimpleValue(const bool vbHandleArrayType, CMIUtilString &vwrValue) const
 {
     const MIuint nChildren = m_rValue.GetNumChildren();
     if (nChildren == 0)
     {
-        if (m_bHandleCharType && IsCharType())
-        {
-            vwrValue = GetSimpleValueChar();
-            return MIstatus::success;
-        }
-        else
-        {
-            const char *pValue = m_rValue.GetValue();
-            vwrValue = pValue != nullptr ? pValue : m_pUnkwn;
-            return MIstatus::success;
-        }
-    }
+        vwrValue = GetValueSummary(!m_bHandleCharType && IsCharType(), m_pUnkwn);
     else if (IsPointerType())
     {
-        if (m_bHandleCharType && IsPointeeCharType())
-        {
-            vwrValue = GetSimpleValueCStringPointer();
-            return MIstatus::success;
-        }
-        else
-        {
-            const char *pValue = m_rValue.GetValue();
-            vwrValue = pValue != nullptr ? pValue : m_pUnkwn;
-            return MIstatus::success;
-        }
-    }
+        vwrValue = GetValueSummary(!m_bHandleCharType && IsPointeeCharType(), m_pUnkwn);
     else if (IsArrayType())
     {
         CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
         bool bPrintCharArrayAsString = false;
         bPrintCharArrayAsString = rSessionInfo.SharedDataRetrieve<bool>(rSessionInfo.m_constStrPrintCharArrayAsString,
                                                                         bPrintCharArrayAsString) && bPrintCharArrayAsString;
         if (bPrintCharArrayAsString && m_bHandleCharType && IsFirstChildCharType())
         {
-            vwrValue = GetSimpleValueCStringArray();
+            vwrValue = GetValueSummary(false);
             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
-        vwrValue = GetValueSummary();
+        vwrValue = GetValueSummary(false);
         if (!vwrValue.empty())
             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
-{
-    const CMIUtilString& summary = GetValueSummary();
-    if (!summary.empty())
-        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;
-    }
-
-    const lldb::BasicType eType = m_rValue.GetType().GetBasicType();
-    switch (eType)
-    {
-        default:
-            assert(0 && "value must be a char type");
-        case lldb::eBasicTypeChar:
-        case lldb::eBasicTypeSignedChar:
-        case lldb::eBasicTypeUnsignedChar:
-        {
-            const CMIUtilString prefix(CMIUtilString::ConvertToPrintableASCII((char)value));
-            return CMIUtilString::Format("%" PRIu8 " '%s'", (uint8_t)value, prefix.c_str());
-        }
-        case lldb::eBasicTypeChar16:
-        {
-            const CMIUtilString prefix(CMIUtilString::ConvertToPrintableASCII((char16_t)value));
-            return CMIUtilString::Format("U+%04" PRIx16 " u'%s'", (uint16_t)value, prefix.c_str());
-        }
-        case lldb::eBasicTypeChar32:
-        {
-            const CMIUtilString prefix(CMIUtilString::ConvertToPrintableASCII((char32_t)value));
-            return CMIUtilString::Format("U+%08" PRIx32 " U'%s'", (uint32_t)value, prefix.c_str());
-        }
-    }
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: Retrieve from the LLDB SB Value object of type char* the c-string value.
-// Type:    Method.
-// Args:    None.
-// Return:  CMIUtilString   - The c-string value of the variable.
-// Throws:  None.
-//--
-CMIUtilString
-CMICmnLLDBUtilSBValue::GetSimpleValueCStringPointer() const
-{
-    const CMIUtilString& summary = GetValueSummary();
-    if (!summary.empty())
-        return summary;
-
-    const char *value = m_rValue.GetValue();
-    if (value == nullptr)
-        return m_pUnkwn;
-
-    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:
-        case lldb::eBasicTypeUnsignedChar:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(child));
-            // Note code that has const in will not show the text suffix to the string pointer
-            // i.e. const char * pMyStr = "blah"; ==> "0x00007000"" <-- Eclipse shows this
-            // but        char * pMyStr = "blah"; ==> "0x00007000" "blah"" <-- Eclipse shows this
-            return CMIUtilString::Format("%s \"%s\"", value, prefix.c_str());
-        }
-        case lldb::eBasicTypeChar16:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(child));
-            return CMIUtilString::Format("%s u\"%s\"", value, prefix.c_str());
-        }
-        case lldb::eBasicTypeChar32:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(child));
-            return CMIUtilString::Format("%s U\"%s\"", value, prefix.c_str());
-        }
-    }
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: Retrieve from the LLDB SB Value object of type char[] the c-string value.
-// Type:    Method.
-// Args:    None.
-// Return:  CMIUtilString   - The c-string value of the variable.
-// Throws:  None.
-//--
-CMIUtilString
-CMICmnLLDBUtilSBValue::GetSimpleValueCStringArray() const
-{
-    const CMIUtilString& summary = GetValueSummary();
-    if (!summary.empty())
-        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:
-        case lldb::eBasicTypeSignedChar:
-        case lldb::eBasicTypeUnsignedChar:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(m_rValue, nChildren));
-            // TODO: to match char* it should be the following
-            //       return CMIUtilString::Format("[%u] \"%s\"", nChildren, prefix.c_str());
-            return CMIUtilString::Format("\"%s\"", prefix.c_str());
-        }
-        case lldb::eBasicTypeChar16:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(m_rValue, nChildren));
-            return CMIUtilString::Format("u\"%s\"", prefix.c_str());
-        }
-        case lldb::eBasicTypeChar32:
-        {
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(m_rValue, nChildren));
-            return CMIUtilString::Format("U\"%s\"", prefix.c_str());
-        }
-    }
-}
-
 bool
 CMICmnLLDBUtilSBValue::GetCompositeValue(const bool vbPrintFieldNames, CMICmnMIValueTuple &vwrMiValueTuple,
                                          const MIuint vnDepth /* = 1 */) const
 {
     const MIuint nMaxDepth = 10;
     const MIuint nChildren = m_rValue.GetNumChildren();
     for (MIuint i = 0; i < nChildren; ++i)
     {
for (MIuint i = 0; i < nChildren; ++i)
             const bool bUseSpacing = false;
             vwrMiValueTuple.Add(miValueConst, bUseSpacing);
         }
     }
 
     return MIstatus::success;
 }
 
+// Returns value or value + summary, depending on valueOnly parameter value.
+// If result is an empty string returns failVal.
 CMIUtilString
-CMICmnLLDBUtilSBValue::GetValueSummary() const
-{
-    CMIUtilString valSummary;
-    if (m_rValue.IsValid())
-    {
-#ifndef LLDB_DISABLE_PYTHON
-        const char *c_str = m_rValue.GetSummary();
-        if (c_str && c_str[0])
-        {
-            valSummary = c_str;
-            lldb::SBTypeSummary summary = m_rValue.GetTypeSummary();
-            if (summary.IsValid() && summary.DoesPrintValue(m_rValue))
-            {
-                c_str = m_rValue.GetValue();
-                if (c_str && c_str[0])
-                {
-                    valSummary.insert(0, std::string(c_str) + " ");
-                }
-            }
-        }
-#endif
+CMICmnLLDBUtilSBValue::GetValueSummary(bool valueOnly, const CMIUtilString& failVal) const
+{    
+    if (!m_rValue.IsValid())
+        return failVal;
+ 
+    CMIUtilString value, valSummary;
+    const char* c_value = m_rValue.GetValue();
+    if (valueOnly)
+        return c_value == nullptr ? failVal : c_value;
+    
+    const char* c_summary = m_rValue.GetSummary();   
+    if (c_value)
+        value = c_value;
+    else if (c_summary == nullptr)
+        return failVal;
+    
+    if (c_summary && c_summary[0])
+        valSummary = c_summary;
+        if (summary.IsValid() && summary.DoesPrintValue(m_rValue) && !value.empty())
+            valSummary.insert(0, value + " ");
         }
         return valSummary;
     }
+    // no summary - return just value
+    return value;
+}
 
 //++ ------------------------------------------------------------------------------------
 // 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.
 //--