Add support for "source info" and use it to fix MI's -symbol-list-lines.

[dawn]

Summary

This patch adds support the command 'source info' as follows:

(lldb) help source info
     Display source line information (as specified) based on the current executable's
     debug info.

Syntax: source info <cmd-options>

Command Options Usage:
  source info [-c <count>] [-s <shlib-name>] [-f <filename>] [-l <linenum>] [-e <linenum>]
  source info [-c <count>] [-s <shlib-name>] [-n <symbol>]
  source info [-c <count>] [-a <address-expression>]

       -a <address-expression> ( --address <address-expression> )
            Lookup the address and display the source information for the corresponding
            file and line.

       -c <count> ( --count <count> )
            The number of line entries to display.

       -e <linenum> ( --end-line <linenum> )
            The line number at which to stop displaying lines.

       -f <filename> ( --file <filename> )
            The file from which to display source.

       -l <linenum> ( --line <linenum> )
            The line number at which to start the displaying lines.

       -n <symbol> ( --name <symbol> )
            The name of a function whose source to display.

       -s <shlib-name> ( --shlib <shlib-name> )
            Look up the source in the given module or shared library (can be specified
            more than once).

For example:

(lldb) source info --file x.h
Lines for file x.h in compilation unit x.cpp in `x
[0x0000000100000d00-0x0000000100000d10): /Users/dawn/tmp/./x.h:10
[0x0000000100000d10-0x0000000100000d1b): /Users/dawn/tmp/./x.h:10

The new options are used to fix the MI command:

-symbol-list-lines <file>

which didn't work for header files because it called:

target modules dump line-table <file>

which only dumps line tables for a compilation unit.

The patch also fixes a bug in the error reporting when no files were supplied to the command. Previously you'd get:

(lldb) target modules dump line-table
error:
Syntax:
error: no source filenames matched any command arguments

Now you get:

error: file option must be specified.

[dawn]

Updated patch to include changes to TestHelp.py.

[jingham]

I don't think this is sufficiently different from "target modules dump line-tables" to warrant a separate command. This seems more like a candidate for a flag to "target modules dump line-tables" like --search-for-inlines or something. That would keep the command surface more manageable and also make the option more discoverable, since you can get both variants in one place.

[dawn]

In D15593#312571, @jingham wrote:

I don't think this is sufficiently different from "target modules dump line-tables" to warrant a separate command. This seems more like a candidate for a flag to "target modules dump line-tables" like --search-for-inlines or something. That would keep the command surface more manageable and also make the option more discoverable, since you can get both variants in one place.

I first thought about adding it as an option to the line-table but decided against it because the information provided by each are just too different.

Dumping the tables gives you raw output from the CU's DWARF .debug_line entries, including end sequences, all files in the compilation unit, etc.:

(lldb) target modules du line-table x.cpp
Line table for /Users/dawn/tmp/x.cpp in `x
0x0000000100000aa0: /Users/dawn/tmp/x.cpp:12
0x0000000100000ab6: /Users/dawn/tmp/x.cpp:14
0x0000000100000af2: /Users/dawn/tmp/x.cpp:16
0x0000000100000afa: /Users/dawn/tmp/x.cpp:17
[...]
0x0000000100000cc0: /Users/dawn/tmp/x.cpp:6
0x0000000100000ccb: /Users/dawn/tmp/x.cpp:8
[...]
0x0000000100000d20: /Users/dawn/tmp/./x.h:10
0x0000000100000d2c: /Users/dawn/tmp/./x.h:10
0x0000000100000d3b: /Users/dawn/tmp/./x.h:10

Whereas dumping the line entries gives you entries after they've been interpreted and sorted by lldb, and will not include any files other than the one(s) asked for:

(lldb) target modules du line-entries x.h
Lines for file x.h in compilation unit x.cpp in `x
[0x0000000100000d00-0x0000000100000d10): /Users/dawn/tmp/./x.h:10
[0x0000000100000d10-0x0000000100000d1b): /Users/dawn/tmp/./x.h:10
[0x0000000100000d20-0x0000000100000d2c): /Users/dawn/tmp/./x.h:10
[0x0000000100000d2c-0x0000000100000d3b): /Users/dawn/tmp/./x.h:10

(lldb) target modules du line-entries x.cpp
Lines for file x.cpp in compilation unit x.cpp in `x
[0x0000000100000cc0-0x0000000100000ccb): /Users/dawn/tmp/x.cpp:6
[0x0000000100000ccb-0x0000000100000cdd): /Users/dawn/tmp/x.cpp:8
[0x0000000100000cdd-0x0000000100000cf1): /Users/dawn/tmp/x.cpp:9
[0x0000000100000aa0-0x0000000100000ab6): /Users/dawn/tmp/x.cpp:12
[0x0000000100000ab6-0x0000000100000af2): /Users/dawn/tmp/x.cpp:14
[...]

I'm fine with combining the two if we can find an interface that makes sense. 'line-table' is not appropriate for the new command, and '--search-for-inlines' doesn't convey the differences. We could change 'line-table' to 'lines', but then what?

[jingham]

Okay. So it seems like there are a couple of orthogonal differences here.

1. The current behavior requires that the the source file you pass in be a compile unit. We don't search inside the line tables. So for instance

target modules dump line-tables foo.h

would currently not dump anything.

2. We dump the whole line table for the given file, not just the lines from that file.

3. We show raw vrs. cooked line entries.

So it seems like your change is adding three flags

--compile-unit-only --only-explicit-matches --show-raw

or something. The current behavior is:

--compile-unit-only true --only-explicit-matches false --show-raw true

and your command does:

--compile-unit-only false --only-explicit-matches true --show-raw false

Does that seem right. If so, then we have to decide whether it is worth the effort to be able to tweak these three independently.

[dawn]

In D15593#312665, @jingham wrote:

So it seems like your change is adding three flags

--compile-unit-only --only-explicit-matches --show-raw

or something. The current behavior is:

--compile-unit-only true --only-explicit-matches false --show-raw true

and your command does:

