[LLDB-MI] Fix -data-info-line and -symbol-list-lines when Windows filenames are used.

[dawn]

Summary

This fixes -data-info-line and -symbol-list-lines to parse the filename and line correctly when line entries don't have the optional column number and the filename contains a Windows drive letter. It also fixes -symbol-list-lines when code from header files is generated.

[zturner]

Rather than all of this ugly error-prone code, can we instead use
llvm::sys::fs::root_name to check whether the path contains a drive letter?

[dawn]

In D12115#226962, @zturner wrote:

Rather than all of this ugly error-prone code, can we instead use
llvm::sys::fs::root_name to check whether the path contains a drive letter?

Sadly no, because root_name only parses c:\ correctly if the platform is Windows. Our IDE is hosted on Windows but talks to lldb running on OSX. I've had this path problem with the DWARF reader and FileSpec - lldb has a core assumption that you only want to support Windows paths if you run on Windows. At least with FileSpec you can pass a PathSyntax, but you have to choose either Windows or Posix, not both. We want to support both Posix and Windows style paths. I've not come up with a clean patch for this problem so none have been submitted. We should start another thread about how to resolve this problem...

For now, would it be OK to put a FIXME comment in the source?

[zturner]

Are you saying that there is a situation where you are given a path, and
you have no idea whether it is a posix path or a windows path? That seems
strange to me. Surely you must know (or be able to find out) if the
computer you are interfacing with is running Windows or non-Windows, right?

[dawn]

Are you saying that there is a situation where you are given a path, and you have no idea whether it is a posix path or a windows path?

Yes. For example, in lldb on OSX, we can be debugging an app that was built on OSX, or an app that was built on Windows targeting OSX. More likely, we would be debugging an app that was built on Windows but links with libraries that were built on OSX.

I've thought of various ways to fit this into lldb...
One idea was to add:

settings set target.pathsyntax [posix|windows|any|native] #default=native

and a FileSpec::ePathSyntaxAny enum which would be set if the user chose "any".
But that doesn't solve the problem for llvm, whose path handling appears to be controlled by the define LLVM_ON_WIN32.

Ideas?

[brucem]

Apart from the concerns expressed by zturner, this needs a test as well if possible.

[dawn]

In D12115#227241, @brucem wrote:

... this needs a test as well if possible.

Since the lldb-mi tests don't run on Windows, I don't see how that would be possible.

[abidh]

This command uses "target modules lookup" to obtain the information while -symbol-list-lines uses "target modules dump line-table". Although there is difference in the format of the output of these 2 commands, the format for path and line is same. I think we should have one code handling path strings in both of these places to avoid duplication.

It would be even better if we have some API which we can use to query this data. Then there would be no need for this parsing.

[dawn]

In D12115#227613, @abidh wrote:

This command uses "target modules lookup" [...]

Good point. Yes, it would be good to encapsulate this. I'll rework this patch accordingly when I can find the time (busy with a release now).

That said, I would love to continue the discussion of how to tackle the filename/path issue so I can have some direction as to how to resolve it. Should that move to lldb-dev?

[zturner]

Seems reasonable to move that to lldb-dev.

[dawn]

This changes the code to use regex to handle the parsing. It is cleaner, more accurate, and faster than the previous code, while not requiring special support to check for Windows paths.

In reworking this patch, I discovered a major bug in -symbol-list-lines where it didn't check the filename so would report lines in header files as belonging to the compilation unit. That is fixed in this patch and a test added, but to fix -symbol-list-lines for header files requires a rewrite of -symbol-list-lines which I didn't have time for. I've added a FIXME for now.

[dawn]

ping?

[zturner]

I'm probably not the best person for this since I don't know anything about
the MI stuff

[abidh]

We dont use the lldb_private stuff inside lldb-mi. Please see the discussion in the following thread.
http://lists.llvm.org/pipermail/lldb-dev/2015-March/007047.html

[dawn]

In D12115#243093, @abidh wrote:

We dont use the lldb_private stuff inside lldb-mi. Please see the discussion in the following thread.
http://lists.llvm.org/pipermail/lldb-dev/2015-March/007047.html

Thank you for your review and for the link. I agree in general and have avoided lldb_private myself, but this means duplicated code which is arguably worse. I think it's time to make lldb-mi a proper part of lldb to avoid reinventing the wheel, or adding SB APIs that make no sense outside of lldb-mi. But I am sympathetic to both arguments so will revise.

