[llvm-objdump] Display locations of variables alongside disassembly

[ostannard]

Summary

This adds the -debug-vars option to llvm-objdump, which prints locations (currently just registers, memory and more complex expressions will be added later) of source-level variables alongside the disassembly based on DWARF info. A vertical line is printed for each live-range, with a label at the top giving the variable name and location, and the position and length of the line indicating the program counter range in which it is valid.

[jhenderson]

llvm/tools/llvm-objdump/llvm-objdump.cpp

592

Function names should start with a lower-case letter, i.e. prettyPrintDWARFOps. Applies elsewhere too.

686

Coulmns -> Columns

I'd also rephrase slightly: "The columns we are currently drawing."

701

Why are you throwing away the error and not report an error or warning?

Add a comment if there's a valid reason not to report a message.

705

Please don't use auto here. I don't know what the type is. Also, is this able to be a const &?

707–709

File a bug for this FIXME against the getLocations method.

729

Too much auto. Should it be const &?

750–751

What's the / 2 and * 2 below about?

767

Too many blank lines. Have you clang-formatted?

771

I'd pull ~0U into a constant and/or use std::numeric_limits::max().

786

Too much auto. Should it be const &?

801

Canonical LLVM style is to precalculate the end value rather than on every iteration. Also applies below.

1090

It may be worth providing a "style" argument to the option that is able to specify a drawing style i.e. "ascii" or "box" or something like that. The formatting strings could then be configured based on that.

1110

Delete extra blank line.

1682

Too much auto. What is the type here?

[aprantl]

llvm/tools/llvm-objdump/llvm-objdump.cpp

577

My intent is to have a short comment here that explains to a future reader of the code what this class is used for. Using doxygen syntax /// allows IDEs to format them more nicely and show them in code outlines / indexes etc.

[ostannard]

Made the suggested changes in the code. However, after rebasing the DWARF5 tests are failing, as the location lists are being parsed incorrectly. I'll update the tests once I've figured out that's changed there.

[eugenis]

llvm/tools/llvm-objdump/llvm-objdump.cpp

642

To render DW_AT_frame_base for inlined subroutines, you'd need to trace up to the top-level one, or remember it while constructing LiveVariable(s).

Remove unused parameters?

[MaskRay]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1925

The destructor of formatted_raw_ostream is very slow.

We cannot declare formatted_raw_ostream in the loop body. The formatted_raw_ostream ctor resets the underlying stream (outs()) to unbuffered. This may introduce a 4x slowdown. I once had caused a slowdown here, which was fixed by D64969.

[ostannard]

• Made suggested changes to tests. I've enabled strict whitespace checking just for the one test in which we check compatibility with other options which affect the layout of the output, because the disassembly uses tabs in a way which doesn't always display well in text editors.
• getLocations now works correctly with -ffunction-sections, so removed the workaround
• Removed unused parameters related to DW_AT_frame_base
• Get endianness form the DWARFunit, no need to pass it around separately
• Don't create/destroy formatted_raw_ostream as often

[jhenderson]

Minor request, but could you please remember to mark my comments as "done" once you've uploaded a patch to address them. It helps me with my follow-ups.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1106 ↗