--compile-unit-only false --only-explicit-matches true --show-raw false

Does that seem right.

Yup.

If so, then we have to decide whether it is worth the effort to be able to tweak these three independently.

I think these flags only make sense if you could tweak them independently, but to support something like:

--compile-unit-only false --only-explicit-matches true --show-raw *true*

would be a major pain - it would mean adding a lot of extra code and interfaces for something that would only be used by this one command.

I think it's better to just have both:

target modules line-tables <cu>
target modules line-entries <file>

and if we find a need for any other combinations of the options you proposed, we can merge them at that time.

Thoughts?

[jingham]

Provided we error out appropriately I don't think we need to support all possible combinations of options. I'd happier doing it by options and not supporting the combinations that aren't worth the effort. Then if anybody really needs one of the unsupported ones, the path to adding the support will be straight-forward, even if tedious.

The options seem to me to actually explain what the variants do, whereas the two names are not going to be meaningful enough to most folks to do more than cause confusion (and force me to have to type "line-t" or "line-e".)

[dawn]

I'm only going to support the combinations:

--compile-unit-only true --only-explicit-matches false --show-raw true
--compile-unit-only false --only-explicit-matches true --show-raw false

OK?

(and force me to have to type "line-t" or "line-e".)

or force me to have to type "line-table --compile-unit-only false --only-explicit-matches true --show-raw false"?! (ugh)

[jingham]

That seems fine for now.

Note, if you use the OptionGroupOptions way of defining the new options for your command, then you can call OptionsSeen to tell you which options were actually provided by the user, so for extra credit, if --compile-unit-only is true and no other options were provided, you can set the other options to the correct values, and ditto when --compile-unit-only is false. That way for now you would only have to provide --compile-unit-only, and the others would be set to the supported combo, but if they provided an unsupported combo you could report the error appropriately.

You can also get the same effect in the table driven way of defining options by just manually marking which options have been seen in your command's SetOptionValue (just remember to clear this info in the OptionParsingStarting method.

Jim

[ki.stfu]

clang-format your changes please (there are many deviations from the coding style)

I'll check it on Linux and say if everything is OK.

source/Commands/CommandObjectTarget.cpp

1510 ↗

