[LLDB] Switch to assembly view if source is moved

[jingham]

This change means that the two cases "no debug info" and "couldn't find your sources" end up looking very similar. I think it is fine to show the assembly but it would be better to also arrange a warning that we couldn't find this source file.

[clayborg]

I would rather not see a warning. If you don't have sources I don't really want to see:

warning: couldn't find foo.c
0x1000: add r1, r2, r3
....

[clayborg]

Maybe we can enable mixed mode display where it intersperses the source file and line in the disassembly when/if there is source info, but no source file?

[clayborg]

Ok, so Jim and I agreed verbally on the solution. If we have source, but we don't have the source file itself, then we should print the line table entry out. This can be done with:

if (num_lines == 0)
{
    const bool show_fullpaths = true;
    m_sc.line_entry.DumpStopContext(&strm, show_fullpaths) const
    have_source = false;
}

So the output will now be

/tmp/main.cpp:123
0x1000: add r1, r2, r3
...

No need for a warning, just print the line entry.

[jasonmolenda]

Maybe I'm an outlier here -- but I don't think we should show assembly code, unless specifically requested by the user, when we can't find a source file (but we have source-level debug information).

lldb used to behave the other way - when a source file could not be found, we would show assembly before the prompt. There were many complaints from users about this behavior; users who are thinking at a source level and using source commands like "step" and "next", did not want to see assembly, it was meaningless to them. If they stepi into an assembly routine or put a breakpoint on it - where we have no debug information, then presenting the assembly makes sense.

IIRC, gdb behaves the same way that lldb does today. e.g.

clang -g a.c
rm a.c
lldb a.out
(lldb) br s -n main
(lldb) r

• thread #1: tid = 0x5e8d52, 0x0000000100000ed7 a.out`main(argc=1, argv=0x00007fff5fbff958) + 39 at a.c:10, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1 frame #0: 0x0000000100000ed7 a.out`main(argc=1, argv=0x00007fff5fbff958) + 39 at a.c:10

(lldb) n
Process 38732 stopped

• thread #1: tid = 0x5e8d52, 0x0000000100000eea a.out`main(argc=1, argv=0x00007fff5fbff958) + 58 at a.c:11, queue = 'com.apple.main-thread', stop reason = step over frame #0: 0x0000000100000eea a.out`main(argc=1, argv=0x00007fff5fbff958) + 58 at a.c:11

(lldb)

I feel pretty strongly that this behavior should not be changed. Seeing mixed source and assembly is meaningful to me and I may personally like to see that -- but the vast majority of our users do not interact with their programs at that level.

[jasonmolenda]

I chatted with Jim and Greg about this today. We have a "stop-disassembly-display" setting right now. It can be one of three values:

never: never show assembly
no-source: show assembly when we have no debug information
always: always show assembly

"no-source" is a poor name. What this really means is "no-debuginfo". I think we should have four values for stop-disassembly-display:

never: never show assembly
no-debuginfo: show assembly when we have no debug info
no-source: show assembly when we have no source file
always: always show assembly

and I think the default for stop-disassembly-display should be no-debuginfo. This preserves the existing behavior but if users would prefer to see assembly when a source file is missing, they can set it to be "no-source" and they will get that behavior.

Mohit, what do you think about this approach?

Jim raised the point that it would be nice if lldb would print the full path of the missing source file when it can't print the source file. That way, if the user knows the source is available at a different file path, they can add a target.source-map remapping and lldb can show the source code. There is a mechanism for printing a warning one time in Process already, see Process::PrintWarningOptimization. This warning is printed once per Module - you can see that it passes the Module pointer to PrintWarning. We'd want to add a Process::PrintWarningSourceFileMissing method and issue it once per source file in a similar way. Don't feel obligated to do this - it's just something that we should do, unrelated to the changes you're looking at here. With this change, the first time a user steps into a context where we have debug info but cannot find the source, the user will get a message like

warning: Could not find source file at '/builder/project/subir_a/MySources.cpp'

and the user can be like "Oh yes, of course, it's actually on /archivedbuilds/project/subdir_a on this computer" and do the file remap.

[mohit.bhakkad]

Hi Jason, thanks for your suggestions. Yes, this approach looks good and one time warning should be helpful from users view, I will implement it get back with a patch soon.

[mohit.bhakkad]

Changes in this revision:

• changed no-source to no-debuginfo and made it default
• now no-source means display assembly if source file is missing, even if debug-info is present.

[mohit.bhakkad]

@jingham, @jasonmolenda,
is it okay to commit it?

[jasonmolenda]

Yep, Greg said the patch is good to commit.

source/Core/Debugger.cpp