(On Diff #233388)

A comment explaining why we just throw away the error here woul be good.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

Ping? You have addressed this in this test?

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s

4–5

-no-show-raw-isn -> --no-show-raw-insn etc

15

You might want to consider another test case for --debug-vars-indent with the value equal to what it would be without the switch, testing against the same check-prefix. That will show what the default value of --debug-vars-indent is more clearly.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5-sections.s

2

--debug-vars

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5.s

2

--debug-vars

llvm/test/tools/llvm-objdump/PowerPC/debug-vars.s

2

--debug-vars

llvm/test/tools/llvm-symbolizer/frame-loclistx.s

1 ↗

(On Diff #233388)

This test seems unrelated?

[ostannard]

Sorry about that, I'd been marking comments as "done" as I went, but forgot to actually click "submit". I also accidentally included D70756 in the patch.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1106 ↗

(On Diff #233388)

This change is from D70756, included in this patch by mistake.

llvm/lib/Support/FormattedStream.cpp

40 ↗

(On Diff #232080)

I think we always use UTF-8 (or 7-bit ASCII) internally, so no need to guard this.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

I'm using sed to replace this string in debug-vars-dwarf4.s, where I'm testing the interaction with source and line number interleaving. I didn't think it would be worth testing that in every file, because the interactions are all in the formatting of the output, which is the same in each file.

llvm/test/tools/llvm-symbolizer/frame-loclistx.s

1 ↗

(On Diff #233388)

Another part of D70756 I included in the patch by mistake.

llvm/tools/llvm-objdump/llvm-objdump.cpp

707–709

This appears to have been fixed since I wrote this, so I've removed the workaround, and no ticket is needed.

750–751

I'll add a comment to explain.

[ostannard]

• Remove D70756 from patch
• Use -- style options in test comments

[jhenderson]

I think my only outstanding comment is about adding a style option to enable this to be used on terminals without unicode support (see also Michael Spencer's recent response on the RFC).

I haven't really looked at the details of the dwarf parsing or disassembly however. Others with more experience in those areas might be better placed to do so.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

Right, so just to clear things up for my own sanity: --debug-vars is not directly related to source interleaving in any way, right? It uses only the debug information in the object file, right?

[MaskRay]

GNU objdump will have this:

https://sourceware.org/ml/binutils/2020-01/msg00072.html RFC: Adding visualization of jumps to objdump's disassembly output

c6:	|  |     \----------> be 00 00 00 00       	mov    $0x0,%esi
cb:	|  |           /----> 48 8b 3d 00 00 00 00 	mov    0x0(%rip),%rdi        # d2 <main+0xd2>
d2:	|  |           |      31 c0                	xor    %eax,%eax
d4:	|  |           |  /-- e8 00 00 00 00       	callq  d9 <main+0xd9>
d9:	|  |           |  \-> bf 02 00 00 00       	mov    $0x2,%edi
de:	|  +-----------|----- e8 00 00 00 00       	callq  e3 <main+0xe3>
e3:	|  \-----------|----> 48 89 da             	mov    %rbx,%rdx
e6:	|              |      be 00 00 00 00       	mov    $0x0,%esi
eb:	|              \----- eb de                	jmp    cb <main+0xcb>
ed:	\-------------------> 48 8b 16             	mov    (%rsi),%rdx

(I'll try studying D70720 in the next few days.)

[ostannard]

Added ASCII output mode. It turns out that the unicode line drawing characters do work correctly on windows (at least windows 10, I don't have easy access to anything older to test with), I've left unicode as the default.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

Added a note to the comment at the top of the file.

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

136–139

This isn't quite the interface I'd use. I'd actually recommend making ASCII the default, since it will work in all situations, rather than requiring Windows users to specify an extra switch. If there's a good reason not to, I'd change this to --debug-vars-ascii, so that it's the normal practice of "use a switch to enable a behaviour" i.e. --debug-vars-unicode is all that is needed (and there's no need to do the slightly weird syntax of --debug-vars-unicode=false).

A third option (possibly in conjunction with the third) would be to change the switch name to --debug-vars-style, and allow it to take an enum of ASCII/Unicode (or more specifically UTF-8 probably). However, I don't think it's likely that we'll ever need more than two modes, so this is probably overkill.

My personal preference would be the first of the option, as I am primarily Windows developer, as are all of the developers I work with/make tools for.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

I'm not seeing any changes in the comments since the previous version?

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s

92

Will this ever be "\\"? The SRC_COMPDIR sed pattern explicitly uses '/' now.

llvm/tools/llvm-objdump/llvm-objdump.cpp

626

This seems unrelated?

854

Have you considered something like the following approach instead of this function (which you have to call every time you need to add a single character)?

1. Keep the enum, but assign the enum values all specific values from 0.
2. Create two constant char arrays, one with the Unicode version, and the other with the ASCII version of the characters.
3. Set some variable early (e.g. DbgVariableChars) to the value of one of the arrays, dependent on the style being used.
4. Use the chars by referencing the DbgVariableChars array, indexed by the enum, i.e. something like DbgVariableChars[RangeStart].

I'm not sure if it's simpler in practice or not, but it is at least worth considering.

863

Is this code tested anywhere? I couldn't find it when searching.

[ostannard]

llvm/docs/CommandGuide/llvm-objdump.rst

136–139

I've tested this on windows 10, and the unicode output displays correctly (in both cmd.exe and powershell). Is there some other version or configuration of windows in which this won't work? If ASCII is only needed for older versions of windows, I'd like to keep the default as unicode, because I find it much more legible than the ASCII version. There's also the option of making ASCII the default for windows and unicode elsewhere, but I'd rather avoid that if possible.

I do like the idea of switching the spelling to --debug-vars-ascii though.

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

58

Oops, missed a git-add.

llvm/tools/llvm-objdump/llvm-objdump.cpp

626

What do you mean? There are DWARF opcodes not handled by this function yet, we have to do something if we hit one, and printing the opcode will make adding the missing cases easier.

854

The unicode characters are each multiple bytes, so the indexes wouldn't match up between the two arrays. We could have to arrays of string literals, with one character in each literal, but I don't think that has any significant advantage over the switch statement.

863

This character only gets used when multiple live ranges start at the same assembly instruction. The example in M2 (more complex than the current tests) uses it twice - the first is a compiler bug, so I don't want to include it in a test, and the second requires printing multiple locations for parts of structs. I expect this to be tested properly when adding the struct location printing.

[ostannard]

• Rebase
• Change option spelling to --debug-vars-ascii (keep default as unicode)

[aprantl]

Would it be feasible to move the bulk of the implementation into lib/DebugInfo or some other more accessible place? I could imagine that this would be a neat feature for LLDB's disassemble command, for example.

[ostannard]

• Move DWARF expression printer into lib/DebugInfo/DWARF. I've left the LiveVariablePrinter class in llvm-objdump for now, because it's more tied into the rest of the disassembly loop (e.g. it needs to print after source line numbers). I'm not really sure what LLDB's requirements are here, but if we're going to move things to a library it might be worth moving more of the disassembly loop at the same time.

[aprantl]

In D70720#1859405, @ostannard wrote:

• Move DWARF expression printer into lib/DebugInfo/DWARF. I've left the LiveVariablePrinter class in llvm-objdump for now, because it's more tied into the rest of the disassembly loop (e.g. it needs to print after source line numbers). I'm not really sure what LLDB's requirements are here, but if we're going to move things to a library it might be worth moving more of the disassembly loop at the same time.

Agreed, this doesn't need to happen all at once.

llvm/tools/llvm-objdump/llvm-objdump.cpp

681

Minor nit: It's encouraged to always use Doxygen (///) comments even in local definitions, because many IDEs can understand them and then dispaly online help and format the comments nicely.

[ostannard]

• Doxygen style comments

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

134

I just tried this out locally, and on an already-wide window, a fairly basic expression wrapped with the default of 50 characters. Any particular reason you've used 50?

136–139

Thanks. Could you remove the "=<true|false>" bit from the description (you don't include it for --debug-vars after all...). Also replace "If true" with "If specified" and ". If false, use" with ", otherwise, use" and delete the "Defaults to false" sentence.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

125

skip_bytes -> skipBytes to match LLVM coding standards.

Also, use uint64_t instead of uint32_t, sine that's what the type of Op.EndOffset is.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

378–379

Would "in which case it will be implicitly dereferenced" make more sense?

Also I'd probably just get rid of the "which does not" bit.

440

Any particular reason you haven't just inlined the whole function here?

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s

7

Typo: diaplayed -> displayed

[ostannard]

• Remove skip_bytes function, not needed until later patch
• Reword comment in DWARFExpression
• Reduce default indent to 40 columns

llvm/docs/CommandGuide/llvm-objdump.rst

134

I picked that to be wide enough to avoid colliding with the disassembled instructions, except in cases where they include long symbol names. However, maybe it is a bit too high. I'll reduce it to 40, which still avoids collisions with a few samples of (ARM and AArch64) code I've tried, and avoids wrapping on an 80-column terminal with the --no-show-raw-insn option. I'd recommend using this with --no-show-raw-insn, especially on narrow terminals, because the disassembly alone ends at around column 65-70 without it, not leaving enough room for the variable display.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

125

I've removed this function, it's not needed until a later patch.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

440

The outlined version will be used by DW_OP_fbreg and DW_OP_entry_value, which need to print a sub-range of the expression. I could inline it here, but would have to revert that soon.

[jhenderson]

Looks good from my point of view, but probably warrants a second opinion.

[ostannard]

Setting back to "Request Review" because this is still waiting for a second reviewer.

[echristo]

Some nits and style/comment/readability requests. Generally pretty happy with how it looks though. And thanks James for the numerous rounds of reviews already! :)

llvm/docs/CommandGuide/llvm-objdump.rst

136–139

FWIW I'd have probably gone with --debug-vars=<encoding> ?

[echristo]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

149

printCompact maybe?

llvm/include/llvm/Support/FormattedStream.h

110 ↗

(On Diff #244371)

Comment what ComputePosition is doing here?

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

391

If you wouldn't mind commenting each of the cases with what's going on in them it'd be appreciated.

llvm/tools/llvm-objdump/llvm-objdump.cpp

612–614

Since this is going to get constructed with subsequent boolean arguments can we move them to enums/something? int, true, false, true isn't real obvious what it's constructing :)

729

Not a huge fan of boolean arguments. Is there a different factoring here that'll help?

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

136–139

FWIW I'd have probably gone with --debug-vars=<encoding> ?

I like this idea. Saves the need for two switches, and makes things nice and explicit about what encoding to use.

[MaskRay]

Needs a rebase after D74507. --debug-vars seems to work with an ET_REL, but does it work with an ET_DYN/ET_DYN?

[MaskRay]

llvm/tools/llvm-objdump/llvm-objdump.cpp

578

//

Internal classes should not use Doxygen comments.

674

Ideally unsigned TabStop = NoShowRawInsn ? 16 : 40 in printInst should be extracted as a function.

Is --no-leading-addr taken into account?

721

addCompileUnit

Looks like this function can be merged with addFunction().

729

No need to use /// . These classes are internal.

855

Change OS << " " to print one space unconditionally can simplify code above.

880

Change OS << " " to OS << ' ' unconditionally can avoid " " above.

1880

Does this harm performance when --debug-vars is not used?

I once caused a regression (fixed by D64969).

[ostannard]

does it work with an ET_DYN/ET_DYN?

Not currently, I'll investigate and fix that as a separate patch.

llvm/tools/llvm-objdump/llvm-objdump.cpp

578

@aprantl previously asked for these to be changed to doxygen. I don't see anything explicit about this in the coding standard, but apparently IDEs can make use of these.

612–614

This is only ever constructed with these all set to false, so I can remove them from the constructor, and use the member names explicitly when modifying them.

674

--no-leading-addr isn't taken into account, because it doesn't affect the column the instruction starts at.

721

I don't see how, given that it calls addFunction in two places.

729

It's not easy to factor out, because CheckedVarIdxs is defined in the first half then used in the second. However, I can rename it to better describe what it does.

1880

If I've understood that discussion properly, the performance problem was caused by creating a formatted_raw_ostream for each instruction, because it flushes the underlying stream in the constructor. Here, i'm creating one per disassembled function, so the overhead will be much lower.

[ostannard]

• Rebase
• Style fixes

[jhenderson]

llvm/tools/llvm-objdump/llvm-objdump.cpp

352

I don't have a strong opinion on this, but perhaps DVDisabled etc would be more in keeping with LLVM style?

622–624

Could you avoid the constructor entirely and initialise the values inline?

[ostannard]

• DV_Disabled -> DVDisabled
• Remove unneeded constructor

[jhenderson]

Latest changes look okay to me, but please wait for @echristo and @MaskRay to be happy.

[MaskRay]

llvm/include/llvm/Support/FormattedStream.h

108 ↗

(On Diff #246902)

The function name self documents. The comment may be unnecessary.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

386

There is certainly prior art. But if changing all SmallString<20> to SmallString<16> may decrease the code size?

llvm/lib/Support/FormattedStream.cpp

29 ↗

(On Diff #246902)

Ptr < End will be safer in -DLLVM_ENABLE_ASSERTIONS=off builds in case of a malformed UTF-8 code sequence.

33 ↗

(On Diff #246902)

The following might be slight simpler.

auto C = static_cast<unsigned char>(*Ptr);
if (C < 0x80) MultiByte = false;
else if (C >= 0b11110000) Ptr += 3;
else if (C >= 0b11100000) Ptr += 2;
else Ptr++;

45 ↗

(On Diff #246902)

This is incorrect due to East Asian Width.... http://www.unicode.org/reports/tr11/tr11-36.html

% cat a.cc
int main() {
  int 喵🙂 = 0;
  int 喵喵🙂 = 15;
  int 喵🙂喵🙂 = 24;
  喵🙂 = 28;
  喵喵🙂 = 32;
}
% clang -c a.cc
% llvm-objdump -S --no-show-raw-insn --debug-vars a.o

a.o:    file format elf64-x86-64


Disassembly of section .text:

0000000000000000 main:
; int main() {                                          ┠─ 喵🙂 = <unknown op DW_OP_fbreg (145)>
                                                        ┃ ┠─ 喵喵🙂 = <unknown op DW_OP_fbreg (145)> 
                                                        ┃ ┃ ┠─ 喵🙂喵🙂 = <unknown op DW_OP_fbreg (145)>
       0:       pushq   %rbp                            ┃ ┃ ┃     
       1:       movq    %rsp, %rbp                      ┃ ┃ ┃     
       4:       xorl    %eax, %eax                      ┃ ┃ ┃     
;   int 喵🙂 = 0;                                         ┃ ┃ ┃   
       6:       movl    $0, -4(%rbp)                    ┃ ┃ ┃     
;   int 喵喵🙂 = 15;                                       ┃ ┃ ┃   
       d:       movl    $15, -8(%rbp)                   ┃ ┃ ┃     
;   int 喵🙂喵🙂 = 24;                                      ┃ ┃ ┃   
      14:       movl    $24, -12(%rbp)                  ┃ ┃ ┃     
;   喵🙂 = 28;                                            ┃ ┃ ┃   
      1b:       movl    $28, -4(%rbp)                   ┃ ┃ ┃     
;   喵喵🙂 = 32;                                           ┃ ┃ ┃   
      22:       movl    $32, -8(%rbp)                   ┃ ┃ ┃     
; }                                                     ┃ ┃ ┃   
      29:       popq    %rbp                            ┃ ┃ ┃     
      2a:       retq                                    ┻ ┻ ┻

[ostannard]

llvm/lib/Support/FormattedStream.cpp

45 ↗

(On Diff #246902)

There's some code in the Support library which does this, which also simplifies this function a bit. It handles east asian characters correctly (at least the ones in your example), but doesn't get the correct widths for emojis. Clang seems to handle emojis by printing a hex value which it knows the length of:

$ /work/llvm/build/bin/clang -fsyntax-only -c width.c 
width.c:1:15: error: use of undeclared identifier 'a'
int 喵<U+1F642> = a;
                  ^
1 error generated.

Fixing that is going to be a lot of work, and isn't related to this patch, so I'll just make it work for characters supported by the existing unicode support library for now.

[ostannard]

• Align columns correctly after east asian wide characters (though not emojis)
• Other style changes

[jhenderson]

llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s

6–8

'##' for comments.

11

I think it will, but will this work on Windows (non-UTF8 environment)?

[ostannard]

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s

92

The SRC_COMPDIR sed script isn't used for the LINE-NUMS test (if it was we'd then need to regex out the whole path), so I've put this regex back.

llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s

11

It turns out that this doesn't work, at least in my windows 10 VM, so I'll disable this test for windows.

[ostannard]

• Disable wide-chars test on windows
• Fix the line-numbers test, which was broken on windows (different dir separator)

[jhenderson]

llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s

9

Nit: windows -> Windows

It might be wise to change "han" -> "'喵'" as I don't know what the "han" character is.

13

Nit: east asian -> East Asian

(I think)

[ostannard]

llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s

9

I was using "han character" meaning a Chinese, Japanese or Korean character, but it seems like "Chinese character" is a more common term, so I'll switch to that. I'd rather not use the character itself in a comment explaining that it might not render correctly on some systems!

[jhenderson]

Latest changes LGTM, but please wait for others to be happy too.

[echristo]

Couple of random comments, but feel free to fix and commit. I think anything else can be handled post-review.

Thanks!

-eric

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

393

You assume MRI isn't null so probably just make it a reference.

443

Since MRI is going to be a reference downstream probably want to make it a reference here.

[MaskRay]

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

14

After D75713, 00000000 <foo>:

You can now delete Disassembly of section .text.foo: and CHECK-EMPTY:

[MaskRay]

In the git description, it may be worth mentioning that ET_EXEC/ET_DYN are not supported yet.

llvm/lib/Support/FormattedStream.cpp

42 ↗

(On Diff #249572)

Delete excess braces.

[ostannard]

I forgot to restrict the new tests to only run when the relevant disassembler is built, should be fixed by rG161f70eae6cd and rG2878c6693875.

The tests are also failing on some windows bots with unicode errors, so I've disabled them on windows with rGf4cb9c919e28. These tests were passing locally in a Windows 10 VM, I'm not sure what is different about the buildbots.

[thakis]

I believe this breaks llvm/test/MC/ARM/lsl-zero.s on Windows.

The failure started here: http://lab.llvm.org:8011/builders/clang-x64-windows-msvc/builds/14810 This build has many changes, but this is the only arm-related one as far as I can tell.

It's still happening on trunk: http://lab.llvm.org:8011/builders/clang-x64-windows-msvc/builds/14816/steps/stage%201%20check/logs/stdio

Please take a look, and if it takes a while to investigate, please revert while you look.

[ostannard]

My reply by email doesn't seem to have made it into phab, so repeating here (sorry for spamming everyone who did get the email):

I'm not sure how this patch could have caused that failure. This isn't really an arm-related patch, that's just the architecture I happened to write most of the tests using.

Do you have access to that buildbot to get the actual output from the llvm-mc command?

[thakis]

Reverted (together with a surprisingly long list of related changes) for now in 9e48422035813b79088dfa4637e31cd836332a54.

When you reland, please leave some time between commits, so that if one should break something, it's clearer which commit is the problem. Most bots cycle time-based, not commit-based, so things that land in quick succession tend to end up in the same build, which makes things confusing.

[thakis]

Sorry, I didn't see that email. The revert did get that bot green, so it was due to this change.

I don't have easy access to that bot, no.

[thakis]

(And sorry, I started the revert seconds before you must've replied, so I didn't see your reply until after I had committed.)

[hoyFB]

llvm/include/llvm/Support/FormattedStream.h

108 ↗

(On Diff #250510)

Hello, looks like this change breaks the clang test: clang/test/Analysis/checker-plugins.c by changing the printing format

from:

example.MyChecker:ExampleOption                   (bool) This is an example checker opt. (default: false)

to:

example.MyChecker:ExampleOption                   (bool) This is an example checker opt. (default:
                                                                             false)

and the test fails at

// CHECK-CHECKER-OPTION-HELP: example.MyChecker:ExampleOption  (bool) This is an
// CHECK-CHECKER-OPTION-HELP-SAME: example checker opt. (default: false)

Can you please take a look? Thanks!

[benlangmuir]

llvm/lib/Support/FormattedStream.cpp

38 ↗

(On Diff #250510)

While it is probablye reasonable to expect only well-formed UTF-8 during the top-level call to write, this will fail for a buffered raw_ostream if you write a multi-byte sequence that happens to crosses the buffer end point. raw_ostream's buffering is byte-level, and won't prevent splitting a multibyte character. We saw this assertion failure in practice.

[ostannard]

@thakis, thanks for reverting, sorry I wasn't more proactive about that yesterday.

@hoyFB, it looks like I've accidentally fixed a bug where the help text wasn't being wrapped when the stdout isn't a TTY. I don't see anything in the code to suggest that this is intended behaviour, so I'll update the test.

@benlangmuir, thanks for the pointer, it looks like we'll need to save the first few bytes of truncated UTF-8 sequences when this happens so that we can calculate the display width once we have the rest of the bytes.

I'll split the formatted_raw_ostream changes out into a separate patch, and add some unit tests for these edge cases. I've still got no idea what the lsl-zero.s failure is about, but splitting the patch up should at least narrow it down.

[ostannard]

See D76291 for that split-put patch.

[MaskRay]

I think this is still in a reverted state (9e48422035813b79088dfa4637e31cd836332a54 ). --debug-vars is useful and I'd like to see it come back. Adding @dblaikie for some opinions.

[ostannard]

This was blocked on D76291 for a while, but that is now committed, so I'll re-land this today.

llvm/docs/CommandGuide/llvm-objdump.rst

.. option:: --arch-name=<string>
 
   Specify the target architecture when disassembling. Use :option:`--version`
   for a list of available targets.
 
 .. option:: -C, --demangle
 
   Demangle symbol names in the output.
 
+.. option:: --debug-vars=<format>
+
+  Print the locations (in registers or memory) of source-level variables
+  alongside disassembly. ``format`` may be ``unicode`` or ``ascii``, defaulting
+  to ``unicode`` if omitted.
+
+.. option:: --debug-vars-indent=<width>
+
+  Distance to indent the source-level variable display, relative to the start
+  of the disassembly. Defaults to 40 characters.
+
 .. option:: -j, --section=<section1[,section2,...]>
 
   Perform commands on the specified sections only. For Mach-O use
   `segment,section` to specify the section name.
 
 .. option:: -l, --line-numbers
 
   When disassembling, display source line numbers. Implies
   :option:`--disassemble`.
 
 .. option:: -M, --disassembler-options=<opt1[,opt2,...]>

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

public:
     class Operation &operator++() {
       Offset = Op.isError() ? Expr->Data.getData().size() : Op.EndOffset;
       Op.Error =
           Offset >= Expr->Data.getData().size() ||
           !Op.extract(Expr->Data, Expr->AddressSize, Offset, Expr->Format);
       return Op;
     }
 
     class Operation &operator*() {
       return Op;
     }
 
     // Comparison operators are provided out of line.
     friend bool operator==(const iterator &, const iterator &);
   };
 
   DWARFExpression(DataExtractor Data, uint8_t AddressSize,
                   Optional<dwarf::DwarfFormat> Format = None)
       : Data(Data), AddressSize(AddressSize), Format(Format) {
     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);
   }
 
   iterator begin() const { return iterator(this, 0); }
   iterator end() const { return iterator(this, Data.getData().size()); }
 
   void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U,
              bool IsEH = false) const;
 
+  /// Print the expression in a format intended to be compact and useful to a
+  /// user, but not perfectly unambiguous, or capable of representing every
+  /// valid DWARF expression. Returns true if the expression was sucessfully
+  /// printed.
+  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);
+
   bool verify(DWARFUnit *U);
 
 private:
   DataExtractor Data;
   uint8_t AddressSize;
   Optional<dwarf::DwarfFormat> Format;
 };
 

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

 bool DWARFExpression::verify(DWARFUnit *U) {
   for (auto &Op : *this)
     if (!Op.verify(U))
       return false;
 
   return true;
 }
 
+/// A user-facing string representation of a DWARF expression. This might be an
+/// Address expression, in which case it will be implicitly dereferenced, or a
+/// Value expression.
+struct PrintedExpr {
+  enum ExprKind {
+    Address,
+    Value,
+  };
+  ExprKind Kind;
+  SmallString<16> String;
+
+  PrintedExpr(ExprKind K = Address) : Kind(K) {}
+};
+
+static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I,
+                                  const DWARFExpression::iterator E,
+                                  const MCRegisterInfo &MRI) {
+  SmallVector<PrintedExpr, 4> Stack;
+
+  while (I != E) {
+    DWARFExpression::Operation &Op = *I;
+    uint8_t Opcode = Op.getCode();
+    switch (Opcode) {
+    case dwarf::DW_OP_regx: {
+      // DW_OP_regx: A register, with the register num given as an operand.
+      // Printed as the plain register name.
+      uint64_t DwarfRegNum = Op.getRawOperand(0);
+      Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);
+      if (!LLVMRegNum) {
+        OS << "<unknown register " << DwarfRegNum << ">";
+        return false;
+      }
+      raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
+      S << MRI.getName(*LLVMRegNum);
+      break;
+    }
+    default:
+      if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) {
+        // DW_OP_reg<N>: A register, with the register num implied by the
+        // opcode. Printed as the plain register name.
+        uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0;
+        Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);
+        if (!LLVMRegNum) {
+          OS << "<unknown register " << DwarfRegNum << ">";
+          return false;
+        }
+        raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
+        S << MRI.getName(*LLVMRegNum);
+      } else {
+        // If we hit an unknown operand, we don't know its effect on the stack,
+        // so bail out on the whole expression.
+        OS << "<unknown op " << dwarf::OperationEncodingString(Opcode) << " ("
+           << (int)Opcode << ")>";
+        return false;
+      }
+      break;
+    }
+    ++I;
+  }
+
+  assert(Stack.size() == 1 && "expected one value on stack");
+  OS << Stack.front().String;
+
+  return true;
+}
+
+bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) {
+  return printCompactDWARFExpr(OS, begin(), end(), MRI);
+}
+
 } // namespace llvm

llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c

+int foo(int a, int b, int c) {
+  int x = a + b;
+  int y = x + c;
+  return y;
+}
+
+int bar(int a) {
+  a++;
+  return a;
+}

llvm/test/tools/llvm-objdump/ARM/Inputs/wide-char.c

+int foo(int *喵) {
+  return *喵;
+}

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s

+## Check that the --debug-vars option works for simple register locations, when
+## using DWARF4 debug info, with functions in multiple sections.
+
+## Generated with this compile command, with the source code in Inputs/debug.c:
+## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-4 -S -o - -ffunction-sections
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn | \
+# RUN:     FileCheck %s
+
+# CHECK: Disassembly of section .text.foo:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000 <foo>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:                                                                   ┃ ┠─ b = R1
+# CHECK-NEXT:                                                                   ┃ ┃ ┠─ c = R2
+# CHECK-NEXT:                                                                   ┃ ┃ ┃ ┌─ x = R0
+# CHECK-NEXT:        0:       add     r0, r1, r0                                ┻ ┃ ┃ ╈
+# CHECK-NEXT:                                                                   ┌─ y = R0
+# CHECK-NEXT:        4:       add     r0, r0, r2                                ╈ ┃ ┃ ┻
+# CHECK-NEXT:        8:       bx      lr                                        ┻ ┻ ┻
+# CHECK-EMPTY:
+# CHECK-NEXT: Disassembly of section .text.bar:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000 <bar>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:        0:       add     r0, r0, #1                                ┃
+# CHECK-NEXT:        4:       bx      lr                                        ┻
+
+  .text
+  .syntax unified
+  .eabi_attribute 67, "2.09"
+  .eabi_attribute 6, 10
+  .eabi_attribute 7, 65
+  .eabi_attribute 8, 1
+  .eabi_attribute 9, 2
+  .fpu  neon
+  .eabi_attribute 34, 0
+  .eabi_attribute 17, 1
+  .eabi_attribute 20, 1
+  .eabi_attribute 21, 1
+  .eabi_attribute 23, 3
+  .eabi_attribute 24, 1
+  .eabi_attribute 25, 1
+  .eabi_attribute 38, 1
+  .eabi_attribute 18, 4
+  .eabi_attribute 26, 2
+  .eabi_attribute 14, 0
+  .file "debug.c"
+  .section  .text.foo,"ax",%progbits
+  .globl  foo
+  .p2align  2
+  .type foo,%function
+  .code 32
+foo:
+.Lfunc_begin0:
+  .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c"
+  .loc  1 1 0
+  .fnstart
+  .cfi_sections .debug_frame
+  .cfi_startproc
+  .loc  1 2 13 prologue_end
+  add r0, r1, r0
+.Ltmp0:
+  .loc  1 3 13
+  add r0, r0, r2
+.Ltmp1:
+  .loc  1 4 3
+  bx  lr
+.Ltmp2:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .text.bar,"ax",%progbits
+  .globl  bar
+  .p2align  2
+  .type bar,%function
+  .code 32
+bar:
+.Lfunc_begin1:
+  .loc  1 7 0
+  .fnstart
+  .cfi_startproc
+  .loc  1 8 4 prologue_end
+  add r0, r0, #1
+.Ltmp3:
+  .loc  1 9 3
+  bx  lr
+.Ltmp4:
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-bar
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .debug_str,"MS",%progbits,1
+.Linfo_string0:
+  .asciz  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+.Linfo_string1:
+  .asciz  "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c"
+.Linfo_string2:
+  .asciz  "/work/scratch"
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "int"
+.Linfo_string5:
+  .asciz  "bar"
+.Linfo_string6:
+  .asciz  "a"
+.Linfo_string7:
+  .asciz  "b"
+.Linfo_string8:
+  .asciz  "c"
+.Linfo_string9:
+  .asciz  "x"
+.Linfo_string10:
+  .asciz  "y"
+  .section  .debug_loc,"",%progbits
+.Ldebug_loc0:
+  .long -1
+  .long .Lfunc_begin0
+  .long .Lfunc_begin0-.Lfunc_begin0
+  .long .Ltmp0-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+.Ldebug_loc1:
+  .long -1
+  .long .Lfunc_begin0
+  .long .Ltmp0-.Lfunc_begin0
+  .long .Ltmp1-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+.Ldebug_loc2:
+  .long -1
+  .long .Lfunc_begin0
+  .long .Ltmp1-.Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+  .section  .debug_abbrev,"",%progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 14
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 14
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 14
+  .byte 17
+  .byte 1
+  .byte 85
+  .byte 23
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 46
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .ascii  "\227B"
+  .byte 25
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 39
+  .byte 25
+  .byte 73
+  .byte 19
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 23
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 24
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 5
+  .byte 52
+  .byte 0
+  .byte 2
+  .byte 23
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 6
+  .byte 36
+  .byte 0
+  .byte 3
+  .byte 14
+  .byte 62
+  .byte 11
+  .byte 11
+  .byte 11
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",%progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0
+.Ldebug_info_start0:
+  .short  4
+  .long .debug_abbrev
+  .byte 4
+  .byte 1
+  .long .Linfo_string0
+  .short  12
+  .long .Linfo_string1
+  .long .Lline_table_start0
+  .long .Linfo_string2
+  .long 0
+  .long .Ldebug_ranges0
+  .byte 2
+  .long .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 91
+
+  .long .Linfo_string3
+  .byte 1
+  .byte 1
+
+  .long 166
+
+  .byte 3
+  .long .Ldebug_loc0
+  .long .Linfo_string6
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 4
+  .byte 1
+  .byte 81
+  .long .Linfo_string7
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 4
+  .byte 1
+  .byte 82
+  .long .Linfo_string8
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 5
+  .long .Ldebug_loc1
+  .long .Linfo_string9
+  .byte 1
+  .byte 2
+  .long 166
+  .byte 5
+  .long .Ldebug_loc2
+  .long .Linfo_string10
+  .byte 1
+  .byte 3
+  .long 166
+  .byte 0
+  .byte 2
+  .long .Lfunc_begin1
+  .long .Lfunc_end1-.Lfunc_begin1
+  .byte 1
+  .byte 91
+
+  .long .Linfo_string5
+  .byte 1
+  .byte 7
+
+  .long 166
+
+  .byte 4
+  .byte 1
+  .byte 80
+  .long .Linfo_string6
+  .byte 1
+  .byte 7
+  .long 166
+  .byte 0
+  .byte 6
+  .long .Linfo_string4
+  .byte 5
+  .byte 4
+  .byte 0
+.Ldebug_info_end0:
+  .section  .debug_ranges,"",%progbits
+.Ldebug_ranges0:
+  .long .Lfunc_begin0
+  .long .Lfunc_end0
+  .long .Lfunc_begin1
+  .long .Lfunc_end1
+  .long 0
+  .long 0
+  .ident  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+  .section  ".note.GNU-stack","",%progbits
+  .addrsig
+  .eabi_attribute 30, 1
+  .section  .debug_line,"",%progbits
+.Lline_table_start0:

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s

+## Check that the --debug-vars option works for simple register locations, when
+## using DWARF4 debug info, with multiple functions in one section. Check that
+## the live-range lines are rendered correctly when using the --no-show-raw-insn,
+## --line-numbers and --source options. These do not affect the DWARF parsing
+## used by --debug-vars, but do add extra lines or columns to the output, so we
+## test to make sure the live ranges are still displayed correctly.
+
+## Generated with this compile command, with the source code in Inputs/debug.c:
+## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-4 -S -o -
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars | \
+# RUN:     FileCheck %s --check-prefix=RAW --strict-whitespace
+
+## Check that passing the default value for --debug-vars-indent (40) makes no
+## change to the output.
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --debug-vars-indent=40 | \
+# RUN:     FileCheck %s --check-prefix=RAW --strict-whitespace
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --debug-vars-indent=30 | \
+# RUN:     FileCheck %s --check-prefix=INDENT --strict-whitespace
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn | \
+# RUN:     FileCheck %s --check-prefix=NO-RAW --strict-whitespace
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn --line-numbers | \
+# RUN:     FileCheck %s --check-prefix=LINE-NUMS --strict-whitespace
+
+# RUN: mkdir -p %t/a
+# RUN: cp %p/Inputs/debug.c %t/a/debug.c
+# RUN: sed -e "s,SRC_COMPDIR,%/t/a,g" %s > %t.s
+# RUN: llvm-mc -triple armv8a--none-eabi < %t.s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn --source | \
+# RUN:     FileCheck %s --check-prefix=SOURCE --strict-whitespace
+
+## An optional argument to the --debug-vars= option can be used to switch
+## between unicode and ascii output (with unicode being the default).
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars=unicode | \
+# RUN:     FileCheck %s --check-prefix=RAW --strict-whitespace
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars=ascii | \
+# RUN:     FileCheck %s --check-prefix=ASCII --strict-whitespace
+
+## Note that llvm-objdump emits tab characters in the disassembly, assuming an
+## 8-byte tab stop, so these might not look aligned in a text editor.
+
+# RAW: 00000000 <foo>:
+# RAW-NEXT:                                                                 ┠─ a = R0 
+# RAW-NEXT:                                                                 ┃ ┠─ b = R1 
+# RAW-NEXT:                                                                 ┃ ┃ ┠─ c = R2 
+# RAW-NEXT:                                                                 ┃ ┃ ┃ ┌─ x = R0 
+# RAW-NEXT:        0: 00 00 81 e0   add r0, r1, r0                      ┻ ┃ ┃ ╈   
+# RAW-NEXT:                                                                 ┌─ y = R0 
+# RAW-NEXT:        4: 02 00 80 e0   add r0, r0, r2                      ╈ ┃ ┃ ┻   
+# RAW-NEXT:        8: 1e ff 2f e1   bx  lr                              ┻ ┻ ┻     
+# RAW-EMPTY:
+# RAW-NEXT: 0000000c <bar>:
+# RAW-NEXT:                                                                 ┠─ a = R0 
+# RAW-NEXT:        c: 01 00 80 e2   add r0, r0, #1                      ┃         
+# RAW-NEXT:       10: 1e ff 2f e1   bx  lr                              ┻         
+
+
+# INDENT: 00000000 <foo>:
+# INDENT-NEXT:                                                       ┠─ a = R0 
+# INDENT-NEXT:                                                       ┃ ┠─ b = R1 
+# INDENT-NEXT:                                                       ┃ ┃ ┠─ c = R2 
+# INDENT-NEXT:                                                       ┃ ┃ ┃ ┌─ x = R0 
+# INDENT-NEXT:        0: 00 00 81 e0    add r0, r1, r0            ┻ ┃ ┃ ╈   
+# INDENT-NEXT:                                                       ┌─ y = R0 
+# INDENT-NEXT:        4: 02 00 80 e0    add r0, r0, r2            ╈ ┃ ┃ ┻   
+# INDENT-NEXT:        8: 1e ff 2f e1    bx  lr                    ┻ ┻ ┻     
+# INDENT-EMPTY:
+# INDENT-NEXT: 0000000c <bar>:
+# INDENT-NEXT:                                                       ┠─ a = R0 
+# INDENT-NEXT:        c: 01 00 80 e2    add r0, r0, #1            ┃         
+# INDENT-NEXT:       10: 1e ff 2f e1    bx  lr                    ┻         
+
+# NO-RAW: 00000000 <foo>:
+# NO-RAW-NEXT:                                                         ┠─ a = R0
+# NO-RAW-NEXT:                                                         ┃ ┠─ b = R1
+# NO-RAW-NEXT:                                                         ┃ ┃ ┠─ c = R2
+# NO-RAW-NEXT:                                                         ┃ ┃ ┃ ┌─ x = R0
+# NO-RAW-NEXT:        0:        add r0, r1, r0                      ┻ ┃ ┃ ╈
+# NO-RAW-NEXT:                                                         ┌─ y = R0
+# NO-RAW-NEXT:        4:        add r0, r0, r2                      ╈ ┃ ┃ ┻
+# NO-RAW-NEXT:        8:        bx  lr                              ┻ ┻ ┻
+# NO-RAW-EMPTY:
+# NO-RAW-NEXT: 0000000c <bar>:
+# NO-RAW-NEXT:                                                         ┠─ a = R0
+# NO-RAW-NEXT:        c:        add r0, r0, #1                      ┃
+# NO-RAW-NEXT:       10:        bx  lr                              ┻
+
+# LINE-NUMS: 00000000 <foo>:
+# LINE-NUMS-NEXT: ; foo():
+# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:2                                 ┠─ a = R0
+# LINE-NUMS-NEXT:                                                         ┃ ┠─ b = R1
+# LINE-NUMS-NEXT:                                                         ┃ ┃ ┠─ c = R2
+# LINE-NUMS-NEXT:                                                         ┃ ┃ ┃ ┌─ x = R0
+# LINE-NUMS-NEXT:        0:       add r0, r1, r0                      ┻ ┃ ┃ ╈
+# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:3                                 ┌─ y = R0
+# LINE-NUMS-NEXT:        4:       add r0, r0, r2                      ╈ ┃ ┃ ┻
+# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:4                                 ┃ ┃ ┃
+# LINE-NUMS-NEXT:        8:       bx  lr                              ┻ ┻ ┻
+# LINE-NUMS-EMPTY:
+# LINE-NUMS-NEXT: 0000000c <bar>:
+# LINE-NUMS-NEXT: ; bar():
+# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:8                                 ┠─ a = R0
+# LINE-NUMS-NEXT:        c:       add r0, r0, #1                      ┃
+# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:9                                 ┃
+# LINE-NUMS-NEXT:       10:       bx  lr                              ┻
+
+# SOURCE: 00000000 <foo>:
+# SOURCE-NEXT: ;   int x = a + b;                                      ┠─ a = R0
+# SOURCE-NEXT:                                                         ┃ ┠─ b = R1
+# SOURCE-NEXT:                                                         ┃ ┃ ┠─ c = R2
+# SOURCE-NEXT:                                                         ┃ ┃ ┃ ┌─ x = R0
+# SOURCE-NEXT:        0:        add r0, r1, r0                      ┻ ┃ ┃ ╈
+# SOURCE-NEXT: ;   int y = x + c;                                      ┌─ y = R0
+# SOURCE-NEXT:        4:        add r0, r0, r2                      ╈ ┃ ┃ ┻
+# SOURCE-NEXT: ;   return y;                                           ┃ ┃ ┃
+# SOURCE-NEXT:        8:        bx  lr                              ┻ ┻ ┻
+# SOURCE-EMPTY:
+# SOURCE-NEXT: 0000000c <bar>:
+# SOURCE-NEXT: ;   a++;                                                ┠─ a = R0
+# SOURCE-NEXT:        c:        add r0, r0, #1                      ┃
+# SOURCE-NEXT: ;   return a;                                           ┃
+# SOURCE-NEXT:       10:        bx  lr                              ┻
+
+# ASCII: 00000000 <foo>:
+# ASCII-NEXT:                                                                 |- a = R0 
+# ASCII-NEXT:                                                                 | |- b = R1 
+# ASCII-NEXT:                                                                 | | |- c = R2 
+# ASCII-NEXT:                                                                 | | | /- x = R0 
+# ASCII-NEXT:        0: 00 00 81 e0   add r0, r1, r0                      v | | ^   
+# ASCII-NEXT:                                                                 /- y = R0 
+# ASCII-NEXT:        4: 02 00 80 e0   add r0, r0, r2                      ^ | | v   
+# ASCII-NEXT:        8: 1e ff 2f e1   bx  lr                              v v v     
+# ASCII-EMPTY:
+# ASCII-NEXT: 0000000c <bar>:
+# ASCII-NEXT:                                                                 |- a = R0 
+# ASCII-NEXT:        c: 01 00 80 e2   add r0, r0, #1                      |         
+# ASCII-NEXT:       10: 1e ff 2f e1   bx  lr                              v         
+
+  .text
+  .syntax unified
+  .eabi_attribute 67, "2.09"
+  .eabi_attribute 6, 10
+  .eabi_attribute 7, 65
+  .eabi_attribute 8, 1
+  .eabi_attribute 9, 2
+  .fpu  neon
+  .eabi_attribute 34, 0
+  .eabi_attribute 17, 1
+  .eabi_attribute 20, 1
+  .eabi_attribute 21, 1
+  .eabi_attribute 23, 3
+  .eabi_attribute 24, 1
+  .eabi_attribute 25, 1
+  .eabi_attribute 38, 1
+  .eabi_attribute 18, 4
+  .eabi_attribute 26, 2
+  .eabi_attribute 14, 0
+  .file "debug.c"
+  .globl  foo
+  .p2align  2
+  .type foo,%function
+  .code 32
+foo:
+.Lfunc_begin0:
+  .file 1 "" "SRC_COMPDIR/debug.c"
+  .loc  1 1 0
+  .fnstart
+  .cfi_sections .debug_frame
+  .cfi_startproc
+  .loc  1 2 13 prologue_end
+  add r0, r1, r0
+.Ltmp0:
+  .loc  1 3 13
+  add r0, r0, r2
+.Ltmp1:
+  .loc  1 4 3
+  bx  lr
+.Ltmp2:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .globl  bar
+  .p2align  2
+  .type bar,%function
+  .code 32
+bar:
+.Lfunc_begin1:
+  .loc  1 7 0
+  .fnstart
+  .cfi_startproc
+  .loc  1 8 4 prologue_end
+  add r0, r0, #1
+.Ltmp3:
+  .loc  1 9 3
+  bx  lr
+.Ltmp4:
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-bar
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .debug_str,"MS",%progbits,1
+.Linfo_string0:
+  .asciz  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+.Linfo_string1:
+  .asciz  "SRC_COMPDIR/debug.c"
+.Linfo_string2:
+  .asciz  ""
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "int"
+.Linfo_string5:
+  .asciz  "bar"
+.Linfo_string6:
+  .asciz  "a"
+.Linfo_string7:
+  .asciz  "b"
+.Linfo_string8:
+  .asciz  "c"
+.Linfo_string9:
+  .asciz  "x"
+.Linfo_string10:
+  .asciz  "y"
+  .section  .debug_loc,"",%progbits
+.Ldebug_loc0:
+  .long .Lfunc_begin0-.Lfunc_begin0
+  .long .Ltmp0-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+.Ldebug_loc1:
+  .long .Ltmp0-.Lfunc_begin0
+  .long .Ltmp1-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+.Ldebug_loc2:
+  .long .Ltmp1-.Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+  .section  .debug_abbrev,"",%progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 14
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 14
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 14
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 46
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .ascii  "\227B"
+  .byte 25
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 39
+  .byte 25
+  .byte 73
+  .byte 19
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 23
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 24
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 5
+  .byte 52
+  .byte 0
+  .byte 2
+  .byte 23
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 6
+  .byte 36
+  .byte 0
+  .byte 3
+  .byte 14
+  .byte 62
+  .byte 11
+  .byte 11
+  .byte 11
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",%progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0
+.Ldebug_info_start0:
+  .short  4
+  .long .debug_abbrev
+  .byte 4
+  .byte 1
+  .long .Linfo_string0
+  .short  12
+  .long .Linfo_string1
+  .long .Lline_table_start0
+  .long .Linfo_string2
+  .long .Lfunc_begin0
+  .long .Lfunc_end1-.Lfunc_begin0
+  .byte 2
+  .long .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 91
+
+  .long .Linfo_string3
+  .byte 1
+  .byte 1
+
+  .long 166
+
+  .byte 3
+  .long .Ldebug_loc0
+  .long .Linfo_string6
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 4
+  .byte 1
+  .byte 81
+  .long .Linfo_string7
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 4
+  .byte 1
+  .byte 82
+  .long .Linfo_string8
+  .byte 1
+  .byte 1
+  .long 166
+  .byte 5
+  .long .Ldebug_loc1
+  .long .Linfo_string9
+  .byte 1
+  .byte 2
+  .long 166
+  .byte 5
+  .long .Ldebug_loc2
+  .long .Linfo_string10
+  .byte 1
+  .byte 3
+  .long 166
+  .byte 0
+  .byte 2
+  .long .Lfunc_begin1
+  .long .Lfunc_end1-.Lfunc_begin1
+  .byte 1
+  .byte 91
+
+  .long .Linfo_string5
+  .byte 1
+  .byte 7
+
+  .long 166
+
+  .byte 4
+  .byte 1
+  .byte 80
+  .long .Linfo_string6
+  .byte 1
+  .byte 7
+  .long 166
+  .byte 0
+  .byte 6
+  .long .Linfo_string4
+  .byte 5
+  .byte 4
+  .byte 0
+.Ldebug_info_end0:
+  .ident  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+  .section  ".note.GNU-stack","",%progbits
+  .addrsig
+  .eabi_attribute 30, 1
+  .section  .debug_line,"",%progbits
+.Lline_table_start0:

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5-sections.s

+## Check that the --debug-vars option works for simple register locations, when
+## using DWARF4 debug info, with functions in multiple sections.
+
+## Generated with this compile command, with the source code in Inputs/debug.c:
+## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-5 -S -o - -ffunction-sections
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj --dwarf-version=5 | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn | \
+# RUN:     FileCheck %s
+
+# CHECK: Disassembly of section .text.foo:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000 <foo>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:                                                                   ┃ ┠─ b = R1
+# CHECK-NEXT:                                                                   ┃ ┃ ┠─ c = R2
+# CHECK-NEXT:                                                                   ┃ ┃ ┃ ┌─ x = R0
+# CHECK-NEXT:        0:       add     r0, r1, r0                                ┻ ┃ ┃ ╈
+# CHECK-NEXT:                                                                   ┌─ y = R0
+# CHECK-NEXT:        4:       add     r0, r0, r2                                ╈ ┃ ┃ ┻
+# CHECK-NEXT:        8:       bx      lr                                        ┻ ┻ ┻
+# CHECK-EMPTY:
+# CHECK-NEXT: Disassembly of section .text.bar:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000 <bar>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:        0:       add     r0, r0, #1                                ┃
+# CHECK-NEXT:        4:       bx      lr                                        ┻
+
+  .text
+  .syntax unified
+  .eabi_attribute 67, "2.09"
+  .eabi_attribute 6, 10
+  .eabi_attribute 7, 65
+  .eabi_attribute 8, 1
+  .eabi_attribute 9, 2
+  .fpu  neon
+  .eabi_attribute 34, 0
+  .eabi_attribute 17, 1
+  .eabi_attribute 20, 1
+  .eabi_attribute 21, 1
+  .eabi_attribute 23, 3
+  .eabi_attribute 24, 1
+  .eabi_attribute 25, 1
+  .eabi_attribute 38, 1
+  .eabi_attribute 18, 4
+  .eabi_attribute 26, 2
+  .eabi_attribute 14, 0
+  .file "debug.c"
+  .section  .text.foo,"ax",%progbits
+  .globl  foo
+  .p2align  2
+  .type foo,%function
+  .code 32
+foo:
+.Lfunc_begin0:
+  .file  0 "/work/scratch" "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e
+  .file  1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e
+  .loc  1 1 0
+  .fnstart
+  .cfi_sections .debug_frame
+  .cfi_startproc
+  .loc  1 2 13 prologue_end
+  add r0, r1, r0
+.Ltmp0:
+  .loc  1 3 13
+  add r0, r0, r2
+.Ltmp1:
+  .loc  1 4 3
+  bx  lr
+.Ltmp2:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .text.bar,"ax",%progbits
+  .globl  bar
+  .p2align  2
+  .type bar,%function
+  .code 32
+bar:
+.Lfunc_begin1:
+  .loc  1 7 0
+  .fnstart
+  .cfi_startproc
+  .loc  1 8 4 prologue_end
+  add r0, r0, #1
+.Ltmp3:
+  .loc  1 9 3
+  bx  lr
+.Ltmp4:
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-bar
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .debug_str_offsets,"",%progbits
+  .long 48
+  .short  5
+  .short  0
+.Lstr_offsets_base0:
+  .section  .debug_str,"MS",%progbits,1
+.Linfo_string0:
+  .asciz  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+.Linfo_string1:
+  .asciz  "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c"
+.Linfo_string2:
+  .asciz  "/work/scratch"
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "int"
+.Linfo_string5:
+  .asciz  "bar"
+.Linfo_string6:
+  .asciz  "a"
+.Linfo_string7:
+  .asciz  "b"
+.Linfo_string8:
+  .asciz  "c"
+.Linfo_string9:
+  .asciz  "x"
+.Linfo_string10:
+  .asciz  "y"
+  .section  .debug_str_offsets,"",%progbits
+  .long .Linfo_string0
+  .long .Linfo_string1
+  .long .Linfo_string2
+  .long .Linfo_string3
+  .long .Linfo_string4
+  .long .Linfo_string5
+  .long .Linfo_string6
+  .long .Linfo_string7
+  .long .Linfo_string8
+  .long .Linfo_string9
+  .long .Linfo_string10
+  .section  .debug_loclists,"",%progbits
+  .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0
+.Ldebug_loclist_table_start0:
+  .short  5
+  .byte 4
+  .byte 0
+  .long 3
+.Lloclists_table_base0:
+  .long .Ldebug_loc0-.Lloclists_table_base0
+  .long .Ldebug_loc1-.Lloclists_table_base0
+  .long .Ldebug_loc2-.Lloclists_table_base0
+.Ldebug_loc0:
+  .byte 3
+  .byte 0
+  .uleb128 .Ltmp0-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loc1:
+  .byte 1
+  .byte 0
+  .byte 4
+  .uleb128 .Ltmp0-.Lfunc_begin0
+  .uleb128 .Ltmp1-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loc2:
+  .byte 1
+  .byte 0
+  .byte 4
+  .uleb128 .Ltmp1-.Lfunc_begin0
+  .uleb128 .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loclist_table_end0:
+  .section  .debug_abbrev,"",%progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 37
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 37
+  .byte 114
+  .byte 23
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 37
+  .byte 17
+  .byte 1
+  .byte 85
+  .byte 35
+  .byte 115
+  .byte 23
+  .byte 116
+  .byte 23
+  .ascii  "\214\001"
+  .byte 23
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 46
+  .byte 1
+  .byte 17
+  .byte 27
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .byte 122
+  .byte 25
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 39
+  .byte 25
+  .byte 73
+  .byte 19
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 34
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 24
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 5
+  .byte 52
+  .byte 0
+  .byte 2
+  .byte 34
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 6
+  .byte 36
+  .byte 0
+  .byte 3
+  .byte 37
+  .byte 62
+  .byte 11
+  .byte 11
+  .byte 11
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",%progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0
+.Ldebug_info_start0:
+  .short  5
+  .byte 1
+  .byte 4
+  .long .debug_abbrev
+  .byte 1
+  .byte 0
+  .short  12
+  .byte 1
+  .long .Lstr_offsets_base0
+  .long .Lline_table_start0
+  .byte 2
+  .long 0
+  .byte 0
+  .long .Laddr_table_base0
+  .long .Lrnglists_table_base0
+  .long .Lloclists_table_base0
+  .byte 2
+  .byte 0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 91
+
+  .byte 3
+  .byte 1
+  .byte 1
+
+  .long 132
+
+  .byte 3
+  .byte 0
+  .byte 6
+  .byte 1
+  .byte 1
+  .long 132
+  .byte 4
+  .byte 1
+  .byte 81
+  .byte 7
+  .byte 1
+  .byte 1
+  .long 132
+  .byte 4
+  .byte 1
+  .byte 82
+  .byte 8
+  .byte 1
+  .byte 1
+  .long 132
+  .byte 5
+  .byte 1
+  .byte 9
+  .byte 1
+  .byte 2
+  .long 132
+  .byte 5
+  .byte 2
+  .byte 10
+  .byte 1
+  .byte 3
+  .long 132
+  .byte 0
+  .byte 2
+  .byte 1
+  .long .Lfunc_end1-.Lfunc_begin1
+  .byte 1
+  .byte 91
+
+  .byte 5
+  .byte 1
+  .byte 7
+
+  .long 132
+
+  .byte 4
+  .byte 1
+  .byte 80
+  .byte 6
+  .byte 1
+  .byte 7
+  .long 132
+  .byte 0
+  .byte 6
+  .byte 4
+  .byte 5
+  .byte 4
+  .byte 0
+.Ldebug_info_end0:
+  .section  .debug_rnglists,"",%progbits
+  .long .Ldebug_rnglist_table_end0-.Ldebug_rnglist_table_start0
+.Ldebug_rnglist_table_start0:
+  .short  5
+  .byte 4
+  .byte 0
+  .long 1
+.Lrnglists_table_base0:
+  .long .Ldebug_ranges0-.Lrnglists_table_base0
+.Ldebug_ranges0:
+  .byte 3
+  .byte 0
+  .uleb128 .Lfunc_end0-.Lfunc_begin0
+  .byte 3
+  .byte 1
+  .uleb128 .Lfunc_end1-.Lfunc_begin1
+  .byte 0
+.Ldebug_rnglist_table_end0:
+  .section  .debug_addr,"",%progbits
+  .long .Ldebug_addr_end0-.Ldebug_addr_start0
+.Ldebug_addr_start0:
+  .short  5
+  .byte 4
+  .byte 0
+.Laddr_table_base0:
+  .long .Lfunc_begin0
+  .long .Lfunc_begin1
+.Ldebug_addr_end0:
+  .ident  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+  .section  ".note.GNU-stack","",%progbits
+  .addrsig
+  .eabi_attribute 30, 1
+  .section  .debug_line,"",%progbits
+.Lline_table_start0:

llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5.s

+## Check that the --debug-vars option works for simple register locations, when
+## using DWARF5 debug info, with multiple functions in one section.
+
+## Generated with this compile command, with the source code in Inputs/debug.c:
+## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-3 -S -o -
+
+# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj --dwarf-version=5 | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn | \
+# RUN:     FileCheck %s
+
+# CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
+# CHECK-NEXT: 00000000 <foo>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:                                                                   ┃ ┠─ b = R1
+# CHECK-NEXT:                                                                   ┃ ┃ ┠─ c = R2
+# CHECK-NEXT:                                                                   ┃ ┃ ┃ ┌─ x = R0
+# CHECK-NEXT:        0:       add     r0, r1, r0                                ┻ ┃ ┃ ╈
+# CHECK-NEXT:                                                                   ┌─ y = R0
+# CHECK-NEXT:        4:       add     r0, r0, r2                                ╈ ┃ ┃ ┻
+# CHECK-NEXT:        8:       bx      lr                                        ┻ ┻ ┻
+# CHECK-EMPTY:
+# CHECK-NEXT: 0000000c <bar>:
+# CHECK-NEXT:                                                                   ┠─ a = R0
+# CHECK-NEXT:        c:       add     r0, r0, #1                                ┃
+# CHECK-NEXT:       10:       bx      lr                                        ┻
+
+  .text
+  .syntax unified
+  .eabi_attribute 67, "2.09"
+  .eabi_attribute 6, 10
+  .eabi_attribute 7, 65
+  .eabi_attribute 8, 1
+  .eabi_attribute 9, 2
+  .fpu  neon
+  .eabi_attribute 34, 0
+  .eabi_attribute 17, 1
+  .eabi_attribute 20, 1
+  .eabi_attribute 21, 1
+  .eabi_attribute 23, 3
+  .eabi_attribute 24, 1
+  .eabi_attribute 25, 1
+  .eabi_attribute 38, 1
+  .eabi_attribute 18, 4
+  .eabi_attribute 26, 2
+  .eabi_attribute 14, 0
+  .file "debug.c"
+  .globl  foo
+  .p2align  2
+  .type foo,%function
+  .code 32
+foo:
+.Lfunc_begin0:
+  .file  0 "/work/scratch" "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e
+  .file  1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e
+  .loc  1 1 0
+  .fnstart
+  .cfi_sections .debug_frame
+  .cfi_startproc
+  .loc  1 2 13 prologue_end
+  add r0, r1, r0
+.Ltmp0:
+  .loc  1 3 13
+  add r0, r0, r2
+.Ltmp1:
+  .loc  1 4 3
+  bx  lr
+.Ltmp2:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .globl  bar
+  .p2align  2
+  .type bar,%function
+  .code 32
+bar:
+.Lfunc_begin1:
+  .loc  1 7 0
+  .fnstart
+  .cfi_startproc
+  .loc  1 8 4 prologue_end
+  add r0, r0, #1
+.Ltmp3:
+  .loc  1 9 3
+  bx  lr
+.Ltmp4:
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-bar
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .debug_str_offsets,"",%progbits
+  .long 48
+  .short  5
+  .short  0
+.Lstr_offsets_base0:
+  .section  .debug_str,"MS",%progbits,1
+.Linfo_string0:
+  .asciz  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+.Linfo_string1:
+  .asciz  "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c"
+.Linfo_string2:
+  .asciz  "/work/scratch"
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "int"
+.Linfo_string5:
+  .asciz  "bar"
+.Linfo_string6:
+  .asciz  "a"
+.Linfo_string7:
+  .asciz  "b"
+.Linfo_string8:
+  .asciz  "c"
+.Linfo_string9:
+  .asciz  "x"
+.Linfo_string10:
+  .asciz  "y"
+  .section  .debug_str_offsets,"",%progbits
+  .long .Linfo_string0
+  .long .Linfo_string1
+  .long .Linfo_string2
+  .long .Linfo_string3
+  .long .Linfo_string4
+  .long .Linfo_string5
+  .long .Linfo_string6
+  .long .Linfo_string7
+  .long .Linfo_string8
+  .long .Linfo_string9
+  .long .Linfo_string10
+  .section  .debug_loclists,"",%progbits
+  .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0
+.Ldebug_loclist_table_start0:
+  .short  5
+  .byte 4
+  .byte 0
+  .long 3
+.Lloclists_table_base0:
+  .long .Ldebug_loc0-.Lloclists_table_base0
+  .long .Ldebug_loc1-.Lloclists_table_base0
+  .long .Ldebug_loc2-.Lloclists_table_base0
+.Ldebug_loc0:
+  .byte 4
+  .uleb128 .Lfunc_begin0-.Lfunc_begin0
+  .uleb128 .Ltmp0-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loc1:
+  .byte 4
+  .uleb128 .Ltmp0-.Lfunc_begin0
+  .uleb128 .Ltmp1-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loc2:
+  .byte 4
+  .uleb128 .Ltmp1-.Lfunc_begin0
+  .uleb128 .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 80
+  .byte 0
+.Ldebug_loclist_table_end0:
+  .section  .debug_abbrev,"",%progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 37
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 37
+  .byte 114
+  .byte 23
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 37
+  .byte 17
+  .byte 27
+  .byte 18
+  .byte 6
+  .byte 115
+  .byte 23
+  .ascii  "\214\001"
+  .byte 23
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 46
+  .byte 1
+  .byte 17
+  .byte 27
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .byte 122
+  .byte 25
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 39
+  .byte 25
+  .byte 73
+  .byte 19
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 34
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 24
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 5
+  .byte 52
+  .byte 0
+  .byte 2
+  .byte 34
+  .byte 3
+  .byte 37
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 6
+  .byte 36
+  .byte 0
+  .byte 3
+  .byte 37
+  .byte 62
+  .byte 11
+  .byte 11
+  .byte 11
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",%progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0
+.Ldebug_info_start0:
+  .short  5
+  .byte 1
+  .byte 4
+  .long .debug_abbrev
+  .byte 1
+  .byte 0
+  .short  12
+  .byte 1
+  .long .Lstr_offsets_base0
+  .long .Lline_table_start0
+  .byte 2
+  .byte 0
+  .long .Lfunc_end1-.Lfunc_begin0
+  .long .Laddr_table_base0
+  .long .Lloclists_table_base0
+  .byte 2
+  .byte 0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 91
+
+  .byte 3
+  .byte 1
+  .byte 1
+
+  .long 128
+
+  .byte 3
+  .byte 0
+  .byte 6
+  .byte 1
+  .byte 1
+  .long 128
+  .byte 4
+  .byte 1
+  .byte 81
+  .byte 7
+  .byte 1
+  .byte 1
+  .long 128
+  .byte 4
+  .byte 1
+  .byte 82
+  .byte 8
+  .byte 1
+  .byte 1
+  .long 128
+  .byte 5
+  .byte 1
+  .byte 9
+  .byte 1
+  .byte 2
+  .long 128
+  .byte 5
+  .byte 2
+  .byte 10
+  .byte 1
+  .byte 3
+  .long 128
+  .byte 0
+  .byte 2
+  .byte 1
+  .long .Lfunc_end1-.Lfunc_begin1
+  .byte 1
+  .byte 91
+
+  .byte 5
+  .byte 1
+  .byte 7
+
+  .long 128
+
+  .byte 4
+  .byte 1
+  .byte 80
+  .byte 6
+  .byte 1
+  .byte 7
+  .long 128
+  .byte 0
+  .byte 6
+  .byte 4
+  .byte 5
+  .byte 4
+  .byte 0
+.Ldebug_info_end0:
+  .section  .debug_addr,"",%progbits
+  .long .Ldebug_addr_end0-.Ldebug_addr_start0
+.Ldebug_addr_start0:
+  .short  5
+  .byte 4
+  .byte 0
+.Laddr_table_base0:
+  .long .Lfunc_begin0
+  .long .Lfunc_begin1
+.Ldebug_addr_end0:
+  .ident  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+  .section  ".note.GNU-stack","",%progbits
+  .addrsig
+  .eabi_attribute 30, 1
+  .section  .debug_line,"",%progbits
+.Lline_table_start0:

llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s

+# RUN: mkdir -p %t/a
+# RUN: cp %p/Inputs/wide-char.c %t/a/wide-char.c
+# RUN: sed -e "s,SRC_COMPDIR,%/t/a,g" %s > %t.s
+# RUN: llvm-mc -triple armv8a--none-eabi < %t.s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --source | \
+# RUN:     FileCheck %s --strict-whitespace
+
+## The Chinese character in the source does not print correctly on Windows.
+# UNSUPPORTED: system-windows
+
+## Check that the --debug-vars option correctly aligns the variable display when
+## the source code (printed by the -S option) includes East Asian wide
+## characters.
+
+# CHECK: 00000000 <foo>:
+# CHECK-NEXT: ;   return *喵;                                                 ┠─ 喵 = R0
+# CHECK-NEXT:        0: 00 00 90 e5   ldr r0, [r0]                        ┻   
+# CHECK-NEXT:        4: 1e ff 2f e1   bx  lr                                  
+
+  .text
+  .syntax unified
+  .eabi_attribute 67, "2.09"
+  .eabi_attribute 6, 10
+  .eabi_attribute 7, 65
+  .eabi_attribute 8, 1
+  .eabi_attribute 9, 2
+  .fpu  vfpv3
+  .eabi_attribute 34, 0
+  .eabi_attribute 17, 1
+  .eabi_attribute 20, 1
+  .eabi_attribute 21, 1
+  .eabi_attribute 23, 3
+  .eabi_attribute 24, 1
+  .eabi_attribute 25, 1
+  .eabi_attribute 38, 1
+  .eabi_attribute 18, 4
+  .eabi_attribute 26, 2
+  .eabi_attribute 14, 0
+  .file "wide.c"
+  .globl  foo
+  .p2align  2
+  .type foo,%function
+  .code 32
+foo:
+.Lfunc_begin0:
+  .file 1 "SRC_COMPDIR/wide-char.c"
+  .loc  1 1 0
+  .fnstart
+  .cfi_sections .debug_frame
+  .cfi_startproc
+  .loc  1 2 10 prologue_end
+  ldr r0, [r0]
+.Ltmp0:
+  .loc  1 2 3 is_stmt 0
+  bx  lr
+.Ltmp1:
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-foo
+  .cfi_endproc
+  .cantunwind
+  .fnend
+
+  .section  .debug_str,"MS",%progbits,1
+.Linfo_string0:
+  .asciz  "clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)"
+.Linfo_string1:
+  .asciz  "wide-char.c"
+.Linfo_string2:
+  .asciz  "SRC_COMPDIR"
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "int"
+.Linfo_string5:
+  .asciz  "\345\226\265"
+  .section  .debug_loc,"",%progbits
+.Ldebug_loc0:
+  .long .Lfunc_begin0-.Lfunc_begin0
+  .long .Ltmp0-.Lfunc_begin0
+  .short  1
+  .byte 80
+  .long 0
+  .long 0
+  .section  .debug_abbrev,"",%progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 14
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 14
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 14
+  .ascii  "\264B"
+  .byte 25
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 46
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 39
+  .byte 25
+  .byte 73
+  .byte 19
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 5
+  .byte 0
+  .byte 2
+  .byte 23
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 36
+  .byte 0
+  .byte 3
+  .byte 14
+  .byte 62
+  .byte 11
+  .byte 11
+  .byte 11
+  .byte 0
+  .byte 0
+  .byte 5
+  .byte 15
+  .byte 0
+  .byte 73
+  .byte 19
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",%progbits
+.Lcu_begin0:
+  .long 84
+  .short  4
+  .long .debug_abbrev
+  .byte 4
+  .byte 1
+  .long .Linfo_string0
+  .short  12
+  .long .Linfo_string1
+  .long .Lline_table_start0
+  .long .Linfo_string2
+
+  .long .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 2
+  .long .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 91
+  .long .Linfo_string3
+  .byte 1
+  .byte 1
+
+  .long 75
+
+  .byte 3
+  .long .Ldebug_loc0
+  .long .Linfo_string5
+  .byte 1
+  .byte 1
+  .long 82
+  .byte 0
+  .byte 4
+  .long .Linfo_string4
+  .byte 5
+  .byte 4
+  .byte 5
+  .long 75
+  .byte 0
+  .section  .debug_ranges,"",%progbits
+  .section  .debug_macinfo,"",%progbits
+.Lcu_macro_begin0:
+  .byte 0
+  .section  .debug_pubnames,"",%progbits
+  .long .LpubNames_end0-.LpubNames_begin0
+.LpubNames_begin0:
+  .short  2
+  .long .Lcu_begin0
+  .long 88
+  .long 38
+  .asciz  "foo"
+  .long 0
+.LpubNames_end0:
+  .section  .debug_pubtypes,"",%progbits
+  .long .LpubTypes_end0-.LpubTypes_begin0
+.LpubTypes_begin0:
+  .short  2
+  .long .Lcu_begin0
+  .long 88
+  .long 75
+  .asciz  "int"
+  .long 0
+.LpubTypes_end0:
+
+  .ident  "clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)"
+  .section  ".note.GNU-stack","",%progbits
+  .eabi_attribute 30, 1
+  .section  .debug_line,"",%progbits
+.Lline_table_start0:

llvm/test/tools/llvm-objdump/PowerPC/debug-vars.s

+## Check that the --debug-vars option works for simple register locations, when
+## using DWARF4 debug info, with multiple functions in one section.
+
+## Generated with this compile command and source code:
+## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-3 -S -o -
+
+## clang --target=powerpc64-unknown-linux -c debug.c -O1 -S -o -
+
+## int foo(int a, int b, int c) {
+##   int x = a + b;
+##   int y = x + c;
+##   return y;
+## }
+##
+## int bar(int a) {
+##   a++;
+##   return a;
+## }
+
+# RUN: llvm-mc -triple powerpc64-unknown-linux < %s -filetype=obj | \
+# RUN:     llvm-objdump - -d --debug-vars --no-show-raw-insn | \
+# RUN:     FileCheck %s
+
+# CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
+# CHECK-NEXT: 0000000000000000 <.text>:
+# CHECK-NEXT:                                                                   ┠─ a = S3
+# CHECK-NEXT:                                                                   ┃ ┠─ b = S4
+# CHECK-NEXT:                                                                   ┃ ┃ ┠─ c = S5
+# CHECK-NEXT:                                                                   ┃ ┃ ┃ ┌─ x = S3
+# CHECK-NEXT:        0:       add 3, 4, 3                                       ┻ ┃ ┃ ╈
+# CHECK-NEXT:                                                                   ┌─ y = S3
+# CHECK-NEXT:        4:       add 3, 3, 5                                       ╈ ┃ ┃ ┻
+# CHECK-NEXT:        8:       extsw 3, 3                                        ┻ ┃ ┃
+# CHECK-NEXT:        c:       blr                                                 ┃ ┃
+# CHECK-NEXT:                 ...
+# CHECK-NEXT:                                                                   ┠─ a = S3
+# CHECK-NEXT:       1c:       addi 3, 3, 1                                      ┃
+# CHECK-NEXT:       20:       extsw 3, 3                                        ┻
+# CHECK-NEXT:       24:       blr
+# CHECK-NEXT:                 ...
+
+  .text
+  .file "debug.c"
+  .globl  foo                     # -- Begin function foo
+  .p2align  2
+  .type foo,@function
+  .section  .opd,"aw",@progbits
+foo:                                    # @foo
+  .p2align  3
+  .quad .Lfunc_begin0
+  .quad .TOC.@tocbase
+  .quad 0
+  .text
+.Lfunc_begin0:
+  .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c"
+  .loc  1 1 0                   # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:1:0
+  .cfi_sections .debug_frame
+  .cfi_startproc
+# %bb.0:                                # %entry
+  #DEBUG_VALUE: foo:a <- $x3
+  #DEBUG_VALUE: foo:a <- $r3
+  #DEBUG_VALUE: foo:b <- $x4
+  #DEBUG_VALUE: foo:b <- $x4
+  #DEBUG_VALUE: foo:b <- $r4
+  #DEBUG_VALUE: foo:c <- $x5
+  #DEBUG_VALUE: foo:c <- $x5
+  #DEBUG_VALUE: foo:c <- $r5
+  .loc  1 2 13 prologue_end     # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:2:13
+  add 3, 4, 3
+.Ltmp0:
+  #DEBUG_VALUE: foo:x <- $r3
+  .loc  1 3 13                  # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:3:13
+  add 3, 3, 5
+.Ltmp1:
+  #DEBUG_VALUE: foo:y <- $r3
+  .loc  1 4 3                   # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:4:3
+  extsw 3, 3
+.Ltmp2:
+  blr
+.Ltmp3:
+  .long 0
+  .quad 0
+.Lfunc_end0:
+  .size foo, .Lfunc_end0-.Lfunc_begin0
+  .cfi_endproc
+                                        # -- End function
+  .globl  bar                     # -- Begin function bar
+  .p2align  2
+  .type bar,@function
+  .section  .opd,"aw",@progbits
+bar:                                    # @bar
+  .p2align  3
+  .quad .Lfunc_begin1
+  .quad .TOC.@tocbase
+  .quad 0
+  .text
+.Lfunc_begin1:
+  .loc  1 7 0                   # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:7:0
+  .cfi_startproc
+# %bb.0:                                # %entry
+  #DEBUG_VALUE: bar:a <- $x3
+  #DEBUG_VALUE: bar:a <- $r3
+  .loc  1 8 4 prologue_end      # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:8:4
+  addi 3, 3, 1
+.Ltmp4:
+  #DEBUG_VALUE: bar:a <- $r3
+  .loc  1 9 3                   # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:9:3
+  extsw 3, 3
+.Ltmp5:
+  blr
+.Ltmp6:
+  .long 0
+  .quad 0
+.Lfunc_end1:
+  .size bar, .Lfunc_end1-.Lfunc_begin1
+  .cfi_endproc
+                                        # -- End function
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" # string offset=0
+.Linfo_string1:
+  .asciz  "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" # string offset=101
+.Linfo_string2:
+  .asciz  "/work/scratch"         # string offset=164
+.Linfo_string3:
+  .asciz  "foo"                   # string offset=178
+.Linfo_string4:
+  .asciz  "int"                   # string offset=182
+.Linfo_string5:
+  .asciz  "bar"                   # string offset=186
+.Linfo_string6:
+  .asciz  "a"                     # string offset=190
+.Linfo_string7:
+  .asciz  "b"                     # string offset=192
+.Linfo_string8:
+  .asciz  "c"                     # string offset=194
+.Linfo_string9:
+  .asciz  "x"                     # string offset=196
+.Linfo_string10:
+  .asciz  "y"                     # string offset=198
+  .section  .debug_loc,"",@progbits
+.Ldebug_loc0:
+  .quad .Lfunc_begin0-.Lfunc_begin0
+  .quad .Ltmp0-.Lfunc_begin0
+  .short  3                       # Loc expr size
+  .byte 144                     # super-register DW_OP_regx
+  .byte 179                     # 1203
+  .byte 9                       #
+  .quad 0
+  .quad 0
+.Ldebug_loc1:
+  .quad .Ltmp0-.Lfunc_begin0
+  .quad .Ltmp1-.Lfunc_begin0
+  .short  3                       # Loc expr size
+  .byte 144                     # super-register DW_OP_regx
+  .byte 179                     # 1203
+  .byte 9                       #
+  .quad 0
+  .quad 0
+.Ldebug_loc2:
+  .quad .Ltmp1-.Lfunc_begin0
+  .quad .Ltmp2-.Lfunc_begin0
+  .short  3                       # Loc expr size
+  .byte 144                     # super-register DW_OP_regx
+  .byte 179                     # 1203
+  .byte 9                       #
+  .quad 0
+  .quad 0
+.Ldebug_loc3:
+  .quad .Lfunc_begin1-.Lfunc_begin0
+  .quad .Ltmp5-.Lfunc_begin0
+  .short  3                       # Loc expr size
+  .byte 144                     # super-register DW_OP_regx
+  .byte 179                     # 1203
+  .byte 9                       #
+  .quad 0
+  .quad 0
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 14                      # DW_FORM_strp
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 14                      # DW_FORM_strp
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 2                       # Abbreviation Code
+  .byte 46                      # DW_TAG_subprogram
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 64                      # DW_AT_frame_base
+  .byte 24                      # DW_FORM_exprloc
+  .ascii  "\227B"                 # DW_AT_GNU_all_call_sites
+  .byte 25                      # DW_FORM_flag_present
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 39                      # DW_AT_prototyped
+  .byte 25                      # DW_FORM_flag_present
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 63                      # DW_AT_external
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 3                       # Abbreviation Code
+  .byte 5                       # DW_TAG_formal_parameter
+  .byte 0                       # DW_CHILDREN_no
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 4                       # Abbreviation Code
+  .byte 5                       # DW_TAG_formal_parameter
+  .byte 0                       # DW_CHILDREN_no
+  .byte 2                       # DW_AT_location
+  .byte 24                      # DW_FORM_exprloc
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 52                      # DW_TAG_variable
+  .byte 0                       # DW_CHILDREN_no
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 6                       # Abbreviation Code
+  .byte 36                      # DW_TAG_base_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 62                      # DW_AT_encoding
+  .byte 11                      # DW_FORM_data1
+  .byte 11                      # DW_AT_byte_size
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0xb5 DW_TAG_compile_unit
+  .long .Linfo_string0          # DW_AT_producer
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .long .Linfo_string2          # DW_AT_comp_dir
+  .quad .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 2                       # Abbrev [2] 0x2a:0x65 DW_TAG_subprogram
+  .quad .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 1                       # DW_AT_frame_base
+  .byte 81
+                                        # DW_AT_GNU_all_call_sites
+  .long .Linfo_string3          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+                                        # DW_AT_prototyped
+  .long 184                     # DW_AT_type
+                                        # DW_AT_external
+  .byte 3                       # Abbrev [3] 0x43:0xf DW_TAG_formal_parameter
+  .long .Ldebug_loc0            # DW_AT_location
+  .long .Linfo_string6          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 4                       # Abbrev [4] 0x52:0xf DW_TAG_formal_parameter
+  .byte 3                       # DW_AT_location
+  .byte 144
+  .ascii  "\264\t"
+  .long .Linfo_string7          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 4                       # Abbrev [4] 0x61:0xf DW_TAG_formal_parameter
+  .byte 3                       # DW_AT_location
+  .byte 144
+  .ascii  "\265\t"
+  .long .Linfo_string8          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 1                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 5                       # Abbrev [5] 0x70:0xf DW_TAG_variable
+  .long .Ldebug_loc1            # DW_AT_location
+  .long .Linfo_string9          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 2                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 5                       # Abbrev [5] 0x7f:0xf DW_TAG_variable
+  .long .Ldebug_loc2            # DW_AT_location
+  .long .Linfo_string10         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 3                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 0                       # End Of Children Mark
+  .byte 2                       # Abbrev [2] 0x8f:0x29 DW_TAG_subprogram
+  .quad .Lfunc_begin1           # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc
+  .byte 1                       # DW_AT_frame_base
+  .byte 81
+                                        # DW_AT_GNU_all_call_sites
+  .long .Linfo_string5          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 7                       # DW_AT_decl_line
+                                        # DW_AT_prototyped
+  .long 184                     # DW_AT_type
+                                        # DW_AT_external
+  .byte 3                       # Abbrev [3] 0xa8:0xf DW_TAG_formal_parameter
+  .long .Ldebug_loc3            # DW_AT_location
+  .long .Linfo_string6          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 7                       # DW_AT_decl_line
+  .long 184                     # DW_AT_type
+  .byte 0                       # End Of Children Mark
+  .byte 6                       # Abbrev [6] 0xb8:0x7 DW_TAG_base_type
+  .long .Linfo_string4          # DW_AT_name
+  .byte 5                       # DW_AT_encoding
+  .byte 4                       # DW_AT_byte_size
+  .byte 0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .ident  "clang version 10.0.0 ([e-mail]:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)"
+  .section  ".note.GNU-stack","",@progbits
+  .addrsig
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

llvm/tools/llvm-objdump/llvm-objdump.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm-objdump.h"
 #include "COFFDump.h"
 #include "ELFDump.h"
 #include "MachODump.h"
 #include "WasmDump.h"
 #include "XCOFFDump.h"
+#include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/FaultMaps.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"

 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
 #include <cstring>
 #include <system_error>
 #include <unordered_map>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;
 
+#define DEBUG_TYPE "objdump"
+
 static cl::OptionCategory ObjdumpCat("llvm-objdump Options");
 
 static cl::opt<uint64_t> AdjustVMA(
     "adjust-vma",
     cl::desc("Increase the displayed address by the specified offset"),
     cl::value_desc("offset"), cl::init(0), cl::cat(ObjdumpCat));
 
 static cl::opt<bool>
static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
                                  cl::NotHidden, cl::Grouping,
                                  cl::aliasopt(UnwindInfo));
 
 static cl::opt<bool>
     Wide("wide", cl::desc("Ignored for compatibility with GNU objdump"),
          cl::cat(ObjdumpCat));
 static cl::alias WideShort("w", cl::Grouping, cl::aliasopt(Wide));
 
+enum DebugVarsFormat {
+  DVDisabled,
+  DVUnicode,
+  DVASCII,
+};
+
+static cl::opt<DebugVarsFormat> DbgVariables(
+    "debug-vars", cl::init(DVDisabled),
+    cl::desc("Print the locations (in registers or memory) of "
+             "source-level variables alongside disassembly"),
+    cl::ValueOptional,
+    cl::values(clEnumValN(DVUnicode, "", "unicode"),
+               clEnumValN(DVUnicode, "unicode", "unicode"),
+               clEnumValN(DVASCII, "ascii", "unicode")),
+    cl::cat(ObjdumpCat));
+
+static cl::opt<int>
+    DbgIndent("debug-vars-indent", cl::init(40),
+              cl::desc("Distance to indent the source-level variable display, "
+                       "relative to the start of the disassembly"),
+              cl::cat(ObjdumpCat));
+
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 static StringSet<> DisasmSymbolSet;
 StringSet<> objdump::FoundSectionSet;
 static StringRef ToolName;
 
 namespace {
if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
         return true;
     }
   }
 
   return false;
 }
 
 namespace {
+
+/// Get the column at which we want to start printing the instruction
+/// disassembly, taking into account anything which appears to the left of it.
+unsigned getInstStartColumn(const MCSubtargetInfo &STI) {
+  return NoShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
+}
+
+/// Stores a single expression representing the location of a source-level
+/// variable, along with the PC range for which that expression is valid.
+struct LiveVariable {
+  DWARFLocationExpression LocExpr;
+  const char *VarName;
+  DWARFUnit *Unit;
+  const DWARFDie FuncDie;
+
+  LiveVariable(const DWARFLocationExpression &LocExpr, const char *VarName,
+               DWARFUnit *Unit, const DWARFDie FuncDie)
+      : LocExpr(LocExpr), VarName(VarName), Unit(Unit), FuncDie(FuncDie) {}
+
+  bool liveAtAddress(object::SectionedAddress Addr) {
+    if (LocExpr.Range == None)
+      return false;
+    return LocExpr.Range->SectionIndex == Addr.SectionIndex &&
+           LocExpr.Range->LowPC <= Addr.Address &&
+           LocExpr.Range->HighPC > Addr.Address;
+  }
+
+  void print(raw_ostream &OS, const MCRegisterInfo &MRI) const {
+    DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()},
+                       Unit->getContext().isLittleEndian(), 0);
+    DWARFExpression Expression(Data, Unit->getAddressByteSize());
+    Expression.printCompact(OS, MRI);
+  }
+};
+
+/// Helper class for printing source variable locations alongside disassembly.
+class LiveVariablePrinter {
+  // Information we want to track about one column in which we are printing a
+  // variable live range.
+  struct Column {
+    unsigned VarIdx = NullVarIdx;
+    bool LiveIn = false;
+    bool LiveOut = false;
+    bool MustDrawLabel  = false;
+
+    bool isActive() const { return VarIdx != NullVarIdx; }
+
+    static constexpr unsigned NullVarIdx = std::numeric_limits<unsigned>::max();
+  };
+
+  // All live variables we know about in the object/image file.
+  std::vector<LiveVariable> LiveVariables;
+
+  // The columns we are currently drawing.
+  IndexedMap<Column> ActiveCols;
+
+  const MCRegisterInfo &MRI;
+  const MCSubtargetInfo &STI;
+
+  void addVariable(DWARFDie FuncDie, DWARFDie VarDie) {
+    uint64_t FuncLowPC, FuncHighPC, SectionIndex;
+    FuncDie.getLowAndHighPC(FuncLowPC, FuncHighPC, SectionIndex);
+    const char *VarName = VarDie.getName(DINameKind::ShortName);
+    DWARFUnit *U = VarDie.getDwarfUnit();
+
+    Expected<DWARFLocationExpressionsVector> Locs =
+        VarDie.getLocations(dwarf::DW_AT_location);
+    if (!Locs) {
+      // If the variable doesn't have any locations, just ignore it. We don't
+      // report an error or warning here as that could be noisy on optimised
+      // code.
+      consumeError(Locs.takeError());
+      return;
+    }
+
+    for (const DWARFLocationExpression &LocExpr : *Locs) {
+      if (LocExpr.Range) {
+        LiveVariables.emplace_back(LocExpr, VarName, U, FuncDie);
+      } else {
+        // If the LocExpr does not have an associated range, it is valid for
+        // the whole of the function.
+        // TODO: technically it is not valid for any range covered by another
+        // LocExpr, does that happen in reality?
+        DWARFLocationExpression WholeFuncExpr{
+            DWARFAddressRange(FuncLowPC, FuncHighPC, SectionIndex),
+            LocExpr.Expr};
+        LiveVariables.emplace_back(WholeFuncExpr, VarName, U, FuncDie);
+      }
+    }
+  }
+
+  void addFunction(DWARFDie D) {
+    for (const DWARFDie &Child : D.children()) {
+      if (Child.getTag() == dwarf::DW_TAG_variable ||
+          Child.getTag() == dwarf::DW_TAG_formal_parameter)
+        addVariable(D, Child);
+      else
+        addFunction(Child);
+    }
+  }
+
+  // Get the column number (in characters) at which the first live variable
+  // line should be printed.
+  unsigned getIndentLevel() const {
+    return DbgIndent + getInstStartColumn(STI);
+  }
+
+  // Indent to the first live-range column to the right of the currently
+  // printed line, and return the index of that column.
+  // TODO: formatted_raw_ostream uses "column" to mean a number of characters
+  // since the last \n, and we use it to mean the number of slots in which we
+  // put live variable lines. Pick a less overloaded word.
+  unsigned moveToFirstVarColumn(formatted_raw_ostream &OS) {
+    // Logical column number: column zero is the first column we print in, each
+    // logical column is 2 physical columns wide.
+    unsigned FirstUnprintedLogicalColumn =
+        std::max((int)(OS.getColumn() - getIndentLevel() + 1) / 2, 0);
+    // Physical column number: the actual column number in characters, with
+    // zero being the left-most side of the screen.
+    unsigned FirstUnprintedPhysicalColumn =
+        getIndentLevel() + FirstUnprintedLogicalColumn * 2;
+
+    if (FirstUnprintedPhysicalColumn > OS.getColumn())
+      OS.PadToColumn(FirstUnprintedPhysicalColumn);
+
+    return FirstUnprintedLogicalColumn;
+  }
+
+  unsigned findFreeColumn() {
+    for (unsigned ColIdx = 0; ColIdx < ActiveCols.size(); ++ColIdx)
+      if (!ActiveCols[ColIdx].isActive())
+        return ColIdx;
+
+    size_t OldSize = ActiveCols.size();
+    ActiveCols.grow(std::max<size_t>(OldSize * 2, 1));
+    return OldSize;
+  }
+
+public:
+  LiveVariablePrinter(const MCRegisterInfo &MRI, const MCSubtargetInfo &STI)
+      : LiveVariables(), ActiveCols(Column()), MRI(MRI), STI(STI) {}
+
+  void dump() const {
+    for (const LiveVariable &LV : LiveVariables) {
+      dbgs() << LV.VarName << " @ " << LV.LocExpr.Range << ": ";
+      LV.print(dbgs(), MRI);
+      dbgs() << "\n";
+    }
+  }
+
+  void addCompileUnit(DWARFDie D) {
+    if (D.getTag() == dwarf::DW_TAG_subprogram)
+      addFunction(D);
+    else
+      for (const DWARFDie &Child : D.children())
+        addFunction(Child);
+  }
+
+  /// Update to match the state of the instruction between ThisAddr and
+  /// NextAddr. In the common case, any live range active at ThisAddr is
+  /// live-in to the instruction, and any live range active at NextAddr is
+  /// live-out of the instruction. If IncludeDefinedVars is false, then live
+  /// ranges starting at NextAddr will be ignored.
+  void update(object::SectionedAddress ThisAddr,
+              object::SectionedAddress NextAddr, bool IncludeDefinedVars) {
+    // First, check variables which have already been assigned a column, so
+    // that we don't change their order.
+    SmallSet<unsigned, 8> CheckedVarIdxs;
+    for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) {
+      if (!ActiveCols[ColIdx].isActive())
+        continue;
+      CheckedVarIdxs.insert(ActiveCols[ColIdx].VarIdx);
+      LiveVariable &LV = LiveVariables[ActiveCols[ColIdx].VarIdx];
+      ActiveCols[ColIdx].LiveIn = LV.liveAtAddress(ThisAddr);
+      ActiveCols[ColIdx].LiveOut = LV.liveAtAddress(NextAddr);
+      LLVM_DEBUG(dbgs() << "pass 1, " << ThisAddr.Address << "-"
+                        << NextAddr.Address << ", " << LV.VarName << ", Col "
+                        << ColIdx << ": LiveIn=" << ActiveCols[ColIdx].LiveIn
+                        << ", LiveOut=" << ActiveCols[ColIdx].LiveOut << "\n");
+
+      if (!ActiveCols[ColIdx].LiveIn && !ActiveCols[ColIdx].LiveOut)
+        ActiveCols[ColIdx].VarIdx = Column::NullVarIdx;
+    }
+
+    // Next, look for variables which don't already have a column, but which
+    // are now live.
+    if (IncludeDefinedVars) {
+      for (unsigned VarIdx = 0, End = LiveVariables.size(); VarIdx < End;
+           ++VarIdx) {
+        if (CheckedVarIdxs.count(VarIdx))
+          continue;
+        LiveVariable &LV = LiveVariables[VarIdx];
+        bool LiveIn = LV.liveAtAddress(ThisAddr);
+        bool LiveOut = LV.liveAtAddress(NextAddr);
+        if (!LiveIn && !LiveOut)
+          continue;
+
+        unsigned ColIdx = findFreeColumn();
+        LLVM_DEBUG(dbgs() << "pass 2, " << ThisAddr.Address << "-"
+                          << NextAddr.Address << ", " << LV.VarName << ", Col "
+                          << ColIdx << ": LiveIn=" << LiveIn
+                          << ", LiveOut=" << LiveOut << "\n");
+        ActiveCols[ColIdx].VarIdx = VarIdx;
+        ActiveCols[ColIdx].LiveIn = LiveIn;
+        ActiveCols[ColIdx].LiveOut = LiveOut;
+        ActiveCols[ColIdx].MustDrawLabel = true;
+      }
+    }
+  }
+
+  enum class LineChar {
+    RangeStart,
+    RangeMid,
+    RangeEnd,
+    LabelVert,
+    LabelCornerNew,
+    LabelCornerActive,
+    LabelHoriz,
+  };
+  const char *getLineChar(LineChar C) const {
+    bool IsASCII = DbgVariables == DVASCII;
+    switch (C) {
+    case LineChar::RangeStart:
+      return IsASCII ? "^" : u8"\u2548";
+    case LineChar::RangeMid:
+      return IsASCII ? "|" : u8"\u2503";
+    case LineChar::RangeEnd:
+      return IsASCII ? "v" : u8"\u253b";
+    case LineChar::LabelVert:
+      return IsASCII ? "|" : u8"\u2502";
+    case LineChar::LabelCornerNew:
+      return IsASCII ? "/" : u8"\u250c";
+    case LineChar::LabelCornerActive:
+      return IsASCII ? "|" : u8"\u2520";
+    case LineChar::LabelHoriz:
+      return IsASCII ? "-" : u8"\u2500";
+    }
+  }
+
+  /// Print live ranges to the right of an existing line. This assumes the
+  /// line is not an instruction, so doesn't start or end any live ranges, so
+  /// we only need to print active ranges or empty columns. If AfterInst is
+  /// true, this is being printed after the last instruction fed to update(),
+  /// otherwise this is being printed before it.
+  void printAfterOtherLine(formatted_raw_ostream &OS, bool AfterInst) {
+    if (ActiveCols.size()) {
+      unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
+      for (size_t ColIdx = FirstUnprintedColumn, End = ActiveCols.size();
+           ColIdx < End; ++ColIdx) {
+        if (ActiveCols[ColIdx].isActive()) {
+          if ((AfterInst && ActiveCols[ColIdx].LiveOut) ||
+              (!AfterInst && ActiveCols[ColIdx].LiveIn))
+            OS << getLineChar(LineChar::RangeMid);
+          else if (!AfterInst && ActiveCols[ColIdx].LiveOut)
+            OS << getLineChar(LineChar::LabelVert);
+          else
+            OS << " ";
+        }
+        OS << " ";
+      }
+    }
+    OS << "\n";
+  }
+
+  /// Print any live variable range info needed to the right of a
+  /// non-instruction line of disassembly. This is where we print the variable
+  /// names and expressions, with thin line-drawing characters connecting them
+  /// to the live range which starts at the next instruction. If MustPrint is
+  /// true, we have to print at least one line (with the continuation of any
+  /// already-active live ranges) because something has already been printed
+  /// earlier on this line.
+  void printBetweenInsts(formatted_raw_ostream &OS, bool MustPrint) {
+    bool PrintedSomething = false;
+    for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) {
+      if (ActiveCols[ColIdx].isActive() && ActiveCols[ColIdx].MustDrawLabel) {
+        // First we need to print the live range markers for any active
+        // columns to the left of this one.
+        OS.PadToColumn(getIndentLevel());
+        for (unsigned ColIdx2 = 0; ColIdx2 < ColIdx; ++ColIdx2) {
+          if (ActiveCols[ColIdx2].isActive()) {
+            if (ActiveCols[ColIdx2].MustDrawLabel &&
+                           !ActiveCols[ColIdx2].LiveIn)
+              OS << getLineChar(LineChar::LabelVert) << " ";
+            else
+              OS << getLineChar(LineChar::RangeMid) << " ";
+          } else
+            OS << "  ";
+        }
+
+        // Then print the variable name and location of the new live range,
+        // with box drawing characters joining it to the live range line.
+        OS << getLineChar(ActiveCols[ColIdx].LiveIn
+                              ? LineChar::LabelCornerActive
+                              : LineChar::LabelCornerNew)
+           << getLineChar(LineChar::LabelHoriz) << " ";
+        WithColor(OS, raw_ostream::GREEN)
+            << LiveVariables[ActiveCols[ColIdx].VarIdx].VarName;
+        OS << " = ";
+        {
+          WithColor ExprColor(OS, raw_ostream::CYAN);
+          LiveVariables[ActiveCols[ColIdx].VarIdx].print(OS, MRI);
+        }
+
+        // If there are any columns to the right of the expression we just
+        // printed, then continue their live range lines.
+        unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
+        for (unsigned ColIdx2 = FirstUnprintedColumn, End = ActiveCols.size();
+             ColIdx2 < End; ++ColIdx2) {
+          if (ActiveCols[ColIdx2].isActive() && ActiveCols[ColIdx2].LiveIn)
+            OS << getLineChar(LineChar::RangeMid) << " ";
+          else
+            OS << "  ";
+        }
+
+        OS << "\n";
+        PrintedSomething = true;
+      }
+    }
+
+    for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx)
+      if (ActiveCols[ColIdx].isActive())
+        ActiveCols[ColIdx].MustDrawLabel = false;
+
+    // If we must print something (because we printed a line/column number),
+    // but don't have any new variables to print, then print a line which
+    // just continues any existing live ranges.
+    if (MustPrint && !PrintedSomething)
+      printAfterOtherLine(OS, false);
+  }
+
+  /// Print the live variable ranges to the right of a disassembled instruction.
+  void printAfterInst(formatted_raw_ostream &OS) {
+    if (!ActiveCols.size())
+      return;
+    unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
+    for (unsigned ColIdx = FirstUnprintedColumn, End = ActiveCols.size();
+         ColIdx < End; ++ColIdx) {
+      if (!ActiveCols[ColIdx].isActive())
+        OS << "  ";
+      else if (ActiveCols[ColIdx].LiveIn && ActiveCols[ColIdx].LiveOut)
+        OS << getLineChar(LineChar::RangeMid) << " ";
+      else if (ActiveCols[ColIdx].LiveOut)
+        OS << getLineChar(LineChar::RangeStart) << " ";
+      else if (ActiveCols[ColIdx].LiveIn)
+        OS << getLineChar(LineChar::RangeEnd) << " ";
+      else
+        llvm_unreachable("var must be live in or out!");
+    }
+  }
+};
+
 class SourcePrinter {
 protected:
   DILineInfo OldLineInfo;
   const ObjectFile *Obj = nullptr;
   std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
   // File name to file contents of source.
   std::unordered_map<std::string, std::unique_ptr<MemoryBuffer>> SourceCache;
   // Mark the line endings of the cached source.
   std::unordered_map<std::string, std::vector<StringRef>> LineCache;
   // Keep track of missing sources.
   StringSet<> MissingSources;
   // Only emit 'no debug info' warning once.
   bool WarnedNoDebugInfo;
 
 private:
   bool cacheSource(const DILineInfo& LineInfoFile);
 
-  void printLines(raw_ostream &OS, const DILineInfo &LineInfo,
-                  StringRef Delimiter);
+  void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
+                  StringRef Delimiter, LiveVariablePrinter &LVP);
 
