[lldb-mi] Fix implementation for a few mi commands

[aetf]

Summary

Some of the mi commands implemented in lldb-mi are incomplete/not confirming to the spec.

• gdb-show and gdb-set doesn't support getting/setting disassembly-flavor
• environment-cd should also change the working directory for inferior
• debugger CLI output should be printed as console-stream-output record, rather than being dumped directly

to stdout

• target-select should provide inner error message in mi response

Related bug report:

• https://llvm.org/bugs/show_bug.cgi?id=28026
• https://llvm.org/bugs/show_bug.cgi?id=28718
• https://llvm.org/bugs/show_bug.cgi?id=30265

[ki.stfu]

Hi! Please add tests for commands that you fixed. I'll take a look later this week.

[aetf]

Okay, tests should go to packages/Python/lldbsuite/test/tools/lldb-mi, right? I need to get familiar with them first.

[ki.stfu]

yes

[abidh]

Changes looks mostly Ok to me apart from some comments. Please address them and add testcases as mentioned by ilia. Also try to do one review for one fix. This review is for 3 fixes. When the changes are approved, please commit them in 3 separate commits (one per fix).

tools/lldb-mi/MICmdCmdGdbSet.cpp

421 ↗

(On Diff #71760)

You are not checking if SetInternalVariable returned an error which can happen in this case if the flavor name was not one of "intel", "att" or "default".

tools/lldb-mi/MICmdCmdMiscellanous.cpp

515 ↗

(On Diff #71760)

It is not really an OutofBand record but rather an output of the command. Why not simple add prepend an ~

tools/lldb-mi/MICmdCmdTarget.cpp

126 ↗

(On Diff #71760)

This does not seem related to any bug fix.

[aetf]

Add unit tests, add error checking for SetInternalVariable

[aetf]

Hi, sorry for the long delay. It has been a busy semester.

Added unit tests are

• MiGdbSetShowTestCase.test_lldbmi_gdb_set_disassembly_flavor for disassembly flavor settings. Note this one doesn't pass currently due to https://llvm.org/bugs/show_bug.cgi?id=31485
• MiEnvironmentCdTestCase.test_lldbmi_environment_cd for -environment-cd command

Extended test case:

• MiSyntaxTestCase.test_lldbmi_output_grammar to include a command generating console stream records

Fixed test case:

• MiExecTestCase.test_lldbmi_exec_arguments_set which breaks because of the console stream records

I tested against latest trunk version (290647), and all tests passed with 5 expected failures and 3 unexpected success:

• MiGdbSetShowTestCase.test_lldbmi_gdb_set_target_async_off
• MiInterpreterExecTestCase.test_lldbmi_settings_set_target_run_args_after
• MiSyntaxTestCase.test_lldbmi_process_output

I don't have the commit access, but I can create separate RRs if necessary. (should the target select error fix go to it's own RR?)

tools/lldb-mi/MICmdCmdMiscellanous.cpp

515 ↗

(On Diff #71760)

The output of the command should be a Stream record which is an OutofBand record according to the spec [1]. I agree it's no more than prepending '~' and quoting the string. But why not just do what the spec says? ;-)

[1] https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Stream-Records.html#GDB_002fMI-Stream-Records

tools/lldb-mi/MICmdCmdTarget.cpp

126 ↗

(On Diff #71760)

I didn't create a bug report for this since it's not a big deal. But it's rather annoying when debugging because the actual error description never gets to the output.

[abidh]

Looks good.

packages/Python/lldbsuite/test/tools/lldb-mi/main.cpp

22 ↗

(On Diff #82654)

This declaration looks redundant.

tools/lldb-mi/MICmdCmdMiscellanous.cpp

515 ↗

(On Diff #71760)

ok.

[aetf]

What do I do next? Could you help me commit and push this? since I don't have write access.

packages/Python/lldbsuite/test/tools/lldb-mi/main.cpp

22 ↗

(On Diff #82654)

It's used in TestMiGdbSetShow.test_lldbmi_gdb_set_ouptut_radix.

[abidh]

What do I do next? Could you help me commit and push this? since I don't have write access.

I will commit it for you.

[ki.stfu]

lgtm

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/TestMiEnvironmentCd.py

+"""
+Test lldb-mi -environment-cd command.
+"""
+
+from __future__ import print_function
+
+
+import lldbmi_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class MiEnvironmentCdTestCase(lldbmi_testcase.MiTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
+    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_environment_cd(self):
+        """Test that 'lldb-mi --interpreter' changes working directory for inferior."""
+
+        self.spawnLldbMi(args=None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # cd to a different directory
+        self.runCmd("-environment-cd /tmp")
+        self.expect("\^done")
+
+        # Run to the end
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("@\"cwd: /tmp\\r\\n\"", exactly=True)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/TestMiGdbSetShow.py

def test_lldbmi_gdb_set_ouptut_radix(self):
         self.runCmd("-var-evaluate-expression var_a")
         self.expect("\^done,value=\"012\"")
 
         # Test decimal output
         self.runCmd("-gdb-set output-radix 10")
         self.expect("\^done")
         self.runCmd("-var-evaluate-expression var_a")
         self.expect("\^done,value=\"10\"")
+
+    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
+    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
+    @expectedFailureAll(
+        bugnumber="llvm.org/pr31485: data-disassemble doesn't follow flavor settings")
+    def test_lldbmi_gdb_set_disassembly_flavor(self):
+        """Test that 'lldb-mi --interpreter' works for -gdb-set disassembly-flavor."""
+
+        self.spawnLldbMi(args=None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Run to BP_printf
+        line = line_number('main.cpp', '// BP_printf')
+        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\".+addr=\"(0x[0-9a-f]+)\"")
+
+        # Get starting and ending address from $pc
+        pc = int(self.child.match.group(1), base=16)
+        s_addr, e_addr = pc, pc + 1
+
+        # Test default output (att)
+        self.runCmd("-data-disassemble -s %d -e %d -- 0" % (s_addr, e_addr))
+        self.expect("movl ")
+
+        # Test intel style
+        self.runCmd("-gdb-set disassembly-flavor intel")
+        self.expect("\^done")
+        self.runCmd("-data-disassemble -s %d -e %d -- 0" % (s_addr, e_addr))
+        self.expect("mov ")
+
+        # Test AT&T style
+        self.runCmd("-gdb-set disassembly-flavor intel")
+        self.expect("\^done")
+        self.runCmd("-data-disassemble -s %d -e %d -- 0" % (s_addr, e_addr))
+        self.expect("movl ")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/control/TestMiExec.py

def test_lldbmi_exec_arguments_set(self):
         # Run to main
         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\"")
 
         # Check argc and argv to see if arg passed
+        # Note that exactly=True is needed to avoid extra escaping for re
         self.runCmd("-data-evaluate-expression argc")
         self.expect("\^done,value=\"5\"")
         #self.runCmd("-data-evaluate-expression argv[1]")
         # self.expect("\^done,value=\"--arg1\"")
         self.runCmd("-interpreter-exec command \"print argv[1]\"")
-        self.expect("\"--arg1\"")
+        self.expect("\\\"--arg1\\\"", exactly=True)
         #self.runCmd("-data-evaluate-expression argv[2]")
         #self.expect("\^done,value=\"2nd arg\"")
         self.runCmd("-interpreter-exec command \"print argv[2]\"")
-        self.expect("\"2nd arg\"")
+        self.expect("\\\"2nd arg\\\"", exactly=True)
         #self.runCmd("-data-evaluate-expression argv[3]")
         # self.expect("\^done,value=\"third_arg\"")
         self.runCmd("-interpreter-exec command \"print argv[3]\"")
-        self.expect("\"third_arg\"")
+        self.expect("\\\"third_arg\\\"", exactly=True)
         #self.runCmd("-data-evaluate-expression argv[4]")
         #self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
         self.runCmd("-interpreter-exec command \"print argv[4]\"")
-        self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
+        self.expect("\\\"fourth=\\\\\\\"4th arg\\\\\\\"\\\"", exactly=True)
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_arguments_reset(self):
         """Test that 'lldb-mi --interpreter' can reset previously set args using -exec-arguments."""
 
         self.spawnLldbMi(args=None)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/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 <cstdio>
 
+#ifdef _WIN32
+    #include <direct.h>
+    #define getcwd _getcwd // suppress "deprecation" warning
+#else
+    #include <unistd.h>
+#endif
+
 int
 main(int argc, char const *argv[])
 {
-    int a  = 10;
+    int a = 10;
 
+    char buf[512];
+    char *ans = getcwd(buf, sizeof(buf));
+    if (ans) {
+        printf("cwd: %s\n", ans);
+    }
+
     printf("argc=%d\n", argc); // BP_printf
+
     return 0;
 }

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/syntax/TestMiSyntax.py

class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
     def test_lldbmi_output_grammar(self):
         """Test that 'lldb-mi --interpreter' uses standard output syntax."""
 
         self.spawnLldbMi(args=None)
         self.child.setecho(False)
 
         # Run all commands simultaneously
         self.runCmd("-unknown-command")
+        self.runCmd("-interpreter-exec command help")
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.runCmd("-break-insert -f main")
         self.runCmd("-gdb-set target-async off")
         self.runCmd("-exec-run")
         self.runCmd("-gdb-set target-async on")
         self.runCmd("-exec-continue")
         self.runCmd("-gdb-exit")
 

lldb/trunk/tools/lldb-mi/MICmdCmdEnviro.cpp

if (!m_rLLDBDebugSessionInfo.SharedDataAdd<CMIUtilString>(rStrKeyWkDir,
                                      rStrKeyWkDir.c_str()));
       bOk = MIstatus::failure;
     }
   } else
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_FNFAILED),
                                    m_cmdData.strMiCmd.c_str(),
                                    "SetCurrentPlatformSDKRoot()"));
 
+  lldb::SBTarget sbTarget = m_rLLDBDebugSessionInfo.GetTarget();
+  if (sbTarget.IsValid()) {
+    lldb::SBLaunchInfo sbLaunchInfo = sbTarget.GetLaunchInfo();
+    sbLaunchInfo.SetWorkingDirectory(strWkDir.c_str());
+    sbTarget.SetLaunchInfo(sbLaunchInfo);
+  }
+
   return bOk;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record
 // Result
 //          for the work carried out in the Execute().

lldb/trunk/tools/lldb-mi/MICmdCmdGdbSet.h

private:
   // Methods:
 private:
   bool GetOptionFn(const CMIUtilString &vrGdbOptionName,
                    FnGdbOptionPtr &vrwpFn) const;
   bool OptionFnTargetAsync(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnPrint(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnSolibSearchPath(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnOutputRadix(const CMIUtilString::VecString_t &vrWords);
+  bool OptionFnDisassemblyFlavor(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnFallback(const CMIUtilString::VecString_t &vrWords);
 
   // Attributes:
 private:
   const static MapGdbOptionNameToFnGdbOptionPtr_t
       ms_mapGdbOptionNameToFnGdbOptionPtr;
   //
   const CMIUtilString m_constStrArgNamedGdbOption;

lldb/trunk/tools/lldb-mi/MICmdCmdGdbSet.cpp

 const CMICmdCmdGdbSet::MapGdbOptionNameToFnGdbOptionPtr_t
     CMICmdCmdGdbSet::ms_mapGdbOptionNameToFnGdbOptionPtr = {
         {"target-async", &CMICmdCmdGdbSet::OptionFnTargetAsync},
         {"print", &CMICmdCmdGdbSet::OptionFnPrint},
         // { "auto-solib-add", &CMICmdCmdGdbSet::OptionFnAutoSolibAdd },    //
         // Example code if need to implement GDB set other options
         {"output-radix", &CMICmdCmdGdbSet::OptionFnOutputRadix},
         {"solib-search-path", &CMICmdCmdGdbSet::OptionFnSolibSearchPath},
+        {"disassembly-flavor", &CMICmdCmdGdbSet::OptionFnDisassemblyFlavor},
         {"fallback", &CMICmdCmdGdbSet::OptionFnFallback}};
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmdCmdGdbSet constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
bool CMICmdCmdGdbSet::OptionFnOutputRadix(
   }
   CMICmnLLDBDebugSessionInfoVarObj::VarObjSetFormat(format);
 
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
+// Details: Carry out work to complete the GDB set option 'disassembly-flavor'
+// to prepare
+//          and send back information asked for.
+// Type:    Method.
+// Args:    vrWords - (R) List of additional parameters used by this option.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool CMICmdCmdGdbSet::OptionFnDisassemblyFlavor(
+    const CMIUtilString::VecString_t &vrWords) {
+  // Check we have at least one argument
+  if (vrWords.size() < 1) {
+    m_bGbbOptionFnHasError = true;
+    // m_strGdbOptionFnError = MIRSRC(IDS_CMD_ERR_GDBSET_OPT_SOLIBSEARCHPATH);
+    return MIstatus::failure;
+  }
+  const CMIUtilString &rStrValDisasmFlavor(vrWords[0]);
+
+  lldb::SBDebugger &rDbgr = m_rLLDBDebugSessionInfo.GetDebugger();
+  lldb::SBError error = lldb::SBDebugger::SetInternalVariable(
+      "target.x86-disassembly-flavor", rStrValDisasmFlavor.c_str(),
+      rDbgr.GetInstanceName());
+  if (error.Fail()) {
+    m_strGdbOptionFnError = error.GetCString();
+    return MIstatus::failure;
+  }
+
+  return MIstatus::success;
+}
+
+//++
+//------------------------------------------------------------------------------------
 // Details: Carry out work to complete the GDB set option to prepare and send
 // back the
 //          requested information.
 // Type:    Method.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.

lldb/trunk/tools/lldb-mi/MICmdCmdGdbShow.h

private:
 
   // Methods:
 private:
   bool GetOptionFn(const CMIUtilString &vrGdbOptionName,
                    FnGdbOptionPtr &vrwpFn) const;
   bool OptionFnTargetAsync(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnPrint(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnLanguage(const CMIUtilString::VecString_t &vrWords);
+  bool OptionFnDisassemblyFlavor(const CMIUtilString::VecString_t &vrWords);
   bool OptionFnFallback(const CMIUtilString::VecString_t &vrWords);
 
   // Attributes:
 private:
   const static MapGdbOptionNameToFnGdbOptionPtr_t
       ms_mapGdbOptionNameToFnGdbOptionPtr;
 
   const CMIUtilString m_constStrArgNamedGdbOption;

lldb/trunk/tools/lldb-mi/MICmdCmdGdbShow.cpp

 //===-- MICmdCmdGdbShow.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Overview:    CMICmdCmdGdbShow implementation.
 
 // Third party headers:
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBLanguageRuntime.h"
+#include "lldb/API/SBStringList.h"
 #include "lldb/API/SBThread.h"
 
 // In-house headers:
 #include "MICmdArgValListOfN.h"
 #include "MICmdArgValOptionLong.h"
 #include "MICmdArgValString.h"
 #include "MICmdCmdGdbShow.h"
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnMIResultRecord.h"
 #include "MICmnMIValueConst.h"
 
 // Instantiations:
 const CMICmdCmdGdbShow::MapGdbOptionNameToFnGdbOptionPtr_t
     CMICmdCmdGdbShow::ms_mapGdbOptionNameToFnGdbOptionPtr = {
         {"target-async", &CMICmdCmdGdbShow::OptionFnTargetAsync},
         {"print", &CMICmdCmdGdbShow::OptionFnPrint},
         {"language", &CMICmdCmdGdbShow::OptionFnLanguage},
+        {"disassembly-flavor", &CMICmdCmdGdbShow::OptionFnDisassemblyFlavor},
         {"fallback", &CMICmdCmdGdbShow::OptionFnFallback}};
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmdCmdGdbShow constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
bool CMICmdCmdGdbShow::OptionFnLanguage(
   const lldb::LanguageType eLanguageType = sbCompileUnit.GetLanguage();
 
   m_strValue = lldb::SBLanguageRuntime::GetNameForLanguageType(eLanguageType);
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
+// Details: Carry out work to complete the GDB show option 'disassembly-flavor' to prepare
+//          and send back the requested information.
+// Type:    Method.
+// Args:    vrWords - (R) List of additional parameters used by this option.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool CMICmdCmdGdbShow::OptionFnDisassemblyFlavor(const CMIUtilString::VecString_t &vrWords) {
+  MIunused(vrWords);
+
+  // Get current disassembly flavor
+  lldb::SBDebugger &rDbgr = m_rLLDBDebugSessionInfo.GetDebugger();
+  m_strValue = lldb::SBDebugger::GetInternalVariableValue("target.x86-disassembly-flavor",
+                                                          rDbgr.GetInstanceName()).GetStringAtIndex(0);
+  return MIstatus::success;
+}
+
+//++
+//------------------------------------------------------------------------------------
 // Details: Carry out work to complete the GDB show option to prepare and send
 // back the
 //          requested information.
 // Type:    Method.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.

lldb/trunk/tools/lldb-mi/MICmdCmdMiscellanous.cpp

 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdInterpreterExec::Acknowledge() {
   if (m_lldbResult.GetOutputSize() > 0) {
-    CMIUtilString strMsg(m_lldbResult.GetOutput());
-    strMsg = strMsg.StripCREndOfLine();
-    CMICmnStreamStdout::TextToStdout(strMsg);
+    const CMIUtilString line(m_lldbResult.GetOutput());
+    const bool bEscapeQuotes(true);
+    CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes));
+    CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_ConsoleStreamOutput, miValueConst);
+    const bool bOk = CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
+    if (!bOk)
+      return MIstatus::failure;
   }
   if (m_lldbResult.GetErrorSize() > 0) {
-    CMIUtilString strMsg(m_lldbResult.GetError());
-    strMsg = strMsg.StripCREndOfLine();
-    CMICmnStreamStderr::LLDBMsgToConsole(strMsg);
+    const CMIUtilString line(m_lldbResult.GetError());
+    const bool bEscapeQuotes(true);
+    CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes));
+    CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_LogStreamOutput, miValueConst);
+    const bool bOk = CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
+    if (!bOk)
+      return MIstatus::failure;
   }
 
   const CMICmnMIResultRecord miRecordResult(
       m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
   m_miResultRecord = miRecordResult;
 
   return MIstatus::success;
 }

lldb/trunk/tools/lldb-mi/MICmdCmdTarget.cpp

bool CMICmdCmdTargetSelect::Execute() {
   // Ask LLDB to collect to the target port
   const char *pPlugin("gdb-remote");
   lldb::SBError error;
   lldb::SBProcess process = rSessionInfo.GetTarget().ConnectRemote(
       rSessionInfo.GetListener(), strUrl.c_str(), pPlugin, error);
 
   // Verify that we have managed to connect successfully
   lldb::SBStream errMsg;
+  error.GetDescription(errMsg);
   if (!process.IsValid()) {
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_PLUGIN),
                                    m_cmdData.strMiCmd.c_str(),
                                    errMsg.GetData()));
     return MIstatus::failure;
   }
   if (error.Fail()) {
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_CONNECT_TO_TARGET),

lldb/trunk/tools/lldb-mi/MICmnMIOutOfBandRecord.h

enum OutOfBand_e {
     eOutOfBand_ThreadGroupExited,
     eOutOfBand_ThreadGroupRemoved,
     eOutOfBand_ThreadGroupStarted,
     eOutOfBand_ThreadCreated,
     eOutOfBand_ThreadExited,
     eOutOfBand_ThreadSelected,
     eOutOfBand_TargetModuleLoaded,
     eOutOfBand_TargetModuleUnloaded,
-    eOutOfBand_TargetStreamOutput
+    eOutOfBand_TargetStreamOutput,
+    eOutOfBand_ConsoleStreamOutput,
+    eOutOfBand_LogStreamOutput
   };
 
   // Methods:
 public:
   /* ctor */ CMICmnMIOutOfBandRecord();
   /* ctor */ CMICmnMIOutOfBandRecord(OutOfBand_e veType);
   /* ctor */ CMICmnMIOutOfBandRecord(OutOfBand_e veType,
                                      const CMICmnMIValueConst &vConst);

lldb/trunk/tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

MapOutOfBandToText(CMICmnMIOutOfBandRecord::OutOfBand_e veType) {
   case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected:
     return "thread-selected";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded:
     return "library-loaded";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded:
     return "library-unloaded";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput:
     return "";
+  case CMICmnMIOutOfBandRecord::eOutOfBand_ConsoleStreamOutput:
+    return "";
+  case CMICmnMIOutOfBandRecord::eOutOfBand_LogStreamOutput:
+    return "";
   }
   assert(false && "unknown CMICmnMIOutofBandRecord::OutOfBand_e");
   return NULL;
 }
 
 static const char *
 MapOutOfBandToToken(CMICmnMIOutOfBandRecord::OutOfBand_e veType) {
   switch (veType) {
MapOutOfBandToToken(CMICmnMIOutOfBandRecord::OutOfBand_e veType) {
   case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected:
     return "=";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded:
     return "=";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded:
     return "=";
   case CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput:
     return "@";
+  case CMICmnMIOutOfBandRecord::eOutOfBand_ConsoleStreamOutput:
+    return "~";
+  case CMICmnMIOutOfBandRecord::eOutOfBand_LogStreamOutput:
+    return "&";
   }
   assert(false && "unknown CMICmnMIOutofBandRecord::OutOfBand_e");
   return NULL;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Build the Out-of-band record's mandatory data part. The part up to