RFC: Proposed change in the disassembly default format in lldb

[jasonmolenda]

Summary

In r219544 (2014-10-10) I changed the default disassembly format to more closely resemble gdb's disassembly format. After living on this format for a few months, there are obvious shortcomings with C++ and Objective-C programs and I want to try a new approach.

Originally lldb's disassembly would display the Module & Function/Symbol name on a line by itself when a new function/symbol began, on each line of assembly display the file/load address followed by opcode, operands, and comments (e.g. showing the target of a branch insn). Branches to the same function would have a comment listing the full function name plus an offset. Note that the addresses did not display the offset, just raw addresses, meaning you had to compare the full address of the branch target with the disassembly output to find the target of the branch. When the branch target was in inlined code, lldb would print all of the inlined functions in the comment field (on separate lines).

In October I changed this to more closely resemble gdb's output: Each line has the file/load address, the function name, the offset into the function ("+35"), opcode, operand, comment. Comments pointing to the same function behaved the same but inlined functions were not included. I try to elide function argument types (e.g. from a demangled C++ name) but with templated methods it can be enormous.

This style of disassembly looks pretty good for short C function names. Like

(lldb) disass -c 20

0x7fff94fbe188 <mach_msg_trap>: movq   %rcx, %r10
0x7fff94fbe18b <mach_msg_trap+3>: movl   $0x100001f, %eax
0x7fff94fbe190 <mach_msg_trap+8>: syscall

-> 0x7fff94fbe192 <mach_msg_trap+10>: retq

0x7fff94fbe193 <mach_msg_trap+11>: nop    
0x7fff94fbe194 <mach_msg_overwrite_trap>: movq   %rcx, %r10

but as soon as you get a hefty C++ name in there, it becomes very messy:

0x107915454 <CommandObjectBreakpointList::DoExecute+68>: jne 0x1be9331 ; CommandObjectBreakpointList::DoExecute + 113 at CommandObjectBreakpoint.cpp:1420

Or, an extreme example that I found in lldb with 30 seconds of looking (function name only) -

std::1::function<std::1::shared_ptr<lldb_private::TypeSummaryImpl> (lldb_private::ValueObject&)>::function<CommandObjectTypeSummary::CommandObjectTypeSummary(lldb_private::CommandInterpreter&)::'lambda'(lldb_private::ValueObject&)>

I want to go with a hybrid approach between these two styles. When there is a new symbol, we print the full module + function name. On each assembly line, we print the file/load address, the offset into the function in angle brackets, opcode, operand, and in the comments branches to the SAME function follow the <+36> style. An example:

(lldb) disass
LLDB`CommandObjectBreakpointList::DoExecute:

0x107915410 <+0>:    pushq  %rbp
0x107915411 <+1>:    movq   %rsp, %rbp
0x107915414 <+4>:    subq   $0x170, %rsp
0x10791541b <+11>:   movq   %rdi, -0x20(%rbp)
0x10791541f <+15>:   movq   %rsi, -0x28(%rbp)
0x107915423 <+19>:   movq   %rdx, -0x30(%rbp)
0x107915427 <+23>:   movq   -0x20(%rbp), %rdx

-> 0x10791542b <+27>: movq %rdx, %rsi

0x10791542e <+30>:   movb   0x165(%rdx), %al
0x107915434 <+36>:   andb   $0x1, %al
0x107915436 <+38>:   movq   %rsi, %rdi
0x107915439 <+41>:   movzbl %al, %esi
0x10791543c <+44>:   movq   %rdx, -0xf8(%rbp)
0x107915443 <+51>:   callq  0x107d87bb0               ; lldb_private::CommandObject::GetSelectedOrDummyTarget at CommandObject.cpp:1045
0x107915448 <+56>:   movq   %rax, -0x38(%rbp)
0x10791544c <+60>:   cmpq   $0x0, -0x38(%rbp)
0x107915454 <+68>:   jne    0x107915481               ; <+113> at CommandObjectBreakpoint.cpp:1420
0x10791545a <+74>:   leaq   0xf54d21(%rip), %rsi      ; "Invalid target. No current target or breakpoints."
0x107915461 <+81>:   movq   -0x30(%rbp), %rdi
0x107915465 <+85>:   callq  0x107d93640               ; lldb_private::CommandReturnObject::AppendError at CommandReturnObject.cpp:135
0x10791546a <+90>:   movl   $0x1, %esi
0x10791546f <+95>:   movq   -0x30(%rbp), %rdi
0x107915473 <+99>:   callq  0x107d93760               ; lldb_private::CommandReturnObject::SetStatus at CommandReturnObject.cpp:172
0x107915478 <+104>:  movb   $0x1, -0x11(%rbp)
0x10791547c <+108>:  jmp    0x1079158bd               ; <+1197> at CommandObjectBreakpoint.cpp:1470
0x107915481 <+113>:  movq   -0x38(%rbp), %rdi

The main drawback for this new arrangement is that you may be looking at a long series of instructions and forget the name of the function/method. You'll need to scroll backwards to the beginning of the disassembly to find this function's names. Minor details include doing a two-pass over the instruction list to find the maximum length of the address component and padding all the lines so the opcodes line up. For instance,

(lldb) disass -c 30 -n mach_msg_trap
libsystem_kernel.dylib`mach_msg_trap:

0x7fff94fbe188 <+0>:  movq   %rcx, %r10
0x7fff94fbe18b <+3>:  movl   $0x100001f, %eax
0x7fff94fbe190 <+8>:  syscall 
0x7fff94fbe192 <+10>: retq   
0x7fff94fbe193 <+11>: nop

dyld`mach_msg_trap:

0x7fff6a867210 <+0>:  movq   %rcx, %r10
0x7fff6a867213 <+3>:  movl   $0x100001f, %eax
0x7fff6a867218 <+8>:  syscall 
0x7fff6a86721a <+10>: retq   
0x7fff6a86721b <+11>: nop

The disassembly format can be overridden by the 'disassembly-format' setting if people have specific preferences. But I think this new hybrid style of disassembly will work the best as a default given the kinds of method names we see with OO languages.

Comments? I'd like to land this in a couple days if no one feels strongly about it.

[zturner]

Personally I prefer always seeing the full function name, even if it's
messy. As an aside, have you considered embedding the function name
directly as the operand to the jump instruction, as opposed to as a
comment? For example, instead of this:

0x107915443 <+51>: callq 0x107d87bb0 ;
lldb_private::CommandObject::GetSelectedOrDummyTarget at
CommandObject.cpp:1045

we would see this:

0x107915443 <+51>: callq lldb_private::CommandObject::G
etSelectedOrDummyTarget (0x107d87bb0) ;
[CommandObject.cpp:1045]

I find this much easier to read, because unless you're a magician who
thinks in hexadecimal, chances are you are more interested in the name than
the address, so your eyes will always have to scroll to the right to find
the function name. This way your eyes sometimes don't have to scroll to
the right.

[zturner]

What if this were done only for functions whose names were a certain length or longer? When the function is a reasonable length, it's nice to see it embedded directly at the call site. But maybe for functions whose name is too long, we could print some kind of magic string. I find it a little jarring to just see <+31> for example. In my head I know it's <+31> from this function, but it's still a little awkward. What about a magic identifier instead? Something like (this func) + 31. I'll use my "symbol name instead of address format" since I'm trying to sell that idea at the same time to give a few examples.

0x107915454 <+68>: jne CommandObjectBreakpointList::DoExecute + 113 ; [CommandObjectBreakpoint.cpp:1420]
0x107915454 <+68>: jne (this func) + 113 ; [CommandObjectBreakpoint.cpp:1420]
0x107915454 <+68>: jne MyClass<int>::DoSomething() + 113 ; [CommandObjectBreakpoint.cpp:1420]

In the second line, (this func) is used because the name to display is determined "too complicated" by some heuristic. I'm not sure if we care that it be deterministic or not. More often than not we prefer to see the function name inlined. So a heuristic could take into account length plus number of angle brackets, for example.

[jasonmolenda]

Initially I had this using "*" to mean current-function. So offsets were expressed like <*+36> but when it was all said and done, the "*" wasn't adding any information so I nixed it. If the <>'s weren't present, the * would be necessary but I think with the offset in the brackets, it's not needed. I'm not wedded to omitting the "*" but I think we're fine without it. I definitely don't want to lose the "+" and have the offsets expressed as "<30>" - that seems a little too much.

I originally was trying to think of a way to alternate the disassembly style based on the function name length. But that makes it hard to have a disassembly-format customization capability unless there was a disassembly-format-short-names and disassembly-format-long-names ;). And someone argued that it would be more confusing to users if we have multiple styles of disassembly formatting depending on the length of the function name -- people aren't going to know why the disassembler formats it one way for certain functions and a different way for a slightly longer function name function.

[zturner]

Well, my underlying premise is that I think we should display as much information about the function as we can without getting in the way. <+36> doesn't display any information (well, aside from the offset, as that's a given), so personally I think something like *always* choosing a display like <(this func)+36> is better than <+36>. But then you have to wonder, if the actual name of this function is shorter than the length of the string "(this func)" why not just display it? And from there, I start to question how long is too long. One way to choose might perhaps be to choose the maximum length to which you are justifying the comments, to guarantee that you never have a function's name spill over into the comments section. Then you have a deterministic, easy to understand rule about when the function name will be truncated to (this func).

BTW, do you have any thoughts on my suggestion regarding displaying the function name inline? More specifically, comparing the following two formats:

; function name embedded. Regular function vs. "too long" function
0x107915454 <+68>: jne CommandObjectBreakpointList::DoExecute + 113 (107915481) ; [CommandObjectBreakpoint.cpp:1420]
0x107915454 <+68>: jne <(this func) + 113> (107915481) ; [CommandObjectBreakpoint.cpp:1420]

; function name not embedded. Regular function vs. "too long" function
0x107915454 <+68>: jne 0x107915481 ; <+113> at CommandObjectBreakpoint.cpp:1420
0x107915454 <+68>: jne 0x107915481 ; <(this func) +113> at CommandObjectBreakpoint.cpp:1420

Using the embedded approach, you could actually provide a debugger setting such as 'disassembly-comment-column' and since the algorithm for determining whether to truncate the name would be based on whether it spills into the comment column, changing the value of the setting would allow longer function names to be displayed in an easy to understand way.

[jasonmolenda]

I like your suggestion of showing the comment contents as the operand instead of the raw address (or in addition to the raw address) -- but there are lots of things that can end up in the comments (and llvm can add additional things like hints about what an instruction does) so it might not make sense in every case.

I was ignoring the idea primarily because I want to stay focused on fixing the current output style.

gdb solved this too-long-name problem by having a maximum name length. If the function name was any longer than that, it was truncated. This was a poor solution IMO.

Why do people care where an instruction is in memory?

They want to know where the pc is currently
They have an address and want to know what instruction that is
They want to know an offset into the function to follow a branch instruction's behavior

And so my new format includes the pc-indicator, the address, and the offset of each instruction. I believe they don't need to see the function name on every line -- they need some way to know when one function ends and another begins (which we give them by a blank line and then a line with the new function name by itself). It would be NICE if we could include the function name but in OO programs, these are often too long to include (especially when the instruction branches to another part of that same function) without forcing a line wrap, and they add much less value than the current-pc/addr/offset information.

[zturner]

Isn't this proposal only for cases of jumping to somewhere else in the same function? Admittedly that's usually the most common type of jump, since it accounts for every control flow instruction.

In any case, I think my suggestion of displaying the operand to the jump instruction as either

jmp function + offset (addr) ; comment

or

jmp <(this func) + offset> (addr) ; comment

looks the best, but if you think that's outside the scope of this change, then I would at least vote for

jump addr ; <(this func) + offset>

(basically the same as your original proposal, except add some kind of word or string in the middle of <+offset> to make it easier on the eyes.

[jasonmolenda]

Right, I'm saying that

jmp function+offset (addr) ; comment

is a separate issue that I don't want to touch right now.

Yeah, Greg and I talked about what to put to indicate "this function". Like, literally we were thinking "this" at one point. Greg suggested a function pointer, like "(*)", and then we shortened it to just "*". But after a couple of days looking at output like

0x100032 <*+36>: jump addr ; <*+36>

we were like, you know, the "*" isn't really necessary, we're just used to seeing something there.

I'm not opposed to putting something before the + -- I'm not sure what it should be.

[zturner]

Also, would the 'disassembly-format' setting be to switch betwen old style and new style? Or would it just be toggle between displaying the function name or not displaying the function name? A toggle between displaying and not displaying the function name seems the best to me. This makes the behavior more straightforward and reduces the amount of code to maintain, and I think better addresses the issue at hand: Whether a line is going to be readable due to a too-long function name or not. If your original plan was for the 'disassembly-format' setting to control old style vs. new style, then I would vote for an additional option called 'disassembly-function-names' or something similar. There's plenty of times I'm debugging C code with short function names and I don't want to pay the penalty for something that isn't an issue.

In the future, I have ideas for a fully customizable disassembly format that would allow you to specify a format string with placeholders, then people could arrange the disassembly output however they wanted.

[jasonmolenda]

I didn't explain the disassembly-format in my proposal - it already works like you're describing. The current lldb format is

${current-pc-arrow}${addr-file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}:

A user can put this in their ~/.lldbinit file to keep that style of output.

[zturner]

Oh cool, I didn't know that was a thing :). In that case, it seems all my
concerns are moot, as i can just change the default. Sorry for the noise :)

[jasonmolenda]

Actually, on the bike ride home I realized that one of your concerns is justified: There is no formatter for the comment field in the disassembly output. A lot of different things can appear here -- this could be an address to an instruction in the current function, in a different function, in a segment of memory with no symbol at all, and there are a bunch of special behaviors like if it's the address of const data string, lldb prints the string. And I mentioned earlier, lldb has assembler hints it can output and we've got a low-priority ToDo to expose those hints to the user -- in the comment field too.

This is a drag - my patch, as it is written today, is going to write branch instructions inside the current function as <+36> regardless of any format setting. :/

[jasonmolenda]

Preparing to commit.

[jasonmolenda]

Landed in r229186.

Sending include/lldb/Core/Address.h
Sending include/lldb/Core/Disassembler.h
Sending include/lldb/Core/FormatEntity.h
Sending include/lldb/Symbol/SymbolContext.h
Sending source/API/SBInstruction.cpp
Sending source/API/SBInstructionList.cpp
Sending source/Breakpoint/BreakpointLocation.cpp
Sending source/Commands/CommandObjectSource.cpp
Sending source/Core/Address.cpp
Sending source/Core/Debugger.cpp
Sending source/Core/Disassembler.cpp
Sending source/Core/FormatEntity.cpp
Sending source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
Sending source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
Sending source/Symbol/SymbolContext.cpp
Sending source/Symbol/Variable.cpp
Sending source/Target/StackFrame.cpp
Sending source/Target/ThreadPlanTracer.cpp
Sending test/functionalities/abbreviation/TestAbbreviations.py
Sending test/functionalities/inferior-assert/TestInferiorAssert.py
Transmitting file data ....................
Committed revision 229186.

include/lldb/Core/Address.h

                                         ///< if the address is in a section (section of pointers, c strings, etc).
         DumpStyleResolvedDescriptionNoModule,
         DumpStyleResolvedDescriptionNoFunctionArguments,
+        DumpStyleNoFunctionName,        ///< Elide the function name; display an offset into the current function.
+                                        ///< Used primarily in disassembly symbolication
         DumpStyleDetailedSymbolContext, ///< Detailed symbol context information for an address for all symbol
                                         ///< context members.
         DumpStyleResolvedPointerDescription ///< Dereference a pointer at the current address and then lookup the

include/lldb/Core/Disassembler.h

     /// @param[in] disassembly_addr_format
     ///     The format specification for how addresses are printed.
     ///     Only needed if show_address is true.
+    ///
+    /// @param[in] max_address_text_size
+    ///     The length of the longest address string at the start of the
+    ///     disassembly line that will be printed (the Debugger::FormatDisassemblerAddress() string)
+    ///     so this method can properly align the instruction opcodes.
+    ///     May be 0 to indicate no indentation/alignment of the opcodes.
     //------------------------------------------------------------------
 
     virtual void

           const ExecutionContext* exe_ctx,
           const SymbolContext *sym_ctx,
           const SymbolContext *prev_sym_ctx,
-          const FormatEntity::Entry *disassembly_addr_format);
+          const FormatEntity::Entry *disassembly_addr_format,
+          size_t max_address_text_size);
     
     virtual bool
     DoesBranch () = 0;

include/lldb/Core/FormatEntity.h

                 FunctionAddrOffsetConcrete,
                 FunctionLineOffset,
                 FunctionPCOffset,
+                FunctionInitial,
+                FunctionChanged,
                 LineEntryFile,
                 LineEntryLineNumber,
                 LineEntryStartAddress,

include/lldb/Symbol/SymbolContext.h

     ///
     /// @param[in] so_addr
     ///     The resolved section offset address.
+    ///
+    /// @param[in] show_fullpaths
+    ///     When printing file paths (with the Module), whether the
+    ///     base name of the Module should be printed or the full path.
+    ///     
+    /// @param[in] show_module
+    ///     Whether the module name should be printed followed by a 
+    ///     grave accent "`" character.
+    ///
+    /// @param[in] show_inlined_frames
+    ///     If a given pc is in inlined function(s), whether the inlined
+    ///     functions should be printed on separate lines in addition to
+    ///     the concrete function containing the pc.
+    ///
+    /// @param[in] show_function_arguments
+    ///     If false, this method will try to elide the function argument
+    ///     types when printing the function name.  This may be ambiguous
+    ///     for languages that have function overloading - but it may
+    ///     make the "function name" too long to include all the argument
+    ///     types.
+    ///
+    /// @param[in] show_function_name
+    ///     Normally this should be true - the function/symbol name should
+    ///     be printed.  In disassembly formatting, where we want a format
+    ///     like "<*+36>", this should be false and "*" will be printed
+    ///     instead.
     //------------------------------------------------------------------
     bool
     DumpStopContext (Stream *s,

                      bool show_fullpaths,
                      bool show_module,
                      bool show_inlined_frames,
-                     bool show_function_arguments) const;
+                     bool show_function_arguments,
+                     bool show_function_name) const;
 
     //------------------------------------------------------------------
     /// Get the address range contained within a symbol context.