[zturner]

The FileSpec is not even used for anything is it? If you want to use the
RegularExpression, then use llvm's regular expression. Honestly LLDB's
regular expression should be deprecated anyway, there's no reason to have
an LLDB regex and an LLVM regex when just one will suffice

[dawn]

In D12115#244049, @zturner wrote:

The FileSpec is not even used for anything is it?

No, that was a carry over from a previous patch - now deleted.

If you want to use the
RegularExpression, then use llvm's regular expression. Honestly LLDB's
regular expression should be deprecated anyway, there's no reason to have
an LLDB regex and an LLVM regex when just one will suffice

I agree.

But for now, I've written a small regex wrapper for lldb-mi based on llvm's C regex implementation which uses lldb-mi's string types. It would be awesome to replace lldb-mi's types with those of llvm someday (e.g. have CMIUtilString use StringRef instead of std::string, etc), so that it would be easier to use llvm's classes.

[dawn]

Patch fixed to remove uses of lldb_private classes.

[abidh]

You forgot to add the MIUtilParse.cpp to CMakeLists.txt. Please add it and then it is good to go. Thanks for doing it.

[dawn]

Oops - forgot patch to CMakeLists.txt.

OK to commit now?

[ki.stfu]

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

12 ↗

(On Diff #34812)

Don't impose restrictions on the main file which contains test cases for symbol-xxx commands. If a new cases should be added, we will be forced to modify this test case (or be sure that we are still between 20-29 lines). I don't want to care about existing test cases when adding a new one. So please keep this file independent of line numbers, and move all your line-dependent code to a new file. For me, it should look like:
main.cpp:

int main ()  {
  [...]
  symbol_list_lines_for_inline_test();
  [...]
}

symbol_list_lines_for_inline_test.cpp:

// Skip lines so we can make sure we're not seeing any lines from x.h
[...]
// line 17
// line 18
// line 19
#include "x.h"
extern int j;
extern int gfunc(int i);
int i;
void symbol_list_lines_for_inline_test()  {
    i = gfunc(j);
    i += ns::s.mfunc();
    i += ns::ifunc(i);
}

And rename x.[h,cpp] to something more informative (symbol_list_lines_for_inline_test_x.[cpp|h] would be better).

test/tools/lldb-mi/symbol/x.h

1–14 ↗

(On Diff #34812)

Please fix the indentation here (for ex, use clang-format)

tools/lldb-mi/MIUtilString.cpp

69 ↗

(On Diff #34812)

Remove this empty line

[dawn]

Ilia, You did the initial implementation of -symbol-list-lines right? I've fixed a major bug in your code with this commit! You have -symbol-list-lines including lines from header files in the compilation unit! Give the test in this patch a try and you will see. It means you get bogus line information.

Oops! I'm sorry, I think I've misunderstood your issue. You are talking about the test case itself, not the restriction on the filename in the -symbol-list-lines code right? OK, no problem.

[dawn]

Ilia, thank you for your review - I think I understand what you are asking for now.

[dawn]

Tests changed as requested by Ilia. Ok to commit?

[ki.stfu]

lgtm

[chaoren]

Could you please take a look at these issues?

TestMiSymbol started to fail on Linux with gcc-4.9:
http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/6387

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

13

This caused a build failure on OS X:
http://lab.llvm.org:8011/builders/lldb-x86_64-darwin-13.4/builds/5801

[dawn]

In D12115#248069, @chaoren wrote:

Could you please take a look at these issues?

TestMiSymbol started to fail on Linux with gcc-4.9:
http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/6387

Hi Chaoren,
I believe the issue with gcc was fixed for gcc a while back. Just checking to make sure you're no longer seeing the failure. Let me know otherwise.

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

13

This was fixed by Sean - the XCode build wasn't including the full set of include paths when building lldb-mi.

[chaoren]

Yeah, it seems like it's been passing for gcc-4.9 for a while now. Thanks
for checking!

lldb/trunk/test/tools/lldb-mi/symbol/Makefile

 LEVEL = ../../../make
 
-CXX_SOURCES := main.cpp
+CXX_SOURCES := main.cpp symbol_list_lines_inline_test.cpp symbol_list_lines_inline_test2.cpp
 
 include $(LEVEL)/Makefile.rules

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

def test_lldbmi_symbol_list_lines_file(self):
         self.expect("\^done,value=\"0x[0-9a-f]+\"")
         addr = int(self.child.after.split("\"")[1], 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
+        # are between 30 and 39.
+        sline = line_number('symbol_list_lines_inline_test2.cpp', '// FUNC_gfunc2')
+        eline = line_number('symbol_list_lines_inline_test2.cpp', '// END_gfunc2')
+        self.runCmd("-symbol-list-lines symbol_list_lines_inline_test2.cpp")
+        self.expect("\^done,lines=\[\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"3\d\"\})*,\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}\]" % (sline, eline))
+        ##FIXME: This doesn't work for symbol_list_lines_inline_test.cpp due to clang bug llvm.org/pr24716
+        ##sline = line_number('symbol_list_lines_inline_test.cpp', '// FUNC_gfunc')
+        ##eline = line_number('symbol_list_lines_inline_test.cpp', '// STRUCT_s')
+        ##self.runCmd("-symbol-list-lines symbol_list_lines_inline_test.cpp")
+        ##self.expect("\^done,lines=\[\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"3\d\"\})*,\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}\]" % (sline, eline))
+
         # Test that -symbol-list-lines fails when file doesn't exist
         self.runCmd("-symbol-list-lines unknown_file")
         self.expect("\^error,message=\"warning: No source filenames matched 'unknown_file'\. error: no source filenames matched any command arguments \"")
 
         # Test that -symbol-list-lines fails when file is specified using relative path
         self.runCmd("-symbol-list-lines ./main.cpp")
         self.expect("\^error,message=\"warning: No source filenames matched '\./main\.cpp'\. error: no source filenames matched any command arguments \"")
 

lldb/trunk/test/tools/lldb-mi/symbol/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.
 //
 //===----------------------------------------------------------------------===//
 
+extern int j;
+extern int gfunc(int i);
+extern int gfunc2(int i);
 int
-main(int argc, char const *argv[]) 
+main()
 { // FUNC_main
-    return 0;
+    int i = gfunc(j) + gfunc2(j);
+    return i == 0;
 }

lldb/trunk/test/tools/lldb-mi/symbol/symbol_list_lines_inline_test.h

+namespace ns
+{
+inline int
+ifunc(int i)
+{
+    return i;
+}
+struct S
+{
+    int a;
+    int b;
+    S()
+        : a(3)
+        , b(4)
+    {
+    }
+    int
+    mfunc()
+    {
+        return a + b;
+    }
+};
+extern S s;
+}

lldb/trunk/test/tools/lldb-mi/symbol/symbol_list_lines_inline_test.cpp

+// Skip lines so we can make sure we're not seeing any lines from
+// symbol_list_lines_inline_test.h included in -symbol-list-lines
+// symbol_list_lines_inline_test.cpp, by checking that all the lines
+// are between 30 and 39.
+// line 5
+// line 6
+// line 7
+// line 8
+// line 9
+// line 10
+// line 11
+// line 12
+// line 13
+// line 14
+// line 15
+// line 16
+// line 17
+// line 18
+// line 19
+// line 20
+// line 21
+// line 22
+// line 23
+// line 24
+// line 25
+// line 26
+// line 27
+// line 28
+// line 29
+#include "symbol_list_lines_inline_test.h"
+int
+gfunc(int i)
+{ // FUNC_gfunc
+    return ns::ifunc(i);
+}
+namespace ns
+{
+S s; // STRUCT_s
+}

lldb/trunk/test/tools/lldb-mi/symbol/symbol_list_lines_inline_test2.cpp

+// Skip lines so we can make sure we're not seeing any lines from
+// symbol_list_lines_inline_test.h included in -symbol-list-lines
+// symbol_list_lines_inline_test2.cpp, by checking that all the lines
+// are between 30 and 39.
+// line 5
+// line 6
+// line 7
+// line 8
+// line 9
+// line 10
+// line 11
+// line 12
+// line 13
+// line 14
+// line 15
+// line 16
+// line 17
+// line 18
+// line 19
+// line 20
+// line 21
+// line 22
+// line 23
+// line 24
+// line 25
+// line 26
+// line 27
+// line 28
+// line 29
+#include "symbol_list_lines_inline_test.h"
+int j = 2;
+int
+gfunc2(int i)
+{ // FUNC_gfunc2
+    i += ns::s.mfunc();
+    i += ns::ifunc(i);
+    return i == 0; // END_gfunc2
+}

lldb/trunk/tools/lldb-mi/CMakeLists.txt

set(LLDB_MI_SOURCES
   MICmnStreamStderr.cpp
   MICmnStreamStdin.cpp
   MICmnStreamStdout.cpp
   MICmnThreadMgrStd.cpp
   MIDriver.cpp
   MIDriverBase.cpp
   MIDriverMain.cpp
   MIDriverMgr.cpp
+  MIUtilParse.cpp
   MIUtilDateTimeStd.cpp
   MIUtilDebug.cpp
   MIUtilFileStd.cpp
   MIUtilMapIdToVariant.cpp
   MIUtilString.cpp
   MIUtilThreadBaseStd.cpp
   MIUtilVariant.cpp
   Platform.cpp

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

 #include "MICmdArgValString.h"
 #include "MICmdArgValThreadGrp.h"
 #include "MICmdArgValOptionLong.h"
 #include "MICmdArgValOptionShort.h"
 #include "MICmdArgValListOfN.h"
 #include "MICmdArgValConsume.h"
 #include "MICmnLLDBDebugSessionInfoVarObj.h"
 #include "MICmnLLDBUtilSBValue.h"
+#include "MIUtilParse.h"
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdDataEvaluateExpression constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
CMICmdCmdDataInfoLine::Execute()
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::ReturnStatus rtn = rSessionInfo.GetDebugger().GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult);
     MIunused(rtn);
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: Helper function for parsing a line entry returned from lldb for the command:
+//              target modules lookup -v <location>
+//          where the line entry is of the format:
+//              LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/file:3[:1]
+//                           start              end                   file       line column(opt)
+// Args:    input - (R) Input string to parse.
+//          start - (W) String representing the start address.
+//          end   - (W) String representing the end address.
+//          file  - (W) String representing the file.
+//          line  - (W) String representing the line.
+// Return:  bool - True = input was parsed successfully, false = input could not be parsed.
+// Throws:  None.
+//--
+static bool
+ParseLLDBLineEntry(const char *input, CMIUtilString &start, CMIUtilString &end,
+                   CMIUtilString &file, CMIUtilString &line)
+{
+    // Note: Ambiguities arise because the column is optional, and
+    // because : can appear in filenames or as a byte in a multibyte
+    // UTF8 character.  We keep those cases to a minimum by using regex
+    // to work on the string from both the left and right, so that what
+    // is remains is assumed to be the filename.
+
+    // Match LineEntry using regex.
+    static MIUtilParse::CRegexParser g_lineentry_nocol_regex( 
+        "^ *LineEntry: \\[(0x[0-9a-fA-F]+)-(0x[0-9a-fA-F]+)\\): (.+):([0-9]+)$");
+    static MIUtilParse::CRegexParser g_lineentry_col_regex( 
+        "^ *LineEntry: \\[(0x[0-9a-fA-F]+)-(0x[0-9a-fA-F]+)\\): (.+):([0-9]+):[0-9]+$");
+        //                ^1=start         ^2=end               ^3=f ^4=line ^5=:col(opt)
+
+    MIUtilParse::CRegexParser::Match match(6);
+
+    // First try matching the LineEntry with the column,
+    // then try without the column.
+    const bool ok = g_lineentry_col_regex.Execute(input, match) ||
+                    g_lineentry_nocol_regex.Execute(input, match);
+    if (ok)
+    {
+        start = match.GetMatchAtIndex(1);
+        end   = match.GetMatchAtIndex(2);
+        file  = match.GetMatchAtIndex(3);
+        line  = match.GetMatchAtIndex(4);
+    }
+    return ok;
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record Result
 //          for the work carried out in the Execute().
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
else if (m_lldbResult.GetOutputSize() > 0)
         const CMIUtilString strLldbMsg(m_lldbResult.GetOutput());
         const MIuint nLines(strLldbMsg.SplitLines(vecLines));
 
         for (MIuint i = 0; i < nLines; ++i)
         {
             // String looks like:
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             const CMIUtilString &rLine(vecLines[i]);
+            CMIUtilString strStart;
+            CMIUtilString strEnd;
+            CMIUtilString strFile;
+            CMIUtilString strLine;
 
-            // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
-            // ^^^^^^^^^ -- property
-            const size_t nPropertyStartPos = rLine.find_first_not_of(' ');
-            const size_t nPropertyEndPos = rLine.find(':');
-            const size_t nPropertyLen = nPropertyEndPos - nPropertyStartPos;
-            const CMIUtilString strProperty(rLine.substr(nPropertyStartPos, nPropertyLen).c_str());
-
-            // Skip all except LineEntry
-            if (!CMIUtilString::Compare(strProperty, "LineEntry"))
+            if (!ParseLLDBLineEntry(rLine.c_str(), strStart, strEnd, strFile, strLine))
                 continue;
 
-            // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
-            //              ^^^^^^^^^^^^^^^^^^ -- start address
-            const size_t nStartAddressStartPos = rLine.find('[');
-            const size_t nStartAddressEndPos = rLine.find('-');
-            const size_t nStartAddressLen = nStartAddressEndPos - nStartAddressStartPos - 1;
-            const CMIUtilString strStartAddress(rLine.substr(nStartAddressStartPos + 1, nStartAddressLen).c_str());
-            const CMICmnMIValueConst miValueConst(strStartAddress);
+            const CMICmnMIValueConst miValueConst(strStart);
             const CMICmnMIValueResult miValueResult("start", miValueConst);
-            CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done, miValueResult);
-
-            // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
-            //                                 ^^^^^^^^^^^^^^^^^^ -- end address
-            const size_t nEndAddressEndPos = rLine.find(')');
-            const size_t nEndAddressLen = nEndAddressEndPos - nStartAddressEndPos - 1;
-            const CMIUtilString strEndAddress(rLine.substr(nStartAddressEndPos + 1, nEndAddressLen).c_str());
-            const CMICmnMIValueConst miValueConst2(strEndAddress);
+            CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken,
+                                                CMICmnMIResultRecord::eResultClass_Done,
+                                                miValueResult);
+            const CMICmnMIValueConst miValueConst2(strEnd);
             const CMICmnMIValueResult miValueResult2("end", miValueConst2);
             miRecordResult.Add(miValueResult2);
-
-            // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
-            //                                                       ^^^^^^^^^^^^^ -- file
-            //                                                                     ^ -- line
-            //                                                                        ^ -- column (optional)
-            const size_t nFileStartPos = rLine.find_first_not_of(' ', nEndAddressEndPos + 2);
-            const size_t nFileOrLineEndPos = rLine.rfind(':');
-            const size_t nFileOrLineStartPos = rLine.rfind(':', nFileOrLineEndPos - 1);
-            const size_t nFileEndPos = nFileStartPos < nFileOrLineStartPos ? nFileOrLineStartPos : nFileOrLineEndPos;
-            const size_t nFileLen = nFileEndPos - nFileStartPos;
-            const CMIUtilString strFile(rLine.substr(nFileStartPos, nFileLen).c_str());
             const CMICmnMIValueConst miValueConst3(strFile);
             const CMICmnMIValueResult miValueResult3("file", miValueConst3);
             miRecordResult.Add(miValueResult3);
-
-            // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
-            //                                                                     ^ -- line
-            const size_t nLineStartPos = nFileEndPos + 1;
-            const size_t nLineEndPos = rLine.find(':', nLineStartPos);
-            const size_t nLineLen = nLineEndPos != std::string::npos ? nLineEndPos - nLineStartPos
-                                                                     : std::string::npos;
-            const CMIUtilString strLine(rLine.substr(nLineStartPos, nLineLen).c_str());
             const CMICmnMIValueConst miValueConst4(strLine);
             const CMICmnMIValueResult miValueResult4("line", miValueConst4);
             miRecordResult.Add(miValueResult4);
 
             // MI print "%s^done,start=\"%d\",end=\"%d\"",file=\"%s\",line=\"%d\"
             m_miResultRecord = miRecordResult;
 
             return MIstatus::success;

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

 
 // In-house headers:
 #include "MICmdArgValFile.h"
 #include "MICmdCmdSymbol.h"
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnMIResultRecord.h"
 #include "MICmnMIValueList.h"
 #include "MICmnMIValueTuple.h"
+#include "MIUtilParse.h"
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdSymbolListLines constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--

 // Throws:  None.
 //--
 bool
 CMICmdCmdSymbolListLines::Execute()
 {
     CMICMDBASE_GETOPTION(pArgFile, File, m_constStrArgNameFile);
 
     const CMIUtilString &strFilePath(pArgFile->GetValue());
+    // FIXME: this won't work for header files!  To try and use existing
+    // commands to get this to work for header files would be too slow.
+    // Instead, this code should be rewritten to use APIs and/or support
+    // should be added to lldb which would work for header files.
     const CMIUtilString strCmd(CMIUtilString::Format("target modules dump line-table \"%s\"", strFilePath.AddSlashes().c_str()));
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::ReturnStatus rtn = rSessionInfo.GetDebugger().GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult);
     MIunused(rtn);
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: Helper function for parsing the header returned from lldb for the command:
+//              target modules dump line-table <file>
+//          where the header is of the format:
+//              Line table for /path/to/file in `/path/to/module
+// Args:    input - (R) Input string to parse.
+//          file  - (W) String representing the file.
+// Return:  bool - True = input was parsed successfully, false = input could not be parsed.
+// Throws:  None.
+//--
+static bool
+ParseLLDBLineAddressHeader(const char *input, CMIUtilString &file)
+{
+    // Match LineEntry using regex.
+    static MIUtilParse::CRegexParser g_lineentry_header_regex( 
+        "^ *Line table for (.+) in `(.+)$");
+        //                 ^1=file  ^2=module
+
+    MIUtilParse::CRegexParser::Match match(3);
+
+    const bool ok = g_lineentry_header_regex.Execute(input, match);
+    if (ok)
+        file = match.GetMatchAtIndex(1);
+    return ok;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Helper function for parsing a line entry returned from lldb for the command:
+//              target modules dump line-table <file>
+//          where the line entry is of the format:
+//              0x0000000100000e70: /path/to/file:3002[:4]
+//              addr                file          line column(opt)
+// Args:    input - (R) Input string to parse.
+//          addr  - (W) String representing the pc address.
+//          file  - (W) String representing the file.
+//          line  - (W) String representing the line.
+// Return:  bool - True = input was parsed successfully, false = input could not be parsed.
+// Throws:  None.
+//--
+static bool
+ParseLLDBLineAddressEntry(const char *input, CMIUtilString &addr,
+                          CMIUtilString &file, CMIUtilString &line)
+{
+    // Note: Ambiguities arise because the column is optional, and
+    // because : can appear in filenames or as a byte in a multibyte
+    // UTF8 character.  We keep those cases to a minimum by using regex
+    // to work on the string from both the left and right, so that what
+    // is remains is assumed to be the filename.
+
+    // Match LineEntry using regex.
+    static MIUtilParse::CRegexParser g_lineentry_nocol_regex( 
+        "^ *(0x[0-9a-fA-F]+): (.+):([0-9]+)$");
+    static MIUtilParse::CRegexParser g_lineentry_col_regex( 
+        "^ *(0x[0-9a-fA-F]+): (.+):([0-9]+):[0-9]+$");
+        //  ^1=addr           ^2=f ^3=line ^4=:col(opt)
+
+    MIUtilParse::CRegexParser::Match match(5);
+
+    // First try matching the LineEntry with the column,
+    // then try without the column.
+    const bool ok = g_lineentry_col_regex.Execute(input, match) ||
+                    g_lineentry_nocol_regex.Execute(input, match);
+    if (ok)
+    {
+        addr = match.GetMatchAtIndex(1);
+        file = match.GetMatchAtIndex(2);
+        line = match.GetMatchAtIndex(3);
+    }
+    return ok;
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record Result
 //          for the work carried out in the Execute().
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
if (m_lldbResult.GetErrorSize() > 0)
         m_miResultRecord = miRecordResult;
     }
     else
     {
         CMIUtilString::VecString_t vecLines;
         const CMIUtilString strLldbMsg(m_lldbResult.GetOutput());
         const MIuint nLines(strLldbMsg.SplitLines(vecLines));
 
+        // Parse the file from the header.
+        const CMIUtilString &rWantFile(vecLines[0]);
+        CMIUtilString strWantFile;
+        if (!ParseLLDBLineAddressHeader(rWantFile.c_str(), strWantFile))
+        {
+            // Unexpected error - parsing failed.
+            // MI print "%s^error,msg=\"Command '-symbol-list-lines'. Error: Line address header is absent or has an unknown format.\""
+            const CMICmnMIValueConst miValueConst(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_SOME_ERROR), m_cmdData.strMiCmd.c_str(), "Line address header is absent or has an unknown format."));
+            const CMICmnMIValueResult miValueResult("msg", miValueConst);
+            const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
+            m_miResultRecord = miRecordResult;
+
+            return MIstatus::success;
+        }
+
+        // Parse the line address entries.
         CMICmnMIValueList miValueList(true);
         for (MIuint i = 1; i < nLines; ++i)
         {
             // String looks like:
             // 0x0000000100000e70: /path/to/file:3[:4]
             const CMIUtilString &rLine(vecLines[i]);
+            CMIUtilString strAddr;
+            CMIUtilString strFile;
+            CMIUtilString strLine;
+
+            if (!ParseLLDBLineAddressEntry(rLine.c_str(), strAddr, strFile, strLine))
+                continue;
+
+            // Skip entries which don't match the desired source.
+            if (strWantFile != strFile)
+                continue;
 
-            // 0x0000000100000e70: /path/to/file:3[:4]
-            // ^^^^^^^^^^^^^^^^^^ -- pc
-            const size_t nAddrEndPos = rLine.find(':');
-            const CMIUtilString strAddr(rLine.substr(0, nAddrEndPos).c_str());
             const CMICmnMIValueConst miValueConst(strAddr);
             const CMICmnMIValueResult miValueResult("pc", miValueConst);
             CMICmnMIValueTuple miValueTuple(miValueResult);
 
-            // 0x0000000100000e70: /path/to/file:3[:4]
-            //                                   ^ -- line
-            const size_t nLineOrColumnStartPos = rLine.rfind(':');
-            const CMIUtilString strLineOrColumn(rLine.substr(nLineOrColumnStartPos + 1).c_str());
-            const size_t nPathOrLineStartPos = rLine.rfind(':', nLineOrColumnStartPos - 1);
-            const size_t nPathOrLineLen = nLineOrColumnStartPos - nPathOrLineStartPos - 1;
-            const CMIUtilString strPathOrLine(rLine.substr(nPathOrLineStartPos + 1, nPathOrLineLen).c_str());
-            const CMIUtilString strLine(strPathOrLine.IsNumber() ? strPathOrLine : strLineOrColumn);
             const CMICmnMIValueConst miValueConst2(strLine);
             const CMICmnMIValueResult miValueResult2("line", miValueConst2);
             miValueTuple.Add(miValueResult2);
 
             miValueList.Add(miValueTuple);
         }
 
         // MI print "%s^done,lines=[{pc=\"%d\",line=\"%d\"}...]"

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

+//===-- MIUtilParse.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+ 
+#pragma once
+ 
+// Third party headers:
+#include "../lib/Support/regex_impl.h"
+
+// In-house headers:
+#include "MIUtilString.h"
+ 
+namespace MIUtilParse
+{
+ 
+//++ ============================================================================
+// Details: MI common code utility class. Used to parse the output
+//          returned from lldb commands using regex.
+//--
+class CRegexParser
+{
+  public:
+    // Helper class for keeping track of regex matches.
+    class Match
+    {
+        friend CRegexParser;
+      public:
+        /* ctor */ explicit Match(size_t nmatches)
+            : m_matchStrs(nmatches), m_maxMatches(nmatches)
+        {
+        }
+        size_t
+        GetMatchCount() const
+        {
+            return m_matchStrs.size();
+        }
+        CMIUtilString
+        GetMatchAtIndex(size_t i) const
+        {
+            if (m_matchStrs.size() > i)
+                return m_matchStrs[i];
+            return CMIUtilString();
+        }
+      private:
+        CMIUtilString::VecString_t m_matchStrs;
+        const size_t m_maxMatches;
+    };
+ 
+    // Methods:
+    // Compile the regular expression.
+    /* ctor */ explicit CRegexParser(const char *regexStr);
+ 
+    // Free the memory used by the regular expression.
+    /* dtor */ ~CRegexParser();
+ 
+    // No copies
+    CRegexParser(const CRegexParser&) = delete;
+    void operator=(CRegexParser&) = delete;
+ 
+    // Return the match at the index.
+    int
+    GetMatchCount(const Match& match) const
+    {
+        if (m_isValid)
+            return match.GetMatchCount();
+        return 0;
+    }
+ 
+    bool
+    IsValid() const
+    {
+        return m_isValid;
+    }
+ 
+    // Match the input against the regular expression.  Return an error
+    // if the number of matches is less than minMatches.  If the default
+    // minMatches value of 0 is passed, an error will be returned if
+    // the number of matches is less than the maxMatches value used to
+    // initialize Match.
+    bool
+    Execute(const char *input, Match& match, size_t minMatches = 0);
+ 
+  private:
+    llvm_regex_t m_emma;
+    const bool m_isValid;
+};
+
+}

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

+//===-- MIUtilParse.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 <memory>
+
+// In-house headers:
+#include "MIUtilParse.h"
+ 
+//++ ------------------------------------------------------------------------------------
+// Details: CRegexParser constructor.
+// Type:    Method.
+// Args:    regexStr - Pointer to the regular expression to compile.
+// Return:  None.
+// Throws:  None.
+//--
+MIUtilParse::CRegexParser::CRegexParser(const char *regexStr)
+    : m_isValid(llvm_regcomp(&m_emma, regexStr, REG_EXTENDED) == 0)
+{
+}
+ 
+//++ ------------------------------------------------------------------------------------
+// Details: CRegexParser destructor.
+// Type:    Method.
+// Args:    None.
+// Return:  None.
+// Throws:  None.
+//--
+MIUtilParse::CRegexParser::~CRegexParser()
+{
+    // Free up memory held within regex.
+    if (m_isValid)
+        llvm_regfree(&m_emma);
+}
+ 
+//++ ------------------------------------------------------------------------------------
+// Details: CRegexParser regex executer.
+//          Match the input against the regular expression.  Return an error
+//          if the number of matches is less than minMatches.  If the default
+//          minMatches value of 0 is passed, an error will be returned if
+//          the number of matches is less than the maxMatches value used to
+//          initialize Match.
+// Type:    Method.
+// Args:    input (R) - Pointer to UTF8 text data to be parsed.
+//          match (RW) - Reference to Match class.
+//          minMatches (R) - Minimum number of regex matches expected.
+// Return:  bool - True = minimum matches were met,
+//                 false = minimum matches were not met or regex failed.
+// Throws:  None.
+//--
+bool
+MIUtilParse::CRegexParser::Execute(const char *input, Match& match, size_t minMatches)
+{
+    if (!m_isValid)
+        return false;
+ 
+    std::unique_ptr<llvm_regmatch_t[]> matches(new llvm_regmatch_t[match.m_maxMatches]); // Array of matches
+   
+    if (llvm_regexec(&m_emma, input, match.m_maxMatches, matches.get(), 0) != 0)
+        return false;
+ 
+    size_t i;
+    for (i = 0; i < match.m_maxMatches && matches[i].rm_so >= 0; i++)
+    {
+        const int n = matches[i].rm_eo - matches[i].rm_so;
+        match.m_matchStrs[i].assign(input + matches[i].rm_so, n);
+    }
+    return i >= minMatches;
+}

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

public:
     static CMIUtilString ConvertToPrintableASCII(const char16_t vChar16, bool bEscapeQuotes = false);
     static CMIUtilString ConvertToPrintableASCII(const char32_t vChar32, bool bEscapeQuotes = false);
 
     // Methods:
   public:
     /* ctor */ CMIUtilString();
     /* ctor */ CMIUtilString(const char *vpData);
     /* ctor */ CMIUtilString(const char *const *vpData);
+    /* ctor */ CMIUtilString(const char *vpData, size_t nLen);
     //
     bool ExtractNumber(MIint64 &vwrNumber) const;
     CMIUtilString FindAndReplace(const CMIUtilString &vFind, const CMIUtilString &vReplaceWith) const;
     bool IsNumber() const;
     bool IsHexadecimalNumber() const;
     bool IsQuoted() const;
     CMIUtilString RemoveRepeatedCharacters(const char vChar);
     size_t Split(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;

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

 // Throws:  None.
 //--
 CMIUtilString::CMIUtilString(const char *const *vpData)
     : std::string((const char *)vpData)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: CMIUtilString constructor.
+// Type:    Method.
+// Args:    vpData  - Pointer to UTF8 text data.
+//          nLen    - Length of string.
+// Return:  None.
+// Throws:  None.
+//--
+CMIUtilString::CMIUtilString(const char *vpData, size_t nLen)
+    : std::string(vpData, nLen)
+{
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString assignment operator.
 // Type:    Method.
 // Args:    vpRhs   - Pointer to UTF8 text data.
 // Return:  CMIUtilString & - *this string.
 // Throws:  None.
 //--
 CMIUtilString &CMIUtilString::operator=(const char *vpRhs)
 {