-  void printSources(raw_ostream &OS, const DILineInfo &LineInfo,
-                    StringRef ObjectFilename, StringRef Delimiter);
+  void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
+                    StringRef ObjectFilename, StringRef Delimiter,
+                    LiveVariablePrinter &LVP);
 
 public:
   SourcePrinter() = default;
   SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch)
       : Obj(Obj), WarnedNoDebugInfo(false) {
     symbolize::LLVMSymbolizer::Options SymbolizerOpts;
     SymbolizerOpts.PrintFunctions =
         DILineInfoSpecifier::FunctionNameKind::LinkageName;
     SymbolizerOpts.Demangle = Demangle;
     SymbolizerOpts.DefaultArch = std::string(DefaultArch);
     Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
   }
   virtual ~SourcePrinter() = default;
-  virtual void printSourceLine(raw_ostream &OS,
+  virtual void printSourceLine(formatted_raw_ostream &OS,
                                object::SectionedAddress Address,
                                StringRef ObjectFilename,
+                               LiveVariablePrinter &LVP,
                                StringRef Delimiter = "; ");
 };
 
 bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
   std::unique_ptr<MemoryBuffer> Buffer;
   if (LineInfo.Source) {
     Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
   } else {
bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
   const char *BufferStart = Buffer->getBufferStart(),
              *BufferEnd = Buffer->getBufferEnd();
   std::vector<StringRef> &Lines = LineCache[LineInfo.FileName];
   const char *Start = BufferStart;
   for (const char *I = BufferStart; I != BufferEnd; ++I)
     if (*I == '\n') {
       Lines.emplace_back(Start, I - Start - (BufferStart < I && I[-1] == '\r'));
       Start = I + 1;
     }
   if (Start < BufferEnd)
     Lines.emplace_back(Start, BufferEnd - Start);
   SourceCache[LineInfo.FileName] = std::move(Buffer);
   return true;
 }
 