source/API/SBInstruction.cpp

         // didn't have a stream already created, one will get created...
         FormatEntity::Entry format;
         FormatEntity::Parse("${addr}: ", format);
-        m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL, &sc, NULL, &format);
+        m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL, &sc, NULL, &format, 0);
         return true;
     }
     return false;

         StreamFile out_stream (out, false);
         FormatEntity::Entry format;
         FormatEntity::Parse("${addr}: ", format);
-        m_opaque_sp->Dump (&out_stream, 0, true, false, NULL, &sc, NULL, &format);
+        m_opaque_sp->Dump (&out_stream, 0, true, false, NULL, &sc, NULL, &format, 0);
     }
 }
 

source/API/SBInstructionList.cpp

                     module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, sc);
                 }
 
-                inst->Dump (&sref, max_opcode_byte_size, true, false, NULL, &sc, &prev_sc, &format);
+                inst->Dump (&sref, max_opcode_byte_size, true, false, NULL, &sc, &prev_sc, &format, 0);
                 sref.EOL();
             }
             return true;

source/Breakpoint/BreakpointLocation.cpp

                 s->PutCString ("re-exported target = ");
             else
                 s->PutCString("where = ");
-            sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false, true);
+            sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false, true, true);
         }
         else
         {

source/Commands/CommandObjectSource.cpp

                     bool show_module = true;
                     bool show_inlined_frames = true;
                     const bool show_function_arguments = true;
+                    const bool show_function_name = true;
                     sc.DumpStopContext(&result.GetOutputStream(),
                                        m_exe_ctx.GetBestExecutionContextScope(),
                                        sc.line_entry.range.GetBaseAddress(),
                                        show_fullpaths,
                                        show_module,
                                        show_inlined_frames,
-                                       show_function_arguments);
+                                       show_function_arguments,
+                                       show_function_name);
                     result.GetOutputStream().EOL();
 
                     if (m_options.num_lines == 0)