GetDebuggerList()
     // global init constructors
     static DebuggerList g_list;
     return g_list;
 }
 
 OptionEnumValueElement
 g_show_disassembly_enum_values[] =
 {
-    { Debugger::eStopDisassemblyTypeNever,    "never",     "Never show disassembly when displaying a stop context."},
-    { Debugger::eStopDisassemblyTypeNoSource, "no-source", "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."},
-    { Debugger::eStopDisassemblyTypeAlways,   "always",    "Always show disassembly when displaying a stop context."},
+    { Debugger::eStopDisassemblyTypeNever,          "never",            "Never show disassembly when displaying a stop context."},
+    { Debugger::eStopDisassemblyTypeNoDebugInfo,    "no-debuginfo",     "Show disassembly when there is no debug information."},
+    { Debugger::eStopDisassemblyTypeNoSource,       "no-source",        "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."},
+    { Debugger::eStopDisassemblyTypeAlways,         "always",           "Always show disassembly when displaying a stop context."},
     { 0, NULL, NULL }
 };
 
 OptionEnumValueElement
 g_language_enumerators[] =
 {
     { eScriptLanguageNone,      "none",     "Disable scripting languages."},
     { eScriptLanguagePython,    "python",   "Select python as the default scripting language."},

 {
 {   "auto-confirm",             OptionValue::eTypeBoolean     , true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." },
 {   "disassembly-format",       OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_DISASSEMBLY_FORMAT, NULL, "The default disassembly format string to use when disassembling instruction sequences." },
 {   "frame-format",             OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." },
 {   "notify-void",              OptionValue::eTypeBoolean     , true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." },
 {   "prompt",                   OptionValue::eTypeString      , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." },
 {   "script-lang",              OptionValue::eTypeEnum        , true, eScriptLanguagePython, NULL, g_language_enumerators, "The script language to be used for evaluating user-written scripts." },
 {   "stop-disassembly-count",   OptionValue::eTypeSInt64      , true, 4    , NULL, NULL, "The number of disassembly lines to show when displaying a stopped context." },
-{   "stop-disassembly-display", OptionValue::eTypeEnum        , true, Debugger::eStopDisassemblyTypeNoSource, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
+{   "stop-disassembly-display", OptionValue::eTypeEnum        , true, Debugger::eStopDisassemblyTypeNoDebugInfo, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
 {   "stop-line-count-after",    OptionValue::eTypeSInt64      , true, 3    , NULL, NULL, "The number of sources lines to display that come after the current source line when displaying a stopped context." },
 {   "stop-line-count-before",   OptionValue::eTypeSInt64      , true, 3    , NULL, NULL, "The number of sources lines to display that come before the current source line when displaying a stopped context." },
 {   "term-width",               OptionValue::eTypeSInt64      , true, 80   , NULL, NULL, "The maximum number of columns to use for displaying text." },
 {   "thread-format",            OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_THREAD_FORMAT, NULL, "The default thread format string to use when displaying thread information." },
 {   "use-external-editor",      OptionValue::eTypeBoolean     , true, false, NULL, NULL, "Whether to use an external editor or not." },
 {   "use-color",                OptionValue::eTypeBoolean     , true, true , NULL, NULL, "Whether to use Ansi color codes or not." },
 {   "auto-one-line-summaries",  OptionValue::eTypeBoolean     , true, true, NULL, NULL, "If true, LLDB will automatically display small structs in one-liner format (default: true)." },
 {   "auto-indent",              OptionValue::eTypeBoolean     , true, true , NULL, NULL, "If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true)." },

source/Target/StackFrame.cpp

StackFrame::GetStatus (Stream& strm,
     {
         strm.Indent();
         DumpUsingSettingsFormat (&strm, frame_marker);
     }
     
     if (show_source)
     {
         ExecutionContext exe_ctx (shared_from_this());
-        bool have_source = false;
+        bool have_source = false, have_debuginfo = false;
         Debugger::StopDisassemblyType disasm_display = Debugger::eStopDisassemblyTypeNever;
         Target *target = exe_ctx.GetTargetPtr();
         if (target)
         {
             Debugger &debugger = target->GetDebugger();
             const uint32_t source_lines_before = debugger.GetStopSourceLineCount(true);
             const uint32_t source_lines_after = debugger.GetStopSourceLineCount(false);
             disasm_display = debugger.GetStopDisassemblyDisplay ();
 
             GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
             if (m_sc.comp_unit && m_sc.line_entry.IsValid())
             {
-                have_source = true;
+                have_debuginfo = true;
                 if (source_lines_before > 0 || source_lines_after > 0)
                 {
-                    target->GetSourceManager().DisplaySourceLinesWithLineNumbers (m_sc.line_entry.file,
+                    size_t num_lines = target->GetSourceManager().DisplaySourceLinesWithLineNumbers (m_sc.line_entry.file,
                                                                                       m_sc.line_entry.line,
                                                                                       source_lines_before,
                                                                                       source_lines_after,
                                                                                       "->",
                                                                                       &strm);
+                    if (num_lines != 0)
+                        have_source = true;
+                    // TODO: Give here a one time warning if source file is missing.
                 }
             }
             switch (disasm_display)
             {
             case Debugger::eStopDisassemblyTypeNever:
                 break;
-                
+            case Debugger::eStopDisassemblyTypeNoDebugInfo:
+                if (have_debuginfo)
+                    break;
+                // Fall through to next case
+
             case Debugger::eStopDisassemblyTypeNoSource:
                 if (have_source)
                     break;
                 // Fall through to next case
+
             case Debugger::eStopDisassemblyTypeAlways:
                 if (target)
                 {
                     const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
                     if (disasm_lines > 0)
                     {
                         const ArchSpec &target_arch = target->GetArchitecture();
                         AddressRange pc_range;