-void SourcePrinter::printSourceLine(raw_ostream &OS,
+void SourcePrinter::printSourceLine(formatted_raw_ostream &OS,
                                     object::SectionedAddress Address,
                                     StringRef ObjectFilename,
+                                    LiveVariablePrinter &LVP,
                                     StringRef Delimiter) {
   if (!Symbolizer)
     return;
 
   DILineInfo LineInfo = DILineInfo();
   auto ExpectedLineInfo = Symbolizer->symbolizeCode(*Obj, Address);
   std::string ErrorMessage;
   if (!ExpectedLineInfo)
     ErrorMessage = toString(ExpectedLineInfo.takeError());
   else
     LineInfo = *ExpectedLineInfo;
 
   if (LineInfo.FileName == DILineInfo::BadString) {
     if (!WarnedNoDebugInfo) {
       std::string Warning =
           "failed to parse debug information for " + ObjectFilename.str();
       if (!ErrorMessage.empty())
         Warning += ": " + ErrorMessage;
       reportWarning(Warning, ObjectFilename);
       WarnedNoDebugInfo = true;
     }
   }
 
   if (PrintLines)
-    printLines(OS, LineInfo, Delimiter);
+    printLines(OS, LineInfo, Delimiter, LVP);
   if (PrintSource)
-    printSources(OS, LineInfo, ObjectFilename, Delimiter);
+    printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP);
   OldLineInfo = LineInfo;
 }
 