source/Core/Address.cpp

     case DumpStyleResolvedDescription:
     case DumpStyleResolvedDescriptionNoModule:
     case DumpStyleResolvedDescriptionNoFunctionArguments:
+    case DumpStyleNoFunctionName:
         if (IsSectionOffset())
         {
             uint32_t pointer_size = 4;

 #endif
                                     Address cstr_addr(*this);
                                     cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
-                                    func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false, true);
+                                    func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false, true, true);
                                     if (ReadAddress (exe_scope, cstr_addr, pointer_size, so_addr))
                                     {
 #if VERBOSE_OUTPUT

                                     if (pointer_sc.function || pointer_sc.symbol)
                                     {
                                         s->PutCString(": ");
-                                        pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false, true);
+                                        pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false, true, true);
                                     }
                                 }
                             }

                         const bool show_fullpaths = false; 
                         const bool show_inlined_frames = true;
                         const bool show_function_arguments = (style != DumpStyleResolvedDescriptionNoFunctionArguments);
+                        const bool show_function_name = (style != DumpStyleNoFunctionName);
                         if (sc.function == NULL && sc.symbol != NULL)
                         {
                             // If we have just a symbol make sure it is in the right section

                                                 show_fullpaths, 
                                                 show_module, 
                                                 show_inlined_frames,
-                                                show_function_arguments);
+                                                show_function_arguments,
+                                                show_function_name);
                         }
                         else
                         {

source/Core/Debugger.cpp

     FILE_AND_LINE\
     "\\n"
 
-#define DEFAULT_DISASSEMBLY_FORMAT "${current-pc-arrow}${addr-file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}: "
+// Three parts to this disassembly format specification:
+//   1. If this is a new function/symbol (no previous symbol/function), print
+//      dylib`funcname:\n
+//   2. If this is a symbol context change (different from previous symbol/function), print
+//      dylib`funcname:\n
+//   3. print 
+//      address <+offset>: 
+#define DEFAULT_DISASSEMBLY_FORMAT "{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}: "
 
+// gdb's disassembly format can be emulated with
+// ${current-pc-arrow}${addr-file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}: 
+
+// lldb's original format for disassembly would look like this format string -
+// {${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}: 
+
+
 static PropertyDefinition
 g_properties[] =
 {

source/Core/Disassembler.cpp

     }
     const uint32_t scope = eSymbolContextLineEntry | eSymbolContextFunction | eSymbolContextSymbol;
     const bool use_inline_block_range = false;
+
+    const FormatEntity::Entry *disassembly_format = NULL;
+    FormatEntity::Entry format;
+    if (exe_ctx.HasTargetScope())
+    {
+        disassembly_format = exe_ctx.GetTargetRef().GetDebugger().GetDisassemblyFormat ();
+    }
+    else
+    {
+        FormatEntity::Parse("${addr}: ", format);
+        disassembly_format = &format;
+    }
+
+    // First pass: step through the list of instructions, 
+    // find how long the initial addresses strings are, insert padding 
+    // in the second pass so the opcodes all line up nicely.
+    size_t address_text_size = 0;
     for (size_t i = 0; i < num_instructions_found; ++i)
     {
         Instruction *inst = disasm_ptr->GetInstructionList().GetInstructionAtIndex (i).get();
         if (inst)
         {
             const Address &addr = inst->GetAddress();
+            ModuleSP module_sp (addr.GetModule());
+            if (module_sp)
+            {
+                const uint32_t resolve_mask = eSymbolContextFunction | eSymbolContextSymbol;
+                uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
+                if (resolved_mask)
+                {
+                    StreamString strmstr;
+                    Debugger::FormatDisassemblerAddress (disassembly_format, &sc, NULL, &exe_ctx, &addr, strmstr);
+                    size_t cur_line = strmstr.GetSizeOfLastLine();
+                    if (cur_line > address_text_size)
+                        address_text_size = cur_line;
+                }
+                sc.Clear(false);
+            }
+        }
+    }
+
+    for (size_t i = 0; i < num_instructions_found; ++i)
+    {
+        Instruction *inst = disasm_ptr->GetInstructionList().GetInstructionAtIndex (i).get();
+        if (inst)
+        {
+            const Address &addr = inst->GetAddress();
             const bool inst_is_at_pc = pc_addr_ptr && addr == *pc_addr_ptr;
 
             prev_sc = sc;

                                 if (offset != 0)
                                     strm.EOL();
                                 
-                                sc.DumpStopContext(&strm, exe_ctx.GetProcessPtr(), addr, false, true, false, false);
+                                sc.DumpStopContext(&strm, exe_ctx.GetProcessPtr(), addr, false, true, false, false, true);
                                 strm.EOL();
                                 
                                 if (sc.comp_unit && sc.line_entry.IsValid())

             }
 
             const bool show_bytes = (options & eOptionShowBytes) != 0;
-            inst->Dump (&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc, &prev_sc, NULL);
+            inst->Dump (&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc, &prev_sc, NULL, address_text_size);
             strm.EOL();            
         }
         else

                    const ExecutionContext* exe_ctx,
                    const SymbolContext *sym_ctx,
                    const SymbolContext *prev_sym_ctx,
-                   const FormatEntity::Entry *disassembly_addr_format)
+                   const FormatEntity::Entry *disassembly_addr_format,
+                   size_t max_address_text_size)
 {
     size_t opcode_column_width = 7;
     const size_t operand_column_width = 25;

     if (show_address)
     {
         Debugger::FormatDisassemblerAddress (disassembly_addr_format, sym_ctx, prev_sym_ctx, exe_ctx, &m_address, ss);
+        ss.FillLastLineToColumn (max_address_text_size, ' ');
     }
     
     if (show_bytes)

     {
         if (pos != begin)
             s->EOL();
-        (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx, NULL, NULL, disassembly_format);
+        (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx, NULL, NULL, disassembly_format, 0);
     }
 }
 

