Fix the variable printing for stack-list-local and stack-list-arguments.

[abidh]

Summary

Fix for http://llvm.org/bugs/show_bug.cgi?id=21744

GetVariableInfo () collected the values of the variable in a list. But it also
tried to generate the name/value pairs for children. This caused generation of
a wrong value string for may items. This function has been fixed to put value in
the list only.

The handling of --print-value related option has been moved to caller.

GetVariableInfo2 and MIResponseFormVariableInfo3 have been removed. They were
almost the duplicate of functions of similar names. I dont see any difference in
the output of -stack-list-locals and -stack-list-arguments. So these functions
just seemed unnecessary.

Char variable was being printed as a string which caused garbage output. This has
been fixed.

Some misc. cleanup.

Test cases have been added that check -stack-list-locals for struct, array and
pointers. Modified other tests which depended on hard coded line numbers.

TODO: Those hardcoded line numbers should be removed.

[ki.stfu]

Looks good. I dislike these func/func2/func3/func4 (and so on) functions. One question for you: --simple-values works now?

FYI: I didn't check it on OS X yet. I'll do it later.

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

729

Is it enough? Should we unescape this string?

733–734

valueStr = CMIUtilString::Format("{%s}", valueStr.c_str());

738

Maybe would better to name it like miValueResultName? I know that lldb-mi uses sequential naming standard for miValueConst/miValueResult values, but in your case it was created on 20 lines above.

762

vrwnDepth must be a reference? I think it can cause a problem on large objects. For example, on line #844 you increment it in cycle (which serves to obtain a value of complex object). But on every iteration we will call GetVariableInfo with vrwnDepth which grows, but actually these children have one depth on call stack.

[ki.stfu]

RE: TODO: Those hardcoded line numbers should be removed.

I think we should leave them to check *stopped notification. We can move it to separate test file to avoid modification of it when we are improving the tests.

[abidh]

Please see my comments inline. Also it will be good if you can check that test pass on OSX.

In D7589#122628, @ki.stfu wrote:

RE: TODO: Those hardcoded line numbers should be removed.

I think we should leave them to check *stopped notification. We can move it to separate test file to avoid modification of it when we are improving the tests.

Yes that will not be part of this revision. Just wanted to draw the attention. I was thinking that we can use the line_number () like function to get the line to check instead of hard coding them. But it can be done later.

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

729

I will check.

733–734

I will change it. I dont like the unnecessary string copying that goes on in lldb-mi. Something to fix in future.

738

ok. I will change it. You may have already guesssed but it is done to have output like
[name="var"] when there is no value field.

If it is added in the tuple first then we will get
[{name="var"}]
which I dont think is wrong but I wanted to be as close to what gdb does.

762

You are right. I think this should be decremented after function return to have the right depth counter. Current implementation will fail if the child struct have more then 10 members.

[abidh]

Handled the comments from review.

1. Use correct constructor of the CMICmnMIValueConst. Removed Trim Call.
2. Used Format function to format a string.
3. Renamed miValueResul to miValueResultName.
4. Decremented the vrwnDepth after function return.

[ki.stfu]

I have one more issue (sorry, forgot to say immediately about it):

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

760–762

bool
CMICmnLLDBDebugSessionInfo::GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
                         const MIuint vnDepth, CMICmnMIValueList &vwrMiValueList)

840–842

bOk = GetVariableInfo(vnMaxDepth, member, true, vnDepth + 1, miValueList2);

tools/lldb-mi/MICmnLLDBDebugSessionInfo.h

203

I'd prefer "const MIuint vnDepth". And it will be great if you make the vnDepth 4th argument (and move vwrMiValueList to the end).

bool GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
                         const MIuint vnDepth, CMICmnMIValueList &vwrMiValueList);

[ki.stfu]

MiExecTestCase.test_lldbmi_exec_step_instruction failed:

======================================================================
ERROR: test_lldbmi_exec_step_instruction (TestMiExec.MiExecTestCase)
    Test that 'lldb-mi --interpreter' works for instruction stepping into.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/IliaK/p/llvm/tools/lldb/test/lldbtest.py", line 422, in wrapper
    return func(self, *args, **kwargs)
  File "/Users/IliaK/p/llvm/tools/lldb/test/lldbtest.py", line 537, in wrapper
    func(*args, **kwargs)
  File "/Users/IliaK/p/llvm/tools/lldb/test/tools/lldb-mi/TestMiExec.py", line 333, in test_lldbmi_exec_step_instruction
    self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
  File "/Users/IliaK/p/llvm/tools/lldb/test/tools/lldb-mi/lldbmi_testcase.py", line 43, in expect
    return self.child.expect(pattern, *args, **kwargs)
  File "/Users/IliaK/p/llvm/tools/lldb/test/pexpect-2.4/pexpect.py", line 1316, in expect
    return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
  File "/Users/IliaK/p/llvm/tools/lldb/test/pexpect-2.4/pexpect.py", line 1330, in expect_list
    return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
  File "/Users/IliaK/p/llvm/tools/lldb/test/pexpect-2.4/pexpect.py", line 1414, in expect_loop
    raise TIMEOUT (str(e) + '\n' + str(self))