-void SourcePrinter::printLines(raw_ostream &OS, const DILineInfo &LineInfo,
-                               StringRef Delimiter) {
+void SourcePrinter::printLines(formatted_raw_ostream &OS,
+                               const DILineInfo &LineInfo, StringRef Delimiter,
+                               LiveVariablePrinter &LVP) {
   bool PrintFunctionName = LineInfo.FunctionName != DILineInfo::BadString &&
                            LineInfo.FunctionName != OldLineInfo.FunctionName;
   if (PrintFunctionName) {
     OS << Delimiter << LineInfo.FunctionName;
     // If demangling is successful, FunctionName will end with "()". Print it
     // only if demangling did not run or was unsuccessful.
     if (!StringRef(LineInfo.FunctionName).endswith("()"))
       OS << "()";
     OS << ":\n";
   }
   if (LineInfo.FileName != DILineInfo::BadString && LineInfo.Line != 0 &&
       (OldLineInfo.Line != LineInfo.Line ||
-       OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName))
-    OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line << "\n";
+       OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) {
+    OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line;
+    LVP.printBetweenInsts(OS, true);
+  }
 }
 
-void SourcePrinter::printSources(raw_ostream &OS, const DILineInfo &LineInfo,
-                                 StringRef ObjectFilename,
-                                 StringRef Delimiter) {
+void SourcePrinter::printSources(formatted_raw_ostream &OS,
+                                 const DILineInfo &LineInfo,
+                                 StringRef ObjectFilename, StringRef Delimiter,
+                                 LiveVariablePrinter &LVP) {
   if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 ||
       (OldLineInfo.Line == LineInfo.Line &&
        OldLineInfo.FileName == LineInfo.FileName))
     return;
 
   if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
     if (!cacheSource(LineInfo))
       return;
   auto LineBuffer = LineCache.find(LineInfo.FileName);
   if (LineBuffer != LineCache.end()) {
     if (LineInfo.Line > LineBuffer->second.size()) {
       reportWarning(
           formatv(
               "debug info line number {0} exceeds the number of lines in {1}",
               LineInfo.Line, LineInfo.FileName),
           ObjectFilename);
       return;
     }
     // Vector begins at 0, line numbers are non-zero
-    OS << Delimiter << LineBuffer->second[LineInfo.Line - 1] << '\n';
+    OS << Delimiter << LineBuffer->second[LineInfo.Line - 1];
+    LVP.printBetweenInsts(OS, true);
   }
 }
 
 static bool isAArch64Elf(const ObjectFile *Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
   return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
 }
 
 static bool isArmElf(const ObjectFile *Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
   return Elf && Elf->getEMachine() == ELF::EM_ARM;
 }
 
 static bool hasMappingSymbols(const ObjectFile *Obj) {
   return isArmElf(Obj) || isAArch64Elf(Obj);
 }
 