source/Core/FormatEntity.cpp

     ENTRY ("addr-offset"         , FunctionAddrOffset     , UInt64),
     ENTRY ("concrete-only-addr-offset-no-padding", FunctionAddrOffsetConcrete, UInt64),
     ENTRY ("line-offset"         , FunctionLineOffset     , UInt64),
-    ENTRY ("pc-offset"           , FunctionPCOffset       , UInt64)
+    ENTRY ("pc-offset"           , FunctionPCOffset       , UInt64),
+    ENTRY ("initial-function"    , FunctionInitial        , None),
+    ENTRY ("changed"             , FunctionChanged        , None)
 };
 
 static FormatEntity::Entry::Definition g_line_child_entries[] =

     ENUM_TO_CSTR(FunctionAddrOffsetConcrete);
     ENUM_TO_CSTR(FunctionLineOffset);
     ENUM_TO_CSTR(FunctionPCOffset);
+    ENUM_TO_CSTR(FunctionInitial);
+    ENUM_TO_CSTR(FunctionChanged);
     ENUM_TO_CSTR(LineEntryFile);
     ENUM_TO_CSTR(LineEntryLineNumber);
     ENUM_TO_CSTR(LineEntryStartAddress);

                                const ExecutionContext *exe_ctx,
                                const Address &format_addr,
                                bool concrete_only,