TIMEOUT: Timeout exceeded in read_nonblocking().
<pexpect.spawn object at 0x10f3868d0>
version: 2.4 ($Revision: 516 $)
command: /Users/IliaK/p/llvm/build_ninja/bin/lldb-mi
args: ['/Users/IliaK/p/llvm/build_ninja/bin/lldb-mi', '--interpreter']
searcher: searcher_re:
    0: re.compile("\*stopped,reason="end-stepping-range".*main.c",line="22"")
buffer (last 100 chars): p/llvm/tools/lldb/test/tools/lldb-mi/main.c",line="24"},thread-id="1",stopped-threads="all"
(gdb)

test/tools/lldb-mi/TestMiExec.py

333

on OS X it should be:

self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")

339

on OS X it should be:

self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")

[abidh]

Fixed some cosmetics changes reported in reviews.
Adjusted line numbers to take care of failures on OSX.

[ki.stfu]

lgth. All tests passed on OS x.

test/tools/lldb-mi/Makefile

 LEVEL = ../../make
 
-C_SOURCES := main.c a.c b.c loop.c
+C_SOURCES := main.c a.c b.c loop.c locals.c
 
 include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/TestMiExec.py

def test_lldbmi_exec_next(self):
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Warning: the following is sensative to the lines in the source.
 
         # Test -exec-next
         self.runCmd("-exec-next --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
 
         # Test that --thread is optional
         self.runCmd("-exec-next --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"23\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"25\"")
 
         # Test that --frame is optional
         self.runCmd("-exec-next --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"25\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"27\"")
 
         # Test that both --thread and --frame are optional
         self.runCmd("-exec-next --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"27\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"29\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-next --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-next --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
def test_lldbmi_exec_next_instruction(self):
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Warning: the following is sensative to the lines in the
         # source and optimizations
 
         # Test -exec-next-instruction
         self.runCmd("-exec-next-instruction --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"20\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
 
         # Test that --thread is optional
         self.runCmd("-exec-next-instruction --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"20\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
 
         # Test that --frame is optional
         self.runCmd("-exec-next-instruction --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"20\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
 
         # Test that both --thread and --frame are optional
         self.runCmd("-exec-next-instruction --thread 1")
         self.expect("\^running")
         # Depending on compiler, it can stop at different line.
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"2[0-2]\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"2[2-4]\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-next-instruction --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-next-instruction --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
def test_lldbmi_exec_step(self):
 
         # Warning: the following is sensative to the lines in the source
 
         # Test that -exec-step does not step into printf (which
         # has no debug info)
         #FIXME: is this supposed to step into printf?
         self.runCmd("-exec-step --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
 
         # Test that -exec-step steps into a_MyFunction and back out
         # (and that --thread is optional)
         self.runCmd("-exec-step --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"a_MyFunction\"")
         #FIXME: is this supposed to step into printf?
         self.runCmd("-exec-step --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"a_MyFunction\"")
         # Use -exec-finish here to make sure that control reaches the caller.
         # -exec-step can keep us in the a_MyFunction for gcc
         self.runCmd("-exec-finish --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
         self.runCmd("-exec-step --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"23\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"25\"")
 
         # Test that -exec-step steps into b_MyFunction
         # (and that --frame is optional)
         self.runCmd("-exec-step --thread 1")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"b_MyFunction\"")
 
         # Test that -exec-step steps into a_MyFunction from inside
def test_lldbmi_exec_step_instruction(self):
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that -exec-step-instruction steps over non branching
         # instruction
         self.runCmd("-exec-step-instruction --thread 1 --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
 
         # Test that -exec-step-instruction steps over non branching
         # instruction (and that --thread is optional)
         self.runCmd("-exec-step-instruction --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"22\"")
 
         # Test that -exec-step-instruction steps into a_MyFunction
         # (and that --frame is optional)
         self.runCmd("-exec-step-instruction --thread 1")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"a_MyFunction\"")
 
         # Test that -exec-step-instruction steps into a_MyFunction

test/tools/lldb-mi/TestMiStack.py

def test_lldbmi_locals(self):
         self.runCmd("-stack-list-locals --all-values")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
 
         # Test -stack-list-locals: use 2 or --simple-values
         self.runCmd("-stack-list-locals 2")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
         self.runCmd("-stack-list-locals --simple-values")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
         
+        # Test struct local variable
+        line = line_number('locals.c', '// BP_LOCAL_STRUCT')
+        self.runCmd("-break-insert --file locals.c:%d" % line)
+        self.expect("\^done,bkpt={number=\"2\"")
+
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+        
+        # Test -stack-list-locals: use 0 or --no-values
+        self.runCmd("-stack-list-locals 0")
+        self.expect("\^done,locals=\[name=\"var_c\"\]")
+        self.runCmd("-stack-list-locals --no-values")
+        self.expect("\^done,locals=\[name=\"var_c\"\]")
+
+        # Test -stack-list-locals: use 1 or --all-values
+        self.runCmd("-stack-list-locals 1")
+        self.expect("\^done,locals=\[{name=\"var_c\",value=\"{var_a = 10,var_b = 97 'a',inner_ = { var_d = 30 }}\"}\]")
+        self.runCmd("-stack-list-locals --all-values")
+        self.expect("\^done,locals=\[{name=\"var_c\",value=\"{var_a = 10,var_b = 97 'a',inner_ = { var_d = 30 }}\"}\]")
+
+        # Test -stack-list-locals: use 2 or --simple-values
+        self.runCmd("-stack-list-locals 2")
+        self.expect("\^done,locals=\[name=\"var_c\"\]")
+        self.runCmd("-stack-list-locals --simple-values")
+        self.expect("\^done,locals=\[name=\"var_c\"\]")
+        
+        # Test array local variable
+        line = line_number('locals.c', '// BP_LOCAL_ARRAY')
+        self.runCmd("-break-insert --file locals.c:%d" % line)
+        self.expect("\^done,bkpt={number=\"3\"")
+
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+        
+        # Test -stack-list-locals: use 0 or --no-values
+        self.runCmd("-stack-list-locals 0")
+        self.expect("\^done,locals=\[name=\"array\"\]")
+        self.runCmd("-stack-list-locals --no-values")
+        self.expect("\^done,locals=\[name=\"array\"\]")
+
+        # Test -stack-list-locals: use 1 or --all-values
+        self.runCmd("-stack-list-locals 1")
+        self.expect("\^done,locals=\[{name=\"array\",value=\"{\[0\] = 100,\[1\] = 200,\[2\] = 300}\"}\]")
+        self.runCmd("-stack-list-locals --all-values")
+        self.expect("\^done,locals=\[{name=\"array\",value=\"{\[0\] = 100,\[1\] = 200,\[2\] = 300}\"}\]")
+
+        # Test -stack-list-locals: use 2 or --simple-values
+        self.runCmd("-stack-list-locals 2")
+        self.expect("\^done,locals=\[name=\"array\"\]")
+        self.runCmd("-stack-list-locals --simple-values")
+        self.expect("\^done,locals=\[name=\"array\"\]")
+        
+        # Test pointers as local variable
+        line = line_number('locals.c', '// BP_LOCAL_PTR')
+        self.runCmd("-break-insert --file locals.c:%d" % line)
+        self.expect("\^done,bkpt={number=\"4\"")
+
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+        
+        # Test -stack-list-locals: use 0 or --no-values
+        self.runCmd("-stack-list-locals 0")
+        self.expect("\^done,locals=\[name=\"test_str\",name=\"var_e\",name=\"ptr\"\]")
+        self.runCmd("-stack-list-locals --no-values")
+        self.expect("\^done,locals=\[name=\"test_str\",name=\"var_e\",name=\"ptr\"\]")
+
+        # Test -stack-list-locals: use 1 or --all-values
+        self.runCmd("-stack-list-locals 1")
+        self.expect("\^done,locals=\[{name=\"test_str\",value=\".*Rakaposhi.*\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*\"}\]")
+        self.runCmd("-stack-list-locals --all-values")
+        self.expect("\^done,locals=\[{name=\"test_str\",value=\".*Rakaposhi.*\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*\"}\]")
+
+        # Test -stack-list-locals: use 2 or --simple-values
+        self.runCmd("-stack-list-locals 2")
+        self.expect("\^done,locals=\[{name=\"test_str\",value=\".*Rakaposhi.*\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*\"}\]")
+        self.runCmd("-stack-list-locals --simple-values")
+        self.expect("\^done,locals=\[{name=\"test_str\",value=\".*Rakaposhi.*\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*\"}\]")
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_lldbmi_stackdepth(self):
         """Test that 'lldb-mi --interpreter' can shows depth of the stack."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

test/tools/lldb-mi/locals.c

+struct inner
+{
+    int var_d;
+};
+
+struct my_type
+{
+    int var_a;
+    char var_b;
+    struct inner inner_;
+};
+
+int local_struct_test(void)
+{
+    struct my_type var_c;
+    var_c.var_a = 10;
+    var_c.var_b = 'a';
+    var_c.inner_.var_d = 30;
+    return 0; // BP_LOCAL_STRUCT
+}
+
+int local_array_test(void)
+{
+    int array[3];
+    array[0] = 100;
+    array[1] = 200;
+    array[2] = 300;
+    return 0; // BP_LOCAL_ARRAY
+}
+
+int local_pointer_test(void)
+{
+    const char* test_str = "Rakaposhi";
+    int var_e = 24;
+    int *ptr = &var_e;
+    return 0; // BP_LOCAL_PTR
+}
+
+int local_test()
+{
+    local_struct_test();
+    local_array_test();
+    local_pointer_test();
+    return 0;
+}
 No newline at end of file

test/tools/lldb-mi/main.c

 //===-- 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 <stdio.h>
 extern int a_MyFunction();
 extern int b_MyFunction();
 extern int infloop();
+extern int local_test();
 int doloop, dosegfault;
 int g_MyVar = 3;
 static int s_MyVar = 4;
+
 int main (int argc, char const *argv[])
 {
     int a, b;
     printf("argc=%d\n", argc);   //BP_printf_call
     //BP_argctest
     a = a_MyFunction();          //BP_a_MyFunction_call
     b = b_MyFunction();          //BP_b_MyFunction_call
     //BP_localstest -- it must be at line #24 (or fix it in main*.micmds)
     if (doloop) // BP_doloop
         infloop();
     if (dosegfault)
         *(volatile int *)NULL = 1;
     if (argc > 1 && *argv[1] == 'l') {
         a++;
         printf("a=%d, argv[1]=%s\n", a, argv[1]); //BP_argtest
     }
     s_MyVar = a + b;
+    local_test();
     return a + b - s_MyVar; //BP_source
 }

tools/lldb-mi/MICmdCmdStack.cpp

CMICmdCmdStackListArguments::Execute(void)
     }
 
     const MIuint nFrames = thread.GetNumFrames();
     for (MIuint i = 0; i < nFrames; i++)
     {
         lldb::SBFrame frame = thread.GetFrameAtIndex(i);
         CMICmnMIValueList miValueList(true);
         const MIuint maskVarTypes = CMICmnLLDBDebugSessionInfo::eVariableType_Arguments;
-        if (!rSessionInfo.MIResponseFormVariableInfo3(frame, maskVarTypes, eVarInfoFormat, miValueList))
+        if (!rSessionInfo.MIResponseFormVariableInfo(frame, maskVarTypes, eVarInfoFormat, miValueList))
             return MIstatus::failure;
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", i));
         const CMICmnMIValueResult miValueResult("level", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueResult miValueResult2("args", miValueList);
         miValueTuple.Add(miValueResult2);
         const CMICmnMIValueResult miValueResult3("frame", miValueTuple);
         m_miValueList.Add(miValueResult3);

tools/lldb-mi/MICmnLLDBDebugSessionInfo.h

bool MIResponseFormFrameInfo2(const lldb::addr_t vPc, const CMIUtilString &vArgInfo, const CMIUtilString &vFnName,
                                   CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormThreadInfo2(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormThreadInfo3(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                     const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
     bool MIResponseFormVariableInfo2(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                      const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
-    bool MIResponseFormVariableInfo3(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
-                                     const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
     bool MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormBrkPtInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfo(const MIuint vnBrkPtId, const SBrkPtInfo &vrBrkPtInfo);
     bool RecordBrkPtInfoGet(const MIuint vnBrkPtId, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfoDelete(const MIuint vnBrkPtId);
     CMIUtilThreadMutex& GetSessionMutex() { return m_sessionMutex;}
     lldb::SBDebugger &GetDebugger() const;
private:
 
     // Methods:
   private:
     /* ctor */ CMICmnLLDBDebugSessionInfo(void);
     /* ctor */ CMICmnLLDBDebugSessionInfo(const CMICmnLLDBDebugSessionInfo &);
     void operator=(const CMICmnLLDBDebugSessionInfo &);
     //
     bool GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                         const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
-    bool GetVariableInfo2(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                          const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
+                         CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnLLDBDebugSessionInfo(void);
 
     // Attributes:
   private:

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
     const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
     const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
     const MIuint nMaxRecusiveDepth = 10;
     MIuint nCurrentRecursiveDepth = 0;
     lldb::SBValueList listArg = rFrame.GetVariables(bArg, bLocals, bStatics, bInScopeOnly);
     const MIuint nArgs = listArg.GetSize();
     for (MIuint i = 0; bOk && (i < nArgs); i++)
     {
+        CMICmnMIValueTuple miValueTuple;
         lldb::SBValue value = listArg.GetValueAtIndex(i);
-        bOk = GetVariableInfo(nMaxRecusiveDepth, value, false, veVarInfoFormat, vwrMiValueList, nCurrentRecursiveDepth);
-    }
-
-    return bOk;
-}
-
-// *** Do not refactor this function to be one function with same name as it can break more than
-// *** than one stack type command
-//++ ------------------------------------------------------------------------------------
-// Details: Form MI partial response by appending more MI value type objects to the
-//          tuple type object past in.
-// Type:    Method.
-// Args:    vrFrame         - (R)   LLDB thread object.
-//          vMaskVarTypes   - (R)   Construed according to VariableType_e.
-//          veVarInfoFormat - (R)   The type of variable info that should be shown.
-//          vwrMIValueList  - (W)   MI value list object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo3(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
-                                                        const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList)
+        const CMICmnMIValueConst miValueConst(value.GetName());
+        const CMICmnMIValueResult miValueResultName("name", miValueConst);
+        if (veVarInfoFormat != eVariableInfoFormat_NoValues)
+        {
+            const MIuint nChildren = value.GetNumChildren();
+            const bool bIsPointerType = value.GetType().IsPointerType();
+            if (nChildren == 0 || // no children
+                    (bIsPointerType && nChildren == 1) || // pointers
+                     veVarInfoFormat == eVariableInfoFormat_AllValues) // show all values
             {
-    bool bOk = MIstatus::success;
-    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);
-
-    const bool bArg = (vMaskVarTypes & eVariableType_Arguments);
-    const bool bLocals = (vMaskVarTypes & eVariableType_Locals);
-    const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
-    const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
-    const MIuint nMaxRecusiveDepth = 10;
-    MIuint nCurrentRecursiveDepth = 0;
-    lldb::SBValueList listArg = rFrame.GetVariables(bArg, bLocals, bStatics, bInScopeOnly);
-    const MIuint nArgs = listArg.GetSize();
-    for (MIuint i = 0; bOk && (i < nArgs); i++)
+                CMICmnMIValueList miValueList(true);
+                if (GetVariableInfo(nMaxRecusiveDepth, value, false, miValueList, nCurrentRecursiveDepth))
                 {
-        lldb::SBValue value = listArg.GetValueAtIndex(i);
-        bOk = GetVariableInfo2(nMaxRecusiveDepth, value, false, veVarInfoFormat, vwrMiValueList, nCurrentRecursiveDepth);
+                    CMIUtilString valueStr = miValueList.ExtractContentNoBrackets();
+                    // Surround by {} if there is , inside indicating multiple values.
+                    if (valueStr.find (',') != CMIUtilString::npos)
+                        valueStr = CMIUtilString::Format("{%s}", valueStr.c_str());
+                    const CMICmnMIValueConst miValueConst2(valueStr);
+                    const CMICmnMIValueResult miValueResult2("value", miValueConst2);
+                    miValueTuple.Add(miValueResultName); // name
+                    miValueTuple.Add(miValueResult2);
+                    vwrMiValueList.Add(miValueTuple);
+                    continue;
+                }
+            }
+        }
+        // If we are printing name only then no need to put it in the tuple.
+        vwrMiValueList.Add(miValueResultName);
     }
-
     return bOk;
 }
 
-// *** Do not refactor this function to be one function with same name as it can break more than
-// *** than one stack type command
 //++ ------------------------------------------------------------------------------------
 // Details: Extract the value's name and value or recurse into child value object.
 // Type:    Method.
 // Args:    vnMaxDepth      - (R)  The max recursive depth for this function.
 //          vrValue         - (R)  LLDB value object.
 //          vbIsChildValue  - (R)  True = Value object is a child of a higher Value object,
 //                          -      False =  Value object not a child.
-//          veVarInfoFormat - (R)  The type of variable info that should be shown.
 //          vwrMIValueList  - (W)  MI value list object.
 //          vnDepth         - (RW) The current recursive depth of this function.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebugSessionInfo::GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                                            const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
-                                            MIuint &vrwnDepth)
+                                            CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth)
 {
-    // *** Update GetVariableInfo2() with any code changes here ***
-
     // Check recursive depth
     if (vrwnDepth >= vnMaxDepth)
         return MIstatus::success;
 
     bool bOk = MIstatus::success;
     lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
     const CMICmnLLDBUtilSBValue utilValue(vrValue, true);
-    CMICmnMIValueTuple miValueTuple;
     const MIchar *pName = rValue.GetName();
     MIunused(pName);
     const bool bIsPointerType = rValue.GetType().IsPointerType();
     const MIuint nChildren = rValue.GetNumChildren();
     if (nChildren == 0)
     {
         if (vbIsChildValue)
         {
-            if (utilValue.IsCharType())
-            {
-                // For char types and try to form text string
-                const CMICmnMIValueConst miValueConst(utilValue.GetValue().c_str(), true);
-                miValueTuple.Add(miValueConst, true);
-            }
-            else
-            {
-                // For composite types
-                const CMICmnMIValueConst miValueConst(
                     CMIUtilString::Format("%s = %s", utilValue.GetName().c_str(), utilValue.GetValue().c_str()), true);
-                miValueTuple.Add(miValueConst, true);
-            }
-            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
+            return vwrMiValueList.Add(miValueConst);
         }
         else
         {
             // Basic types
-            switch (veVarInfoFormat)
-            {
-                case eVariableInfoFormat_NoValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    return vwrMiValueList.Add(miValueResult);
-                }
-                case eVariableInfoFormat_AllValues:
-                case eVariableInfoFormat_SimpleValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    miValueTuple.Add(miValueResult);
-                    const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
-                    const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-                    miValueTuple.Add(miValueResult2);
-                    break;
-                }
-                default:
-                    break;
-            }
-            return vwrMiValueList.Add(miValueTuple);
+            const CMICmnMIValueConst miValueConst(utilValue.GetValue(), true);
+            return vwrMiValueList.Add(miValueConst);
         }
     }
     else if (bIsPointerType && utilValue.IsChildCharType())
     {
-        switch (veVarInfoFormat)
-        {
-            case eVariableInfoFormat_NoValues:
-            {
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                return vwrMiValueList.Add(miValueResult);
-            }
-            case eVariableInfoFormat_AllValues:
-            case eVariableInfoFormat_SimpleValues:
-            {
-                // Append string text to the parent value information
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                miValueTuple.Add(miValueResult);
-
-                const CMIUtilString &rText(utilValue.GetChildValueCString());
-                if (rText.empty())
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetValue());
-                    const CMICmnMIValueResult miValueResult("value", miValueConst);
-                    miValueTuple.Add(miValueResult);
-                }
-                else
-                {
-                    if (utilValue.IsValueUnknown())
-                    {
-                        const CMICmnMIValueConst miValueConst(rText);
-                        const CMICmnMIValueResult miValueResult("value", miValueConst);
-                        miValueTuple.Add(miValueResult);
-                    }
-                    else
-                    {
-                        // 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
-                        const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%s %s", utilValue.GetValue().c_str(), rText.c_str()));
-                        const CMICmnMIValueResult miValueResult("value", miValueConst);
-                        miValueTuple.Add(miValueResult);
-                    }
-                }
-                break;
+            const CMICmnMIValueConst miValueConst(utilValue.GetValue(), true);
+            bOk = vwrMiValueList.Add(miValueConst);
+                const CMICmnMIValueConst miValueConst(rText, true);
+                bOk = vwrMiValueList.Add(miValueConst);
+                const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%s %s", utilValue.GetValue().c_str(), rText.c_str()), true);
+                bOk = vwrMiValueList.Add(miValueConst);
             }
-            default:
-                break;
         }
-        return vwrMiValueList.Add(miValueTuple);
+        return bOk;
     }
     else if (bIsPointerType)
     {
         if (vbIsChildValue)
         {
             // For composite types
             const CMICmnMIValueConst miValueConst(
                     CMIUtilString::Format("%s = %s", utilValue.GetName().c_str(), utilValue.GetValue().c_str()), true);
-            miValueTuple.Add(miValueConst, true);
-            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
+            return vwrMiValueList.Add(miValueConst);
         }
         else
         {
             // Basic types
-            switch (veVarInfoFormat)
-            {
-                case eVariableInfoFormat_NoValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    return vwrMiValueList.Add(miValueResult);
-                }
-                case eVariableInfoFormat_AllValues:
-                case eVariableInfoFormat_SimpleValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    miValueTuple.Add(miValueResult);
-                    const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
-                    const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-                    miValueTuple.Add(miValueResult2);
-                    break;
-                }
-                default:
-                    break;
-            }
-            return vwrMiValueList.Add(miValueTuple);
+            const CMICmnMIValueConst miValueConst(utilValue.GetValue(), true);
+            return vwrMiValueList.Add(miValueConst);
         }
     }
     else
     {
-        switch (veVarInfoFormat)
-        {
-            case eVariableInfoFormat_NoValues:
-            {
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                return vwrMiValueList.Add(miValueResult);
-            }
-            case eVariableInfoFormat_AllValues:
-            case eVariableInfoFormat_SimpleValues:
-            {
-                // Build parent child composite types
-                CMICmnMIValueList miValueList(true);
-                for (MIuint i = 0; bOk && (i < nChildren); i++)
-                {
-                    lldb::SBValue member = rValue.GetChildAtIndex(i);
-                    bOk = GetVariableInfo(vnMaxDepth, member, true, veVarInfoFormat, miValueList, ++vrwnDepth);
-                }
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                miValueTuple.Add(miValueResult);
-                const CMICmnMIValueConst miValueConst2(CMIUtilString::Format("{%s}", miValueList.ExtractContentNoBrackets().c_str()));
-                const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-                miValueTuple.Add(miValueResult2);
-                break;
-            }
-            default:
-                break;
-        }
-        return vwrMiValueList.Add(miValueTuple);
-    }
-}
-
-// *** Do not refactor this function to be one function with same name as it can break more than
-// *** than one stack type command
-//++ ------------------------------------------------------------------------------------
-// Details: Extract the value's name and value or recurse into child value object.
-// Type:    Method.
-// Args:    vnMaxDepth      - (R)  The max recursive depth for this function.
-//          vrValue         - (R)  LLDB value object.
-//          vbIsChildValue  - (R)  True = Value object is a child of a higher Value object,
-//                          -      False =  Value object not a child.
-//          veVarInfoFormat - (R)  The type of variable info that should be shown.
-//          vwrMIValueList  - (W)  MI value list object.
-//          vnDepth         - (RW) The current recursive depth of this function.
-//          // Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMICmnLLDBDebugSessionInfo::GetVariableInfo2(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                                             const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
-                                             MIuint &vrwnDepth)
-{
-    // *** Update GetVariableInfo() with any code changes here ***
-
-    // Check recursive depth
-    if (vrwnDepth >= vnMaxDepth)
-        return MIstatus::success;
-
-    bool bOk = MIstatus::success;
-    lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
-    const CMICmnLLDBUtilSBValue utilValue(vrValue, true);
-    CMICmnMIValueTuple miValueTuple;
-    const MIchar *pName = rValue.GetName();
-    MIunused(pName);
-    const MIuint nChildren = rValue.GetNumChildren();
-    if (nChildren == 0)
-    {
-        if (vbIsChildValue && utilValue.IsCharType())
-        {
-            // For char types and try to form text string
-            const CMICmnMIValueConst miValueConst(utilValue.GetValue().c_str(), true);
-            miValueTuple.Add(miValueConst, true);
-            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
-        }
-        else
-        {
-            // Basic types
-            switch (veVarInfoFormat)
-            {
-                case eVariableInfoFormat_NoValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    return vwrMiValueList.Add(miValueResult);
-                }
-                case eVariableInfoFormat_AllValues:
-                case eVariableInfoFormat_SimpleValues:
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                    const CMICmnMIValueResult miValueResult("name", miValueConst);
-                    miValueTuple.Add(miValueResult);
-                    const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
-                    const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-                    miValueTuple.Add(miValueResult2);
-                    break;
-                }
-                default:
-                    break;
-            }
-            return vwrMiValueList.Add(miValueTuple);
-        }
-    }
-    else if (utilValue.IsChildCharType())
-    {
-        switch (veVarInfoFormat)
-        {
-            case eVariableInfoFormat_NoValues:
-            {
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                return vwrMiValueList.Add(miValueResult);
-            }
-            case eVariableInfoFormat_AllValues:
-            case eVariableInfoFormat_SimpleValues:
-            {
-                // Append string text to the parent value information
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                miValueTuple.Add(miValueResult);
-
-                const CMIUtilString &rText(utilValue.GetChildValueCString());
-                if (rText.empty())
-                {
-                    const CMICmnMIValueConst miValueConst(utilValue.GetValue());
-                    const CMICmnMIValueResult miValueResult("value", miValueConst);
-                    miValueTuple.Add(miValueResult);
-                }
-                else
-                {
-                    if (utilValue.IsValueUnknown())
-                    {
-                        const CMICmnMIValueConst miValueConst(rText);
-                        const CMICmnMIValueResult miValueResult("value", miValueConst);
-                        miValueTuple.Add(miValueResult);
-                    }
-                    else
-                    {
-                        // 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
-                        const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%s %s", utilValue.GetValue().c_str(), rText.c_str()));
-                        const CMICmnMIValueResult miValueResult("value", miValueConst);
-                        miValueTuple.Add(miValueResult);
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
-        return vwrMiValueList.Add(miValueTuple);
+        CMICmnMIValueList miValueList2(true);
+            vrwnDepth++;
+            bOk = GetVariableInfo(vnMaxDepth, member, true, miValueList2, vrwnDepth);
+            vrwnDepth--;
+        }
+        if (bOk)
+        {
+            CMIUtilString valueStr = miValueList2.ExtractContentNoBrackets();
+            // This is to handle case when a child has further children. For example,
+            // a struct containing another struct member
+            // value="{var_a = 10,var_b = 97 'a',inner_ = { var_d = 30 }}
+            if(vbIsChildValue)
+                const CMICmnMIValueConst miValueConst(
+                            CMIUtilString::Format("%s = { %s }", utilValue.GetName().c_str (), valueStr.c_str()), true);
+                return vwrMiValueList.Add(miValueConst);
             }
             else
             {
-        switch (veVarInfoFormat)
-        {
-            case eVariableInfoFormat_NoValues:
-            {
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                return vwrMiValueList.Add(miValueResult);
-            }
-            case eVariableInfoFormat_AllValues:
-            case eVariableInfoFormat_SimpleValues:
-            {
-                // Build parent child composite types
-                CMICmnMIValueList miValueList(true);
-                for (MIuint i = 0; bOk && (i < nChildren); i++)
-                {
-                    lldb::SBValue member = rValue.GetChildAtIndex(i);
-                    bOk = GetVariableInfo(vnMaxDepth, member, true, veVarInfoFormat, miValueList, ++vrwnDepth);
-                }
-                const CMICmnMIValueConst miValueConst(utilValue.GetName());
-                const CMICmnMIValueResult miValueResult("name", miValueConst);
-                miValueTuple.Add(miValueResult);
-                const CMICmnMIValueConst miValueConst2(CMIUtilString::Format("{%s}", miValueList.ExtractContentNoBrackets().c_str()));
-                const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-                miValueTuple.Add(miValueResult2);
-                break;
-            }
-            default:
-                break;
+                const CMICmnMIValueConst miValueConst(valueStr, true);
+                return vwrMiValueList.Add(miValueConst);
         }
-        return vwrMiValueList.Add(miValueTuple);
+        return bOk;
     }
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form MI partial response by appending more MI value type objects to the
 //          tuple type object past in.
 // Type:    Method.
 // Args:    vrThread        - (R) LLDB thread object.

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetValue(void) const
 {
     CMIUtilString text;
 
     if (m_bHandleCharType && IsCharType())
     {
-        const lldb::addr_t addr = m_rValue.GetLoadAddress();
-        text = CMIUtilString::Format("0x%08x", addr);
-        const CMIUtilString cString(GetValueCString());
-        if (!cString.empty())
-            text += CMIUtilString::Format(" %s", cString.c_str());
+        uint8_t val = (uint8_t)m_rValue.GetValueAsUnsigned ();
+        text += CMIUtilString::Format("%d '%c'", val, (char)val);
     }
     else
     {
         const MIchar *pValue = m_bValidSBValue ? m_rValue.GetValue() : nullptr;
         text = (pValue != nullptr) ? pValue : m_pUnkwn;
     }
 
     return text;

 // Type:    Method.
 // Args:    None.
 // Return:  bool    - True = Yes is a char type, false = some other type.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBUtilSBValue::IsCharType(void) const
 {
-    const MIchar *pName = m_rValue.GetName();
-    MIunused(pName);
     const lldb::BasicType eType = m_rValue.GetType().GetBasicType();
     return ((eType == lldb::eBasicTypeChar) || (eType == lldb::eBasicTypeSignedChar) || (eType == lldb::eBasicTypeUnsignedChar));
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the flag stating whether any child value object of *this object is a
 //          char type or some other type. Returns false if there are not children. Char
 //          type can be signed or unsigned.

tools/lldb-mi/MICmnMIValueList.cpp

CMICmnMIValueList::BuildList(const CMICmnMIValue &vValue)
     // Clear out the default "<Invalid>" text
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vValue.GetString();
         return BuildList();
     }
 
+    // Remove already present '[' and ']' from the start and end
+    m_strValue = m_strValue.Trim();
+    size_t len = m_strValue.size();
+    if ( (len > 1) && (m_strValue[0] == '[') && (m_strValue[len - 1] == ']') )
+        m_strValue = m_strValue.substr(1, len - 2);
     const MIchar *pFormat = "[%s,%s]";
-    m_strValue = m_strValue.FindAndReplace("[", "");
-    m_strValue = m_strValue.FindAndReplace("]", "");
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str(), vValue.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the contents of *this value object but without the outer most
 //          brackets.