-static void printRelocation(StringRef FileName, const RelocationRef &Rel,
-                            uint64_t Address, bool Is64Bits) {
+static void printRelocation(formatted_raw_ostream &OS, StringRef FileName,
+                            const RelocationRef &Rel, uint64_t Address,
+                            bool Is64Bits) {
   StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64 ":  " : "\t\t\t%08" PRIx64 ":  ";
   SmallString<16> Name;
   SmallString<32> Val;
   Rel.getTypeName(Name);
   if (Error E = getRelocationValueString(Rel, Val))
     reportError(std::move(E), FileName);
-  outs() << format(Fmt.data(), Address) << Name << "\t" << Val << "\n";
+  OS << format(Fmt.data(), Address) << Name << "\t" << Val;
 }
 
 class PrettyPrinter {
 public:
   virtual ~PrettyPrinter() = default;
-  virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
-                         ArrayRef<uint8_t> Bytes,
-                         object::SectionedAddress Address, raw_ostream &OS,
-                         StringRef Annot, MCSubtargetInfo const &STI,
-                         SourcePrinter *SP, StringRef ObjectFilename,
-                         std::vector<RelocationRef> *Rels = nullptr) {
+  virtual void
+  printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
+            object::SectionedAddress Address, formatted_raw_ostream &OS,
+            StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
+            StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
+            LiveVariablePrinter &LVP) {
     if (SP && (PrintSource || PrintLines))
-      SP->printSourceLine(OS, Address, ObjectFilename);
+      SP->printSourceLine(OS, Address, ObjectFilename, LVP);
+    LVP.printBetweenInsts(OS, false);
 
     size_t Start = OS.tell();
     if (!NoLeadingAddr)
       OS << format("%8" PRIx64 ":", Address.Address);
     if (!NoShowRawInsn) {
       OS << ' ';
       dumpBytes(Bytes, OS);
     }
 
-    // The output of printInst starts with a tab. Print some spaces so that the
-    // tab has 1 column and advances to the target tab stop. Give more columns
-    // to x86 which may encode an instruction with many bytes.
-    unsigned TabStop =
-        NoShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
+    // The output of printInst starts with a tab. Print some spaces so that
+    // the tab has 1 column and advances to the target tab stop.
+    unsigned TabStop = getInstStartColumn(STI);
     unsigned Column = OS.tell() - Start;
     OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8);
 
     if (MI) {
       // See MCInstPrinter::printInst. On targets where a PC relative immediate
       // is relative to the next instruction and the length of a MCInst is
       // difficult to measure (x86), this is the address of the next
       // instruction.
       uint64_t Addr =
           Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0);
       IP.printInst(MI, Addr, "", STI, OS);
     } else
       OS << "\t<unknown>";
   }
 };
 PrettyPrinter PrettyPrinterInst;
 
 class HexagonPrettyPrinter : public PrettyPrinter {
 public:
   void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,
-                 raw_ostream &OS) {
+                 formatted_raw_ostream &OS) {
     uint32_t opcode =
       (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0];
     if (!NoLeadingAddr)
       OS << format("%8" PRIx64 ":", Address);
     if (!NoShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes.slice(0, 4), OS);
       OS << format("\t%08" PRIx32, opcode);
     }
   }
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 object::SectionedAddress Address, raw_ostream &OS,
+                 object::SectionedAddress Address, formatted_raw_ostream &OS,
                  StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