-                               bool no_padding)
+                               bool no_padding,
+                               bool print_zero_offsets)
 {
     if (format_addr.IsValid())
     {

             {
                 addr_t func_file_addr = func_addr.GetFileAddress();
                 addr_t addr_file_addr = format_addr.GetFileAddress();
-                if (addr_file_addr > func_file_addr)
+                if (addr_file_addr > func_file_addr
+                    || (addr_file_addr == func_file_addr && print_zero_offsets))
+                {
                     s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding, addr_file_addr - func_file_addr);
+                }
                 else if (addr_file_addr < func_file_addr)
+                {
                     s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding, func_file_addr - addr_file_addr);
+                }
                 return true;
             }
             else

                 {
                     addr_t func_load_addr = func_addr.GetLoadAddress (target);
                     addr_t addr_load_addr = format_addr.GetLoadAddress (target);
-                    if (addr_load_addr > func_load_addr)
+                    if (addr_load_addr > func_load_addr
+                        || (addr_load_addr == func_load_addr && print_zero_offsets))
+                    {
                         s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding, addr_load_addr - func_load_addr);
+                    }
                     else if (addr_load_addr < func_load_addr)
+                    {
                         s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding, func_load_addr - addr_load_addr);
+                    }
                     return true;
                 }
             }

         case Entry::Type::FunctionAddrOffset:
             if (addr)
             {
-                if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, *addr, false, false))
+                if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, *addr, false, false, false))
                     return true;
             }
             return false;

         case Entry::Type::FunctionAddrOffsetConcrete:
             if (addr)
             {
-                if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, *addr, true, true))
+                if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, *addr, true, true, true))
                     return true;
             }
             return false;
 
         case Entry::Type::FunctionLineOffset:
-            if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, sc->line_entry.range.GetBaseAddress(), false, false))
+            if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, sc->line_entry.range.GetBaseAddress(), false, false, false))
                 return true;
             return false;
 

                 StackFrame *frame = exe_ctx->GetFramePtr();
                 if (frame)
                 {
-                    if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, frame->GetFrameCodeAddress(), false, false))
+                    if (DumpAddressOffsetFromFunction (s, sc, exe_ctx, frame->GetFrameCodeAddress(), false, false, false))
                         return true;
                 }
             }
             return false;
 
+        case Entry::Type::FunctionChanged:
+            return function_changed == true;
+
+        case Entry::Type::FunctionInitial:
+            return initial_function == true;
+
         case Entry::Type::LineEntryFile:
             if (sc && sc->line_entry.IsValid())
             {

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

             //std::string remove_this_prior_to_checkin;
             Target *target = m_exe_ctx ? m_exe_ctx->GetTargetPtr() : NULL;
             Address value_so_addr;
+            Address pc_so_addr;
             if (m_inst->UsingFileAddress())
             {
                 ModuleSP module_sp(m_inst->GetAddress().GetModule());
                 if (module_sp)
+                {
                     module_sp->ResolveFileAddress(value, value_so_addr);
+                    module_sp->ResolveFileAddress(pc, pc_so_addr);
+                }
             }
             else if (target && !target->GetSectionLoadList().IsEmpty())
             {
                 target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
+                target->GetSectionLoadList().ResolveLoadAddress(pc, pc_so_addr);
             }
 
+            SymbolContext sym_ctx;
+            const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
+            if (pc_so_addr.IsValid() && pc_so_addr.GetModule())
+            {
+                pc_so_addr.GetModule()->ResolveSymbolContextForAddress (pc_so_addr, resolve_scope, sym_ctx);
+            }
+
             if (value_so_addr.IsValid() && value_so_addr.GetSection())
             {
                 StreamString ss;
 
-                value_so_addr.Dump (&ss,
-                                    target,
-                                    Address::DumpStyleResolvedDescriptionNoFunctionArguments,
-                                    Address::DumpStyleSectionNameOffset);
+                bool format_omitting_current_func_name = false;
+                if (sym_ctx.symbol || sym_ctx.function)
+                {
+                    AddressRange range;
+                    if (sym_ctx.GetAddressRange (resolve_scope, 0, false, range) 
+                        && range.GetBaseAddress().IsValid() 
+                        && range.ContainsLoadAddress (value_so_addr, target))
+                    {
+                        format_omitting_current_func_name = true;
+                    }
+                }
+                
+                // If the "value" address (the target address we're symbolicating)
+                // is inside the same SymbolContext as the current instruction pc
+                // (pc_so_addr), don't print the full function name - just print it
+                // with DumpStyleNoFunctionName style, e.g. "<*+36>".
+                if (format_omitting_current_func_name)
+                {
+                    value_so_addr.Dump (&ss,
+                                        target,
+                                        Address::DumpStyleNoFunctionName,
+                                        Address::DumpStyleSectionNameOffset);
+                }
+                else
+                {
+                    value_so_addr.Dump (&ss,
+                                        target,
+                                        Address::DumpStyleResolvedDescriptionNoFunctionArguments,
+                                        Address::DumpStyleSectionNameOffset);
+                }
 
                 if (!ss.GetString().empty())
                 {

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

                             StreamString strm;
                             lldb_private::FormatEntity::Entry format;
                             FormatEntity::Parse("${frame.pc}: ", format);
-                            inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize (), show_address, show_bytes, NULL, NULL, NULL, &format);
+                            inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize (), show_address, show_bytes, NULL, NULL, NULL, &format, 0);
                             log->PutCString (strm.GetData());
                         }
 

source/Symbol/SymbolContext.cpp

 }
 
 bool