(On Diff #43103)

nit: fix indentation

1536–1537 ↗

(On Diff #43103)

use size_t

1541–1542 ↗

(On Diff #43103)

Isn't it always false?

1543 ↗

(On Diff #43103)

You don't need a raw pointer here, just use cu_sp.get() on line #1587

1576 ↗

(On Diff #43103)

!cu_header_printed

1594–1596 ↗

(On Diff #43103)

combine it together:

cu->FindLineEntry(start_idx + 1, ...)

2689 ↗

(On Diff #43103)

Please use the most popular pattern:

error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);

tools/lldb-mi/MICmdCmdSymbol.cpp

85 ↗

(On Diff #43103)

Could you use long-options here?

[ki.stfu]

packages/Python/lldbsuite/test/tools/lldb-mi/symbol/symbol_list_lines_inline_test.h

20 ↗

(On Diff #43103)

and could you pick it up at 1 line above?

[dawn]

clang-format your changes please (there are many deviations from the coding style)

I've made some fixes even though the code is no longer consistent with the rest of the file. Alas. I would love to run all of lldb through clang-format, but as we've seen, there are several options which still need to be added before we can do that (mostly relating to the formatting function declarations).

source/Commands/CommandObjectTarget.cpp

1510 ↗

(On Diff #43103)

This is the original code, and is consistent with the coding style of the rest of the file. It bothers me too that lldb is so schizophrenic about its coding style, but unless we fix all of lldb, I think it's best to just try and follow the style of the code around you.

Does anyone else have an opinion about this? I'll go ahead and change it, only because I see I that the new code I added didn't follow this style (oops).

1541–1542 ↗

(On Diff #43103)

Code elsewhere checks for it, so I assume there are cases when cu_sp can be null. Example in source/Core/SearchFilter.cpp:

for (size_t i = 0; i < num_comp_units; i++)
{
    CompUnitSP cu_sp (module_sp->GetCompileUnitAtIndex (i));
    if (cu_sp)
    {

Better safe than sorry.

1543 ↗

(On Diff #43103)

There are 5 uses of cu in this code, so I think it's cleaner to have a variable.

1594–1596 ↗

(On Diff #43103)

I'd love to have a guideline as to when to wrap lines - lldb is all over the place about this. I've tended to try to keep lines to 100.

[dawn]

Updated patch with suggestions from Ilia's review (thanks Ilia!).

[clayborg]

Man those options are complex. I really would like to see something more simple:

"--raw" dumps the line entries as you have mentioned
"--no-inlines" would omit any inline entries
"--module <module>" would only find any source file arguments in the module that is specified by full or basename (this option can be specified more than once)

The arguments are still the compile unit names (full or basenames). If there are no arguments, dump all line tables from all modules. If --module is specified, then dump all compile units from any modules that are specified.

Am I missing something?

[clayborg]

Ok, so I talked with Jim on this and this is what we came up with. I would like to see no changes made to the "target modules dump line-table" command. It is dumping complete line tables. This command is not for "find any line entries that match this file anywhere including inline references". We should make this new command into "source info". Its syntax will be:

source info --file <file> [--line <line>] [--module <module]

line is optional. This job of this command is to find all line entries that match the file and optional line and optionally look only in the modules that might have been specified (might be more than one). --file and --line can only be specified once, --module can be specified multiple times.

The functionality that you reproduced in DumpFileLines() should be replaced. This is the code that looks through all compile units and finds the line entries that is contained in:

else if (compile_unit_only == false && explicit_matches_only == true && show_raw==false)

should be replaced with a call to:

uint32_t
CompileUnit::ResolveSymbolContext
(
    const FileSpec& file_spec,
    uint32_t line,
    bool check_inlines,
    bool exact,
    uint32_t resolve_scope,
    SymbolContextList &sc_list
)

As this already does exactly what you are doing. We will need to modify CompileUnit::ResolveSymbolContext() to accept the "line" argument being zero. It will return an "sc_list" of all matches, inside each symbol context will be the LineEntry that you need.

[clayborg]

I do want to apologize to Dawn and Jim for not having chimed in earlier and causing Dawn some extra work.

[ki.stfu]

source/Commands/CommandObjectTarget.cpp

1536–1537 ↗

(On Diff #43152)

use it on line #1536 too

1543 ↗

(On Diff #43152)

That's no problem. Just replace s/cu/cu_sp/ on lines #1544, #1565, #1580, #1594, and then use cu_sp.get() on line #1586.

1594–1596 ↗

(On Diff #43152)

How about that?

start_idx = cu->FindLineEntry(start_idx + 1,
                              line,
                              &cu_file_spec,
                              /*exact=*/true,
                              &line_entry);

2689 ↗

(On Diff #43152)

nit: you forgot the dot

[ki.stfu]

tools/lldb-mi/MICmdCmdSymbol.cpp

226 ↗

(On Diff #43152)

Is strWantFile needed? Seems it's an auxiliary variable.

[clayborg]

Dawn, if you don't understand what I asked you to do, let me know and I can go and do the "source info" command for you, then you can modify this patch to just use the command I added. But it should be simple to just revert and changes to the original line table dumping command, and move the contents over to the new "source info" command and just make it do what you wanted it to do.

[clayborg]

Note that you won't need any of the options that you had added to the other command becuase the "source info" command will do what you wanted in the first place: find all line entries where a file and optional line is mentioned in any line tables.

[dawn]

In D15593#313342, @clayborg wrote:

Dawn, if you don't understand what I asked you to do,

Sorry for late reply - been recovering from minor surgery. I have a new patch, but I've not yet gone through all of Ilia's additional comments - will probably go ahead and upload anyway just to give you all a glimpse, as I fear there will be a few more rounds before this patch is ready.

As this already does exactly what you are doing. We will need to modify CompileUnit::ResolveSymbolContext() to accept the "line" argument being zero. It will return an "sc_list" of all matches, inside each symbol context will be the LineEntry that you need.

I didn't do this because I added support for additional options which were supported by 'source list', and needed access to the options during the loop which collects the lines. I hope you'll agree that this was the right approach after seeing the patch.

[dawn]

Replies to Ilia's comments...

source/Commands/CommandObjectTarget.cpp

1543 ↗

(On Diff #43152)

this no longer applies to the most recent patch.

2689 ↗

(On Diff #43152)

did I forget a dot?

tools/lldb-mi/MICmdCmdSymbol.cpp

226 ↗

(On Diff #43152)

It's no longer needed with the new code, because you'll never get a file that isn't what was asked for.

[dawn]

Hopefully folks are back from the holidays by now - can someone give this a look? Thanks in advance...

[clayborg]

So I am going to let this through because you have done all we asked and I really like the "source info" command!

But in the future when adding things for MI, please add an API in the lldb::SB layer to do what you need. Text scraping is really not the solution we should be adding into the code. Other people using MI are going to see this kind of code and think it is what they should do when implementing/fixing new/existing MI commands.

We have an API for a debugger that we are trying to make with the lldb::SB layer, so we should use it and stop ANY form of text scraping in the future. I think an API'ized version of what you are requesting here -- all line table entries for a given source file -- should be available from SBTarget and a future modification to MICmdCmdSymbol.cpp should switch over to using it.

[dawn]

In D15593#319670, @clayborg wrote:

... in the future when adding things for MI, please add an API in the lldb::SB layer to do what you need.

Thanks for not asking me to do that as part of this patch.

Text scraping is really not the solution we should be adding into the code. Other people using MI are going to see this kind of code and think it is what they should do when implementing/fixing new/existing MI commands.

I agree that MI should have used the SB layer - did anyone ask the authors about that? Because as you say, the text scraping has now become a precedent for MI commands.

We have an API for a debugger that we are trying to make with the lldb::SB layer, so we should use it and stop ANY form of text scraping in the future. I think an API'ized version of what you are requesting here -- all line table entries for a given source file -- should be available from SBTarget and a future modification to MICmdCmdSymbol.cpp should switch over to using it.

+100. Except that I think it should only apply to new code - bug fixes like this shouldn't be held back because of preexisting code.

Rewriting lldb-mi to use the SB layer would be a great project for an intern or someone who wants to get familiar with lldb. We should keep that in mind if/when folks on lldb-dev ask about how they can help out.

[dawn]

I forgot to commit updated changes to the tests:

MiSymbolTestCase.test_lldbmi_symbol_list_lines_file
HelpCommandTestCase.test_help_image_du_line_should_work

so they are failing now, but svn at llvm.org appears to be down at the moment.
I'll commit those changes as soon as svn is back up...

[dawn]

Amended patch was posted to http://reviews.llvm.org/D15904 - hopefully someone who can get to llvm.org will commit.

[dawn]

Amended patch was committed in svn r256877 (svn at lldb.org is back up now)

[labath]

Hi, the new check you have added to TestMiSymbol fails on linux: all the source lines are listed twice for some reason. I don't know if this is expected behavior (and the test needs to be fixed) or it's an bug (and the code needs to be fixed), but I have marked the test as XFAIL no pacify the buildbots.

lldb/trunk/packages/Python/lldbsuite/test/help/TestHelp.py

def test_help_image_du_sym_is_ambiguous(self):
                        'symfile',
                        'symtab'])
 
     @no_debug_info_test
     def test_help_image_du_line_should_work(self):
         """Command 'help image du line' is not ambiguous and should work."""
         # 'image' is an alias for 'target modules'.
         self.expect("help image du line",
-            substrs = ['Dump the line table for one or more compilation units'])
+            substrs = ['Dump the line table for one or more files'])
 
     @no_debug_info_test
     def test_help_target_variable_syntax(self):
         """Command 'help target variable' should display <variable-name> ..."""
         self.expect("help target variable",
             substrs = ['<variable-name> [<variable-name> [...]]'])
 
     @no_debug_info_test

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

def test_lldbmi_symbol_list_lines_file(self):
 
         # 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\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"3\d\"\})*\]" % (sline, eline))
-        ##FIXME: This doesn't work for symbol_list_lines_inline_test.cpp due to clang bug llvm.org/pr24716
+        ##FIXME: This doesn't work for symbol_list_lines_inline_test.cpp due to clang bug llvm.org/pr24716 (fixed in newer versions of clang)
         ##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 works on header files by checking the first
+        # and last line, and making sure the other lines are under 29.
+        sline = line_number('symbol_list_lines_inline_test.h', '// FUNC_ifunc')
+        eline = line_number('symbol_list_lines_inline_test.h', '// FUNC_mfunc')
+        self.runCmd("-symbol-list-lines symbol_list_lines_inline_test.h")
+        self.expect("\^done,lines=\[\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d\"\})*(,\{pc=\"0x[0-9a-f]+\",line=\"1\d\"\})*,\{pc=\"0x[0-9a-f]+\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"2\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/packages/Python/lldbsuite/test/tools/lldb-mi/symbol/symbol_list_lines_inline_test.h

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

lldb/trunk/source/Commands/CommandObjectSource.cpp

 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/StackFrame.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/Options.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-//-------------------------------------------------------------------------
-// CommandObjectSourceInfo
-//-------------------------------------------------------------------------
+
+#pragma mark CommandObjectSourceInfo
+//----------------------------------------------------------------------
+// CommandObjectSourceInfo - debug line entries dumping command
+//----------------------------------------------------------------------
 
 class CommandObjectSourceInfo : public CommandObjectParsed
 {
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
-        {
-        }
+        CommandOptions (CommandInterpreter &interpreter) : Options(interpreter) {}
 
-        ~CommandOptions () override
-        {
-        }
+        ~CommandOptions () override {}
 
         Error
         SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
                 case 'l':
-                start_line = StringConvert::ToUInt32 (option_arg, 0);
+                    start_line = StringConvert::ToUInt32(option_arg, 0);
                     if (start_line == 0)
                         error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg);
                     break;
 
+                case 'e':
+                    end_line = StringConvert::ToUInt32(option_arg, 0);
+                    if (end_line == 0)
+                        error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg);
+                    break;
+
+                case 'c':
+                    num_lines = StringConvert::ToUInt32(option_arg, 0);
+                    if (num_lines == 0)
+                        error.SetErrorStringWithFormat("invalid line count: '%s'", option_arg);
+                    break;
+
                 case 'f':
                     file_name = option_arg;
                     break;
 
+                case 'n':
+                    symbol_name = option_arg;
+                    break;
+
+                case 'a':
+                {
+                    ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
+                    address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                }
+                break;
+                case 's':
+                    modules.push_back(std::string(option_arg));
+                    break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
         OptionParsingStarting () override
         {
             file_spec.Clear();
             file_name.clear();
+            symbol_name.clear();
+            address = LLDB_INVALID_ADDRESS;
             start_line = 0;
+            end_line = 0;
+            num_lines = 0;
+            modules.clear();
         }
 
-        const OptionDefinition*
+        const OptionDefinition *
         GetDefinitions () override
         {
             return g_option_table;
         }
         static OptionDefinition g_option_table[];
 
         // Instance variables to hold the values for command options.
         FileSpec file_spec;
         std::string file_name;
+        std::string symbol_name;
+        lldb::addr_t address;
         uint32_t start_line;
-        
+        uint32_t end_line;
+        uint32_t num_lines;
+        STLStringArray modules;
     };
- 
-public:   
-    CommandObjectSourceInfo(CommandInterpreter &interpreter) :
-        CommandObjectParsed (interpreter,
-                             "source info",
-                             "Display information about the source lines from the current executable's debug info.",
-                             "source info [<cmd-options>]"),
-        m_options (interpreter)
+public:
+    CommandObjectSourceInfo (CommandInterpreter &interpreter)
+        : CommandObjectParsed(interpreter, "source info", "Display source line information (as specified) based "
+                                                          "on the current executable's debug info.",
+                              NULL, eCommandRequiresTarget),
+          m_options(interpreter)
     {
     }
 
-    ~CommandObjectSourceInfo () override
-    {
-    }
-
+    ~CommandObjectSourceInfo () override {}
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
 protected:
+
+    // Dump the line entries in each symbol context.
+    // Return the number of entries found.
+    // If module_list is set, only dump lines contained in one of the modules.
+    // If file_spec is set, only dump lines in the file.
+    // If the start_line option was specified, don't print lines less than start_line.
+    // If the end_line option was specified, don't print lines greater than end_line.
+    // If the num_lines option was specified, dont print more than num_lines entries.
+    uint32_t
+    DumpLinesInSymbolContexts (Stream &strm, const SymbolContextList &sc_list,
+                               const ModuleList &module_list, const FileSpec &file_spec)
+    {
+        uint32_t start_line = m_options.start_line;
+        uint32_t end_line = m_options.end_line;
+        uint32_t num_lines = m_options.num_lines;
+        Target *target = m_exe_ctx.GetTargetPtr();
+
+        uint32_t num_matches = 0;
+        bool has_path = false;
+        if (file_spec)
+        {
+            assert(file_spec.GetFilename().AsCString());
+            has_path = (file_spec.GetDirectory().AsCString() != 0);
+        }
+    
+        // Dump all the line entries for the file in the list.
+        ConstString last_module_file_name;
+        uint32_t num_scs = sc_list.GetSize();
+        for (uint32_t i = 0; i < num_scs; ++i)
+        {
+            SymbolContext sc;
+            sc_list.GetContextAtIndex(i, sc);
+            if (sc.comp_unit)
+            {
+                Module *module = sc.module_sp.get();
+                CompileUnit *cu = sc.comp_unit;
+                const LineEntry &line_entry = sc.line_entry;
+                assert(module && cu);
+    
+                // Are we looking for specific modules, files or lines?
+                if (module_list.GetSize() && module_list.GetIndexForModule(module) == LLDB_INVALID_INDEX32)
+                    continue;
+                if (file_spec && !lldb_private::FileSpec::Equal(file_spec, line_entry.file, has_path))
+                    continue;
+                if (start_line > 0 && line_entry.line < start_line)
+                    continue;
+                if (end_line > 0 && line_entry.line > end_line)
+                    continue;
+                if (num_lines > 0 && num_matches > num_lines)
+                    continue;
+    
+                // Print a new header if the module changed.
+                const ConstString &module_file_name = module->GetFileSpec().GetFilename();
+                assert(module_file_name);
+                if (module_file_name != last_module_file_name)
+                {
+                    if (num_matches > 0)
+                        strm << "\n\n";
+                    strm << "Lines found in module `" << module_file_name << "\n";
+                }
+                // Dump the line entry.
+                line_entry.GetDescription(&strm, lldb::eDescriptionLevelBrief, cu,
+                                          target, /*show_address_only=*/false);
+                strm << "\n";
+                last_module_file_name = module_file_name;
+                num_matches++;
+            }
+        }
+        return num_matches;
+    }
+    
+    // Dump the requested line entries for the file in the compilation unit.
+    // Return the number of entries found.
+    // If module_list is set, only dump lines contained in one of the modules.
+    // If the start_line option was specified, don't print lines less than start_line.
+    // If the end_line option was specified, don't print lines greater than end_line.
+    // If the num_lines option was specified, dont print more than num_lines entries.
+    uint32_t
+    DumpFileLinesInCompUnit (Stream &strm, Module *module, CompileUnit *cu, const FileSpec &file_spec)
+    {
+        uint32_t start_line = m_options.start_line;
+        uint32_t end_line = m_options.end_line;
+        uint32_t num_lines = m_options.num_lines;
+        Target *target = m_exe_ctx.GetTargetPtr();
+
+        uint32_t num_matches = 0;
+        assert(module);
+        if (cu)
+        {
+            assert(file_spec.GetFilename().AsCString());
+            bool has_path = (file_spec.GetDirectory().AsCString() != 0);
+            const FileSpecList &cu_file_list = cu->GetSupportFiles();
+            size_t file_idx = cu_file_list.FindFileIndex(0, file_spec, has_path);
+            if (file_idx != UINT32_MAX)
+            {
+                // Update the file to how it appears in the CU.
+                const FileSpec &cu_file_spec = cu_file_list.GetFileSpecAtIndex(file_idx);
+    
+                // Dump all matching lines at or above start_line for the file in the CU.
+                const ConstString &file_spec_name = file_spec.GetFilename();
+                const ConstString &module_file_name = module->GetFileSpec().GetFilename();
+                bool cu_header_printed = false;
+                uint32_t line = start_line;
+                while (true)
+                {
+                    LineEntry line_entry;
+    
+                    // Find the lowest index of a line entry with a line equal to
+                    // or higher than 'line'.
+                    uint32_t start_idx = 0;
+                    start_idx = cu->FindLineEntry(start_idx, line, &cu_file_spec,
+                                                  /*exact=*/false, &line_entry);
+                    if (start_idx == UINT32_MAX)
+                        // No more line entries for our file in this CU.
+                        break;
+    
+                    if (end_line > 0 && line_entry.line > end_line)
+                        break;
+    
+                    // Loop through to find any other entries for this line, dumping each.
+                    line = line_entry.line;
+                    do
+                    {
+                        num_matches++;
+                        if (num_lines > 0 && num_matches > num_lines)
+                            break;
+                        assert(lldb_private::FileSpec::Equal(cu_file_spec, line_entry.file, has_path));
+                        if (!cu_header_printed)
+                        {
+                            if (num_matches > 0)
+                                strm << "\n\n";
+                            strm << "Lines found for file " << file_spec_name
+                                 << " in compilation unit " << cu->GetFilename()
+                                 << " in `" << module_file_name << "\n";
+                            cu_header_printed = true;
+                        }
+                        line_entry.GetDescription(&strm, lldb::eDescriptionLevelBrief, cu,
+                                                  target, /*show_address_only=*/false);
+                        strm << "\n";
+    
+                        // Anymore after this one?
+                        start_idx++;
+                        start_idx = cu->FindLineEntry(start_idx, line, &cu_file_spec,
+                                                      /*exact=*/true, &line_entry);
+                    } while (start_idx != UINT32_MAX);
+    
+                    // Try the next higher line, starting over at start_idx 0.
+                    line++;
+                }
+            }
+        }
+        return num_matches;
+    }
+    
+    // Dump the requested line entries for the file in the module.
+    // Return the number of entries found.
+    // If module_list is set, only dump lines contained in one of the modules.
+    // If the start_line option was specified, don't print lines less than start_line.
+    // If the end_line option was specified, don't print lines greater than end_line.
+    // If the num_lines option was specified, dont print more than num_lines entries.
+    uint32_t
+    DumpFileLinesInModule (Stream &strm, Module *module, const FileSpec &file_spec)
+    {
+        uint32_t num_matches = 0;
+        if (module)
+        {
+            // Look through all the compilation units (CUs) in this module for ones that
+            // contain lines of code from this source file.
+            for (size_t i = 0; i < module->GetNumCompileUnits(); i++)
+            {
+                // Look for a matching source file in this CU.
+                CompUnitSP cu_sp(module->GetCompileUnitAtIndex(i));
+                if (cu_sp)
+                {
+                    num_matches += DumpFileLinesInCompUnit(strm, module, cu_sp.get(), file_spec);
+                }
+            }
+        }
+        return num_matches;
+    }
+    
+    // Given an address and a list of modules, append the symbol contexts of all line entries
+    // containing the address found in the modules and return the count of matches.  If none
+    // is found, return an error in 'error_strm'.
+    size_t
+    GetSymbolContextsForAddress (const ModuleList &module_list, lldb::addr_t addr,
+                                 SymbolContextList &sc_list, StreamString &error_strm)
+    {
+        Address so_addr;
+        size_t num_matches = 0;
+        assert(module_list.GetSize() > 0);
+        Target *target = m_exe_ctx.GetTargetPtr();
+        if (target->GetSectionLoadList().IsEmpty())
+        {
+            // The target isn't loaded yet, we need to lookup the file address in
+            // all modules.  Note: the module list option does not apply to addresses.
+            const size_t num_modules = module_list.GetSize();
+            for (size_t i = 0; i < num_modules; ++i)
+            {
+                ModuleSP module_sp(module_list.GetModuleAtIndex(i));
+                if (!module_sp)
+                    continue;
+                if (module_sp->ResolveFileAddress(addr, so_addr))
+                {
+                    SymbolContext sc;
+                    sc.Clear(true);
+                    if (module_sp->ResolveSymbolContextForAddress(so_addr, eSymbolContextEverything, sc) &
+                        eSymbolContextLineEntry)
+                    {
+                        sc_list.AppendIfUnique(sc, /*merge_symbol_into_function=*/false);
+                        ++num_matches;
+                    }
+                }
+            }
+            if (num_matches == 0)
+                error_strm.Printf("Source information for file address 0x%" PRIx64
+                                  " not found in any modules.\n", addr);
+        }
+        else
+        {
+            // The target has some things loaded, resolve this address to a
+            // compile unit + file + line and display
+            if (target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
+            {
+                ModuleSP module_sp(so_addr.GetModule());
+                // Check to make sure this module is in our list.
+                if (module_sp &&
+                    module_list.GetIndexForModule(module_sp.get()) != LLDB_INVALID_INDEX32)
+                {
+                    SymbolContext sc;
+                    sc.Clear(true);
+                    if (module_sp->ResolveSymbolContextForAddress(so_addr, eSymbolContextEverything, sc) &
+                        eSymbolContextLineEntry)
+                    {
+                        sc_list.AppendIfUnique(sc, /*merge_symbol_into_function=*/false);
+                        ++num_matches;
+                    }
+                    else
+                    {
+                        StreamString addr_strm;
+                        so_addr.Dump(&addr_strm, NULL, Address::DumpStyleModuleWithFileAddress);
+                        error_strm.Printf("Address 0x%" PRIx64 " resolves to %s, but there is"
+                                          " no source information available for this address.\n",
+                                          addr, addr_strm.GetData());
+                    }
+                }
+                else
+                {
+                    StreamString addr_strm;
+                    so_addr.Dump(&addr_strm, NULL, Address::DumpStyleModuleWithFileAddress);
+                    error_strm.Printf("Address 0x%" PRIx64 " resolves to %s, but it cannot"
+                                      " be found in any modules.\n",
+                                      addr, addr_strm.GetData());
+                }
+            }
+            else
+                error_strm.Printf("Unable to resolve address 0x%" PRIx64 ".\n", addr);
+        }
+        return num_matches;
+    }
+
+    // Dump the line entries found in functions matching the name specified in the option. 
+    bool
+    DumpLinesInFunctions (CommandReturnObject &result)
+    {
+        SymbolContextList sc_list_funcs;
+        ConstString name(m_options.symbol_name.c_str());
+        SymbolContextList sc_list_lines;
+        Target *target = m_exe_ctx.GetTargetPtr();
+        uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+
+        // Note: module_list can't be const& because FindFunctionSymbols isn't const.
+        ModuleList module_list = (m_module_list.GetSize() > 0) ?
+                                 m_module_list : target->GetImages();
+        size_t num_matches = module_list.FindFunctions(name,
+                                                       eFunctionNameTypeAuto,
+                                                       /*include_symbols=*/false,
+                                                       /*include_inlines=*/true,
+                                                       /*append=*/true,
+                                                       sc_list_funcs);
+        if (!num_matches)
+        {
+            // If we didn't find any functions with that name, try searching for
+            // symbols that line up exactly with function addresses.
+            SymbolContextList sc_list_symbols;
+            size_t num_symbol_matches = module_list.FindFunctionSymbols(name,
+                                                                        eFunctionNameTypeAuto,
+                                                                        sc_list_symbols);
+            for (size_t i = 0; i < num_symbol_matches; i++)
+            {
+                SymbolContext sc;
+                sc_list_symbols.GetContextAtIndex(i, sc);
+                if (sc.symbol && sc.symbol->ValueIsAddress())
+                {
+                    const Address &base_address = sc.symbol->GetAddressRef();
+                    Function *function = base_address.CalculateSymbolContextFunction();
+                    if (function)
+                    {
+                        sc_list_funcs.Append(SymbolContext(function));
+                        num_matches++;
+                    }
+                }
+            }
+        }
+        if (num_matches == 0)
+        {
+            result.AppendErrorWithFormat("Could not find function named \'%s\'.\n",
+                                         m_options.symbol_name.c_str());
+            return false;
+        }
+        for (size_t i = 0; i < num_matches; i++)
+        {
+            SymbolContext sc;
+            sc_list_funcs.GetContextAtIndex(i, sc);
+            bool context_found_for_symbol = false;
+            // Loop through all the ranges in the function.
+            AddressRange range;
+            for (uint32_t r = 0;
+                 sc.GetAddressRange(eSymbolContextEverything,
+                                    r,
+                                    /*use_inline_block_range=*/true,
+                                    range);
+                 ++r)
+            {
+                // Append the symbol contexts for each address in the range to sc_list_lines.
+                const Address &base_address = range.GetBaseAddress();
+                const addr_t size = range.GetByteSize();
+                lldb::addr_t start_addr = base_address.GetLoadAddress(target);
+                if (start_addr == LLDB_INVALID_ADDRESS)
+                    start_addr = base_address.GetFileAddress();
+                lldb::addr_t end_addr = start_addr + size;
+                for (lldb::addr_t addr = start_addr; addr < end_addr; addr += addr_byte_size)
+                {
+                    StreamString error_strm;
+                    if (!GetSymbolContextsForAddress(module_list, addr, sc_list_lines, error_strm))
+                        result.AppendWarningWithFormat("in symbol '%s': %s",
+                                                       sc.GetFunctionName().AsCString(),
+                                                       error_strm.GetData());
+                    else
+                        context_found_for_symbol = true;
+                }
+            }
+            if (!context_found_for_symbol)
+                result.AppendWarningWithFormat("Unable to find line information"
+                                               " for matching symbol '%s'.\n",
+                                               sc.GetFunctionName().AsCString());
+        }
+        if (sc_list_lines.GetSize() == 0)
+        {
+            result.AppendErrorWithFormat("No line information could be found"
+                                         " for any symbols matching '%s'.\n",
+                                         name.AsCString());
+            return false;
+        }
+        FileSpec file_spec;
+        if (!DumpLinesInSymbolContexts(result.GetOutputStream(),
+                                       sc_list_lines, module_list, file_spec))
+        {
+            result.AppendErrorWithFormat("Unable to dump line information for symbol '%s'.\n",
+                                         name.AsCString());
+            return false;
+        }
+        return true;
+    }
+
+    // Dump the line entries found for the address specified in the option. 
+    bool
+    DumpLinesForAddress (CommandReturnObject &result)
+    {
+        Target *target = m_exe_ctx.GetTargetPtr();
+        SymbolContextList sc_list;
+
+        StreamString error_strm;
+        if (!GetSymbolContextsForAddress(target->GetImages(), m_options.address, sc_list, error_strm))
+        {
+            result.AppendErrorWithFormat("%s.\n", error_strm.GetData());
+            return false;
+        }
+        ModuleList module_list;
+        FileSpec file_spec;
+        if (!DumpLinesInSymbolContexts(result.GetOutputStream(),
+                                       sc_list, module_list, file_spec))
+        {
+            result.AppendErrorWithFormat("No modules contain load address 0x%" PRIx64 ".\n",
+                                         m_options.address);
+            return false;
+        }
+        return true;
+    }
+
+    // Dump the line entries found in the file specified in the option. 
+    bool
+    DumpLinesForFile (CommandReturnObject &result)
+    {
+        FileSpec file_spec(m_options.file_name, false);
+        const char *filename = m_options.file_name.c_str();
+        Target *target = m_exe_ctx.GetTargetPtr();
+        const ModuleList &module_list = (m_module_list.GetSize() > 0) ?
+                                        m_module_list : target->GetImages();
+
+        bool displayed_something = false;
+        const size_t num_modules = module_list.GetSize();
+        for (uint32_t i = 0; i < num_modules; ++i)
+        {
+            // Dump lines for this module.
+            Module *module = module_list.GetModulePointerAtIndex(i);
+            assert(module);
+            if (DumpFileLinesInModule(result.GetOutputStream(), module, file_spec))
+                displayed_something = true;
+        }
+        if (!displayed_something)
+        {
+            result.AppendErrorWithFormat("No source filenames matched '%s'.\n", filename);
+            return false;
+        }
+        return true;
+    }
+
+    // Dump the line entries for the current frame.
+    bool
+    DumpLinesForFrame (CommandReturnObject &result)
+    {
+        StackFrame *cur_frame = m_exe_ctx.GetFramePtr();
+        if (cur_frame == NULL)
+        {
+            result.AppendError("No selected frame to use to find the default source.");
+            return false;
+        }
+        else if (!cur_frame->HasDebugInformation())
+        {
+            result.AppendError("No debug info for the selected frame.");
+            return false;
+        }
+        else
+        {
+            const SymbolContext &sc = cur_frame->GetSymbolContext(eSymbolContextLineEntry);
+            SymbolContextList sc_list;
+            sc_list.Append(sc);
+            ModuleList module_list;
+            FileSpec file_spec;
+            if (!DumpLinesInSymbolContexts(result.GetOutputStream(), sc_list, module_list, file_spec))
+            {
+                result.AppendError("No source line info available for the selected frame.");
+                return false;
+            }
+        }
+        return true;
+    }
+
     bool
-    DoExecute (Args& command, CommandReturnObject &result) override
+    DoExecute (Args &command, CommandReturnObject &result) override
     {
-        result.AppendError ("Not yet implemented");
-        result.SetStatus (eReturnStatusFailed);
+        const size_t argc = command.GetArgumentCount();
+
+        if (argc != 0)
+        {
+            result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n",
+                                         GetCommandName());
+            result.SetStatus(eReturnStatusFailed);
+            return false;
+        }
+
+        Target *target = m_exe_ctx.GetTargetPtr();
+        if (target == NULL)
+        {
+            target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+            if (target == NULL)
+            {
+                result.AppendError("invalid target, create a debug target using the "
+                                   "'target create' command.");
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+        }
+
+        uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+        result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+        result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+
+        // Collect the list of modules to search.
+        m_module_list.Clear();
+        if (m_options.modules.size() > 0)
+        {
+            for (size_t i = 0, e = m_options.modules.size(); i < e; ++i)
+            {
+                FileSpec module_file_spec(m_options.modules[i].c_str(), false);
+                if (module_file_spec)
+                {
+                    ModuleSpec module_spec(module_file_spec);
+                    if (target->GetImages().FindModules(module_spec, m_module_list) == 0)
+                        result.AppendWarningWithFormat("No module found for '%s'.\n",
+                                                       m_options.modules[i].c_str());
+                }
+            }
+            if (!m_module_list.GetSize())
+            {
+                result.AppendError("No modules match the input.");
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+        }
+        else if (target->GetImages().GetSize() == 0)
+        {
+            result.AppendError("The target has no associated executable images.");
+            result.SetStatus(eReturnStatusFailed);
             return false;
         }
 
+        // Check the arguments to see what lines we should dump.
+        if (!m_options.symbol_name.empty())
+        {
+            // Print lines for symbol.
+            if (DumpLinesInFunctions(result))
+                result.SetStatus(eReturnStatusSuccessFinishResult);
+            else
+                result.SetStatus(eReturnStatusFailed);
+        }
+        else if (m_options.address != LLDB_INVALID_ADDRESS)
+        {
+            // Print lines for an address.
+            if (DumpLinesForAddress(result))
+                result.SetStatus(eReturnStatusSuccessFinishResult);
+            else
+                result.SetStatus(eReturnStatusFailed);
+        }
+        else if (!m_options.file_name.empty())
+        {
+            // Dump lines for a file.
+            if (DumpLinesForFile(result))
+                result.SetStatus(eReturnStatusSuccessFinishResult);
+            else
+                result.SetStatus(eReturnStatusFailed);
+        }
+        else
+        {
+            // Dump the line for the current frame.
+            if (DumpLinesForFrame(result))
+                result.SetStatus(eReturnStatusSuccessFinishResult);
+            else
+                result.SetStatus(eReturnStatusFailed);
+        }
+        return result.Succeeded();
+    }
+
     CommandOptions m_options;
+    ModuleList m_module_list;
 };
 
-OptionDefinition
-CommandObjectSourceInfo::CommandOptions::g_option_table[] =
-{
-{ LLDB_OPT_SET_1, false, "line",       'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLineNum,    "The line number at which to start the display source."},
-{ LLDB_OPT_SET_1, false, "file",       'f', OptionParser::eRequiredArgument, NULL, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,    "The file from which to display source."},
-{ 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
+OptionDefinition CommandObjectSourceInfo::CommandOptions::g_option_table[] = {
+    {LLDB_OPT_SET_ALL, false, "count", 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeCount,
+     "The number of line entries to display."},
+    {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib", 's', OptionParser::eRequiredArgument, NULL, NULL,
+     CommandCompletions::eModuleCompletion, eArgTypeShlibName,
+     "Look up the source in the given module or shared library (can be "
+     "specified more than once)."},
+    {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, NULL, NULL,
+     CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "The file from which to display source."},
+    {LLDB_OPT_SET_1, false, "line", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLineNum,
+     "The line number at which to start the displaying lines."},
+    {LLDB_OPT_SET_1, false, "end-line", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLineNum,
+     "The line number at which to stop displaying lines."},
+    {LLDB_OPT_SET_2, false, "name", 'n', OptionParser::eRequiredArgument, NULL, NULL,
+     CommandCompletions::eSymbolCompletion, eArgTypeSymbol, "The name of a function whose source to display."},
+    {LLDB_OPT_SET_3, false, "address", 'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeAddressOrExpression,
+     "Lookup the address and display the source information for the "
+     "corresponding file and line."},
+    {0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL}
 };
 
+
 #pragma mark CommandObjectSourceList
 //-------------------------------------------------------------------------
 // CommandObjectSourceList
 //-------------------------------------------------------------------------
 
 class CommandObjectSourceList : public CommandObjectParsed
 {
 

 { LLDB_OPT_SET_1  , false, "line",   'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLineNum,    "The line number at which to start the display source."},
 { LLDB_OPT_SET_2  , false, "name",   'n', OptionParser::eRequiredArgument, NULL, NULL, CommandCompletions::eSymbolCompletion, eArgTypeSymbol,    "The name of a function whose source to display."},
 { LLDB_OPT_SET_3  , false, "address",'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."},
 { LLDB_OPT_SET_4, false, "reverse", 'r', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Reverse the listing to look backwards from the last displayed block of source."},
 { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 #pragma mark CommandObjectMultiwordSource
-
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordSource
 //-------------------------------------------------------------------------
 
 CommandObjectMultiwordSource::CommandObjectMultiwordSource (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "source",
                             "A set of commands for accessing source file information",
                             "source <subcommand> [<subcommand-options>]")
 {
-    // "source info" isn't implemented yet...
-    //LoadSubCommand ("info",   CommandObjectSP (new CommandObjectSourceInfo (interpreter)));
+    LoadSubCommand ("info",   CommandObjectSP (new CommandObjectSourceInfo (interpreter)));
     LoadSubCommand ("list",   CommandObjectSP (new CommandObjectSourceList (interpreter)));
 }
 
 CommandObjectMultiwordSource::~CommandObjectMultiwordSource ()
 {
 }
 

lldb/trunk/source/Commands/CommandObjectTarget.cpp

DoExecute (Args& command, CommandReturnObject &result) override
         uint32_t total_num_dumped = 0;
 
         uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
         result.GetOutputStream().SetAddressByteSize(addr_byte_size);
         result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
         if (command.GetArgumentCount() == 0)
         {
-            result.AppendErrorWithFormat ("\nSyntax: %s\n", m_cmd_syntax.c_str());
+            result.AppendError ("file option must be specified.");
             result.SetStatus (eReturnStatusFailed);
+            return result.Succeeded();
         }
         else
         {
             // Dump specified images (by basename or fullpath)
             const char *arg_cstr;
             for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
             {
                 FileSpec file_spec(arg_cstr, false);

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

 // 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()));
+    const CMIUtilString strCmd(CMIUtilString::Format("source info --file \"%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
+        "^ *Lines for file (.+) in compilation unit (.+) in `(.+)$");
+        //                 ^1=file                  ^2=cu    ^3=module
 
-    MIUtilParse::CRegexParser::Match match(3);
+    MIUtilParse::CRegexParser::Match match(4);
 
     const bool ok = g_lineentry_header_regex.Execute(input, match);
     if (ok)
         file = match.GetMatchAtIndex(1);
     return ok;
 }
 
 //++ ------------------------------------------------------------------------------------
ParseLLDBLineAddressEntry(const char *input, CMIUtilString &addr,
     // 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]+)$");
+        "^ *\\[(0x[0-9a-fA-F]+)-(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)
+        "^ *\\[(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(5);
+    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)
     {
         addr = match.GetMatchAtIndex(1);
-        file = match.GetMatchAtIndex(2);
-        line = match.GetMatchAtIndex(3);
+        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.
else
             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;
-
             const CMICmnMIValueConst miValueConst(strAddr);
             const CMICmnMIValueResult miValueResult("pc", miValueConst);
             CMICmnMIValueTuple miValueTuple(miValueResult);
 
             const CMICmnMIValueConst miValueConst2(strLine);
             const CMICmnMIValueResult miValueResult2("line", miValueConst2);
             miValueTuple.Add(miValueResult2);