-                 StringRef ObjectFilename,
-                 std::vector<RelocationRef> *Rels) override {
+                 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
+                 LiveVariablePrinter &LVP) override {
     if (SP && (PrintSource || PrintLines))
-      SP->printSourceLine(OS, Address, ObjectFilename, "");
+      SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
     if (!MI) {
       printLead(Bytes, Address.Address, OS);
       OS << " <unknown>";
       return;
     }
     std::string Buffer;
     {
       raw_string_ostream TempStream(Buffer);
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
 
     // Hexagon's packets require relocations to be inline rather than
     // clustered at the end of the packet.
     std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
     std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
     auto PrintReloc = [&]() -> void {
       while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
         if (RelCur->getOffset() == Address.Address) {
-          printRelocation(ObjectFilename, *RelCur, Address.Address, false);
+          printRelocation(OS, ObjectFilename, *RelCur, Address.Address, false);
           return;
         }
         ++RelCur;
       }
     };
 
     while (!HeadTail.first.empty()) {
       OS << Separator;
       Separator = "\n";
       if (SP && (PrintSource || PrintLines))
-        SP->printSourceLine(OS, Address, ObjectFilename, "");
+        SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
       printLead(Bytes, Address.Address, OS);
       OS << Preamble;
       Preamble = "   ";
       StringRef Inst;
       auto Duplex = HeadTail.first.split('\v');
       if (!Duplex.second.empty()) {
         OS << Duplex.first;
         OS << "; ";
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
     }
   }
 };
 HexagonPrettyPrinter HexagonPrettyPrinterInst;
 
 class AMDGCNPrettyPrinter : public PrettyPrinter {
 public:
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 object::SectionedAddress Address, raw_ostream &OS,
+                 object::SectionedAddress Address, formatted_raw_ostream &OS,
                  StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
-                 StringRef ObjectFilename,
-                 std::vector<RelocationRef> *Rels) override {
+                 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
+                 LiveVariablePrinter &LVP) override {
     if (SP && (PrintSource || PrintLines))
-      SP->printSourceLine(OS, Address, ObjectFilename);
+      SP->printSourceLine(OS, Address, ObjectFilename, LVP);
 
     if (MI) {
       SmallString<40> InstStr;
       raw_svector_ostream IS(InstStr);
 
       IP.printInst(MI, Address.Address, "", STI, IS);
 
       OS << left_justify(IS.str(), 60);
if (!Annot.empty())
       OS << " // " << Annot;
   }
 };
 AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
 
 class BPFPrettyPrinter : public PrettyPrinter {
 public:
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
-                 object::SectionedAddress Address, raw_ostream &OS,
+                 object::SectionedAddress Address, formatted_raw_ostream &OS,
                  StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
-                 StringRef ObjectFilename,
-                 std::vector<RelocationRef> *Rels) override {
+                 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
+                 LiveVariablePrinter &LVP) override {
     if (SP && (PrintSource || PrintLines))
-      SP->printSourceLine(OS, Address, ObjectFilename);
+      SP->printSourceLine(OS, Address, ObjectFilename, LVP);
     if (!NoLeadingAddr)
       OS << format("%8" PRId64 ":", Address.Address / 8);
     if (!NoShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes, OS);
     }
     if (MI)
       IP.printInst(MI, Address.Address, "", STI, OS);