-SymbolContext::DumpStopContext
-(
+SymbolContext::DumpStopContext (
     Stream *s,
     ExecutionContextScope *exe_scope,
     const Address &addr,
     bool show_fullpaths,
     bool show_module,
     bool show_inlined_frames,
-    bool show_function_arguments
+    bool show_function_arguments,
+    bool show_function_name
 ) const
 {
     bool dumped_something = false;

     {
         SymbolContext inline_parent_sc;
         Address inline_parent_addr;
-        if (show_function_arguments == false && function->GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments))
+        if (show_function_name == false)
         {
+            s->Printf("<");
             dumped_something = true;
+        }
+        else if (show_function_arguments == false && function->GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments))
+        {
+            dumped_something = true;
             function->GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments).Dump(s);
         }
         else if (function->GetMangled().GetName())

         if (addr.IsValid())
         {
             const addr_t function_offset = addr.GetOffset() - function->GetAddressRange().GetBaseAddress().GetOffset();
-            if (function_offset)
+            if (show_function_name == false)
             {
+                // Print +offset even if offset is 0
                 dumped_something = true;
+                s->Printf("+%" PRIu64 ">", function_offset);
+            }
+            else if (function_offset)
+            {
+                dumped_something = true;
                 s->Printf(" + %" PRIu64, function_offset);
             }
         }

             {
                 s->EOL();
                 s->Indent();
-                return inline_parent_sc.DumpStopContext (s, exe_scope, inline_parent_addr, show_fullpaths, show_module, show_inlined_frames, show_function_arguments);
+                const bool show_function_name = true;
+                return inline_parent_sc.DumpStopContext (s, exe_scope, inline_parent_addr, show_fullpaths, show_module, show_inlined_frames, show_function_arguments, show_function_name);
             }
         }
         else

     }
     else if (symbol != nullptr)
     {
-        if (symbol->GetMangled().GetName())
+        if (show_function_name == false)
         {
+            s->Printf("<");
             dumped_something = true;
+        }
+        else if (symbol->GetMangled().GetName())
+        {
+            dumped_something = true;
             if (symbol->GetType() == eSymbolTypeTrampoline)
                 s->PutCString("symbol stub for: ");
             symbol->GetMangled().GetName().Dump(s);

         if (addr.IsValid() && symbol->ValueIsAddress())
         {
             const addr_t symbol_offset = addr.GetOffset() - symbol->GetAddress().GetOffset();
-            if (symbol_offset)
+            if (show_function_name == false)
             {
+                // Print +offset even if offset is 0
                 dumped_something = true;
+                s->Printf("+%" PRIu64 ">", symbol_offset);
+            }
+            else if (symbol_offset)
+            {
+                dumped_something = true;
                 s->Printf(" + %" PRIu64, symbol_offset);
             }
         }

source/Symbol/Variable.cpp

         sc.line_entry.Clear();
         bool show_inlined_frames = false;
         const bool show_function_arguments = true;
+        const bool show_function_name = true;
     
         dumped_declaration_info = sc.DumpStopContext (s, 
                                                       nullptr,

                                                       show_fullpaths, 
                                                       show_module, 
                                                       show_inlined_frames,
-                                                      show_function_arguments);
+                                                      show_function_arguments,
+                                                      show_function_name);
         
         if (sc.function)
             s->PutChar(':');

source/Target/StackFrame.cpp

     const bool show_module = true;
     const bool show_inline = true;
     const bool show_function_arguments = true;
+    const bool show_function_name = true;
     m_sc.DumpStopContext (strm, 
                           exe_ctx.GetBestExecutionContextScope(), 
                           GetFrameCodeAddress(), 
                           show_fullpaths, 
                           show_module, 
                           show_inline,
-                          show_function_arguments);
+                          show_function_arguments,
+                          show_function_name);
 }
 
 void

source/Target/ThreadPlanTracer.cpp

                                    NULL,
                                    NULL,
                                    NULL,
-                                   disassemble_format);
+                                   disassemble_format,
+                                   0);
             }
         }
     }

test/functionalities/abbreviation/TestAbbreviations.py

         # ARCH, if not specified, defaults to x86_64.
         if self.getArchitecture() in ["", 'x86_64', 'i386']:
             self.expect("dis -f",
-                        substrs = ['<sum(int, int)>:',
-                                   ' mov',
+                        startstr = "a.out`sum(int, int)",
+                        substrs = [' mov',
                                    ' addl ',
                                    'ret'])
 

test/functionalities/inferior-assert/TestInferiorAssert.py

             if frame.GetFrameID() == 0:
                 pc_backup_offset = 0
             self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset),
-                    substrs = ['<%s>:' % frame.GetFunctionName()])
+                    substrs = ['<+0>: '])
 
     def check_expr_in_main(self, thread):
         depth = thread.GetNumFrames()