static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
   if (It == MappingSymbols.begin())
     return '\x00';
   return (It - 1)->second;
 }
 
 static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index,
                                uint64_t End, const ObjectFile *Obj,
                                ArrayRef<uint8_t> Bytes,
-                               ArrayRef<MappingSymbolPair> MappingSymbols) {
+                               ArrayRef<MappingSymbolPair> MappingSymbols,
+                               raw_ostream &OS) {
   support::endianness Endian =
       Obj->isLittleEndian() ? support::little : support::big;
-  outs() << format("%8" PRIx64 ":\t", SectionAddr + Index);
+  OS << format("%8" PRIx64 ":\t", SectionAddr + Index);
   if (Index + 4 <= End) {
-    dumpBytes(Bytes.slice(Index, 4), outs());
-    outs() << "\t.word\t"
+    dumpBytes(Bytes.slice(Index, 4), OS);
+    OS << "\t.word\t"
            << format_hex(support::endian::read32(Bytes.data() + Index, Endian),
                          10);
     return 4;
   }
   if (Index + 2 <= End) {
-    dumpBytes(Bytes.slice(Index, 2), outs());
-    outs() << "\t\t.short\t"
+    dumpBytes(Bytes.slice(Index, 2), OS);
+    OS << "\t\t.short\t"
            << format_hex(support::endian::read16(Bytes.data() + Index, Endian),
                          6);
     return 2;
   }
-  dumpBytes(Bytes.slice(Index, 1), outs());
-  outs() << "\t\t.byte\t" << format_hex(Bytes[0], 4);
+  dumpBytes(Bytes.slice(Index, 1), OS);
+  OS << "\t\t.byte\t" << format_hex(Bytes[0], 4);
   return 1;
 }
 
 static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
                         ArrayRef<uint8_t> Bytes) {
   // print out data up to 8 bytes at a time in hex and ascii
   uint8_t AsciiData[9] = {'\0'};
   uint8_t Byte;
if (NumBytes == 8) {
       outs() << std::string(IndentOffset, ' ') << "         ";
       outs() << reinterpret_cast<char *>(AsciiData);
       outs() << '\n';
       NumBytes = 0;
     }
   }
 }
 
 SymbolInfoTy objdump::createSymbolInfo(const ObjectFile *Obj,
                                        const SymbolRef &Symbol) {
   const StringRef FileName = Obj->getFileName();
   const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
   const StringRef Name = unwrapOrError(Symbol.getName(), FileName);
 
   if (Obj->isXCOFF() && SymbolDescription) {
     const auto *XCOFFObj = cast<XCOFFObjectFile>(Obj);
     DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl();
static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
   // Sort all the symbols, this allows us to use a simple binary search to find
   // Multiple symbols can have the same address. Use a stable sort to stabilize
   // the output.
   StringSet<> FoundDisasmSymbolSet;
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     stable_sort(SecSyms.second);
   stable_sort(AbsoluteSymbols);
 
+  std::unique_ptr<DWARFContext> DICtx;
+  LiveVariablePrinter LVP(*Ctx.getRegisterInfo(), *STI);
+
+  if (DbgVariables != DVDisabled) {
+    DICtx = DWARFContext::create(*Obj);
+    for (const std::unique_ptr<DWARFUnit> &CU : DICtx->compile_units())
+      LVP.addCompileUnit(CU->getUnitDIE(false));
+  }
+
+  LLVM_DEBUG(LVP.dump());
+
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     if (FilterSections.empty() && !DisassembleAll &&
         (!Section.isText() || Section.isVirtual()))
       continue;
 
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
           dumpELFData(SectionAddr, Index, End, Bytes);
           Index = End;
         }
       }
 
       bool CheckARMELFData = hasMappingSymbols(Obj) &&
                              Symbols[SI].Type != ELF::STT_OBJECT &&
                              !DisassembleAll;
       bool DumpARMELFData = false;
+      formatted_raw_ostream FOS(outs());
       while (Index < End) {
         // ARM and AArch64 ELF binaries can interleave data and text in the
         // same section. We rely on the markers introduced to understand what
         // we need to dump. If the data marker is within a function, it is
         // denoted as a word/short etc.
         if (CheckARMELFData) {
           char Kind = getMappingSymbolKind(MappingSymbols, Index);
           DumpARMELFData = Kind == 'd';
           if (SecondarySTI) {
             if (Kind == 'a') {
               STI = PrimaryIsThumb ? SecondarySTI : PrimarySTI;
               DisAsm = PrimaryIsThumb ? SecondaryDisAsm : PrimaryDisAsm;
             } else if (Kind == 't') {
               STI = PrimaryIsThumb ? PrimarySTI : SecondarySTI;
               DisAsm = PrimaryIsThumb ? PrimaryDisAsm : SecondaryDisAsm;
             }
           }
         }
 
         if (DumpARMELFData) {
           Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
-                                MappingSymbols);
+                                MappingSymbols, FOS);
         } else {
           // When -z or --disassemble-zeroes are given we always dissasemble
           // them. Otherwise we might want to skip zero bytes we see.
           if (!DisassembleZeroes) {
             uint64_t MaxOffset = End - Index;
             // For --reloc: print zero blocks patched by relocations, so that
             // relocations can be shown in the dump.
             if (RelCur != RelEnd)
               MaxOffset = RelCur->getOffset() - Index;
 
             if (size_t N =
                     countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
-              outs() << "\t\t..." << '\n';
+              FOS << "\t\t..." << '\n';
               Index += N;
               continue;
             }
           }
 
           // Disassemble a real instruction or a data when disassemble all is
           // provided
           MCInst Inst;
           bool Disassembled =
               DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                      SectionAddr + Index, CommentStream);
           if (Size == 0)
             Size = 1;
 
+          LVP.update({Index, Section.getIndex()},
+                     {Index + Size, Section.getIndex()}, Index + Size != End);
+
           PIP.printInst(
               *IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size),
-              {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, outs(),
-              "", *STI, &SP, Obj->getFileName(), &Rels);
-          outs() << CommentStream.str();
+              {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, FOS,
+              "", *STI, &SP, Obj->getFileName(), &Rels, LVP);
+          FOS << CommentStream.str();
           Comments.clear();
 
           // If disassembly has failed, avoid analysing invalid/incomplete
           // instruction information. Otherwise, try to resolve the target
           // address (jump target or memory operand address) and print it on the
           // right of the instruction.
           if (Disassembled && MIA) {
             uint64_t Target;
             bool PrintTarget =
                 MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target);
             if (!PrintTarget)
               if (Optional<uint64_t> MaybeTarget =
                       MIA->evaluateMemoryOperandAddress(
                           Inst, SectionAddr + Index, Size)) {
                 Target = *MaybeTarget;
                 PrintTarget = true;
-                outs() << "  # " << Twine::utohexstr(Target);
+                FOS << "  # " << Twine::utohexstr(Target);
               }
             if (PrintTarget) {
               // In a relocatable object, the target's section must reside in
               // the same section as the call instruction or it is accessed
               // through a relocation.
               //
               // In a non-relocatable object, the target may be in any section.
               // In that case, locate the section(s) containing the target
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
               }
 
               if (TargetSym != nullptr) {
                 uint64_t TargetAddress = TargetSym->Addr;
                 std::string TargetName = TargetSym->Name.str();
                 if (Demangle)
                   TargetName = demangle(TargetName);
 
-                outs() << " <" << TargetName;
+                FOS << " <" << TargetName;
                 uint64_t Disp = Target - TargetAddress;
                 if (Disp)
-                  outs() << "+0x" << Twine::utohexstr(Disp);
-                outs() << '>';
+                  FOS << "+0x" << Twine::utohexstr(Disp);
+                FOS << '>';
               }
             }
           }
         }
-        outs() << "\n";
+
+        LVP.printAfterInst(FOS);
+        FOS << "\n";
 
         // Hexagon does this in pretty printer
         if (Obj->getArch() != Triple::hexagon) {
           // Print relocation for instruction and data.
           while (RelCur != RelEnd) {
             uint64_t Offset = RelCur->getOffset();
             // If this relocation is hidden, skip it.
             if (getHidden(*RelCur) || SectionAddr + Offset < StartAddress) {
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
             if (RelCur->getSymbol() != Obj->symbol_end()) {
               Expected<section_iterator> SymSI =
                   RelCur->getSymbol()->getSection();
               if (SymSI && *SymSI != Obj->section_end() &&
                   shouldAdjustVA(**SymSI))
                 Offset += AdjustVMA;
             }
 
-            printRelocation(Obj->getFileName(), *RelCur, SectionAddr + Offset,
-                            Is64Bits);
+            printRelocation(FOS, Obj->getFileName(), *RelCur,
+                            SectionAddr + Offset, Is64Bits);
+            LVP.printAfterOtherLine(FOS, true);
             ++RelCur;
           }
         }
 
         Index += Size;
       }
     }
   }