llvm-objdump: move SourcePrinter to shared file

[t.p.northover]

Summary

Interleaved source printing during disassembly is a useful feature, but all the classes for it live in llvm-objdump.cpp and can't be used by the (weirdly) separate MachODumper.cpp. This patch pretty mechanically moves the needed bits (and command-line options) into a shareable header and adds the needed hooks for MachO.

[jhenderson]

Looks like this is causing test failures? Maybe you could break it down into a couple of patches, with the first being the simple moving of code, and later patches adding the new functionality for MachO?

Moving the code is a good time to address any formatting issues highlighted by clang-tidy/clang-format too.

[t.p.northover]

Thanks, this should now be just the NFC refactoring, with most clang-tidy/clang-format suggestions applied (I ignored the DWARF one for obvious reasons).

I'm not sure what's going on with those test failures, it works on my local Linux machine. But now that this is non-MachO that's a problem for another time.

[jhenderson]

LGTM, with nits.

llvm/tools/llvm-objdump/SourcePrinter.cpp

482

Nit: add a new line at EOF.

llvm/tools/llvm-objdump/SourcePrinter.h

164

Nit: add a new line at EOF

[t.p.northover]

Thanks. Committed as c623945d707c with the new lines.

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

Error SymbolizableObjectFile::addSymbol(const SymbolRef &Symbol,
   Expected<section_iterator> Sec = Symbol.getSection();
   if (!Sec || Obj.section_end() == *Sec) {
     if (Obj.isELF()) {
       // Store the (index, filename) pair for a file symbol.
       ELFSymbolRef ESym(Symbol);
       if (ESym.getELFType() == ELF::STT_FILE)
         FileSymbols.emplace_back(ELFSymIdx, SymbolName);
     }
-    return Error::success();
+    return Sec.takeError();
   }
 
   Expected<SymbolRef::Type> SymbolTypeOrErr = Symbol.getType();
   if (!SymbolTypeOrErr)
     return SymbolTypeOrErr.takeError();
   SymbolRef::Type SymbolType = *SymbolTypeOrErr;
   if (Obj.isELF()) {
     // Allow function and data symbols. Additionally allow STT_NONE, which are

llvm/test/tools/llvm-objdump/MachO/AArch64/Inputs/interleaved-source-macho.c

+int main(int argc, char *argv[]) {
+   int i = 2;
+   i += 1;
+   return i;
+}

llvm/test/tools/llvm-objdump/MachO/AArch64/Inputs/interleaved-source-macho.dSYM/Contents/Info.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>English</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.apple.xcode.dsym.interleaved-source-macho</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundlePackageType</key>
+    <string>dSYM</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+  </dict>
+</plist>

llvm/test/tools/llvm-objdump/MachO/AArch64/interleaved-source.txt

+; RUN: cd %p
+; RUN: llvm-objdump --macho -g -d --source %p/Inputs/interleaved-source-macho --dsym %p/Inputs/interleaved-source-macho.dSYM | FileCheck %s
+
+; Source for interleaved-source.c
+; To regenerate this file:
+;   clang -g interleaved-source.c -o interleaved-source -fdebug-prefix-map=/path/to/llvm/test/tools/llvm-objdump/Inputs=Inputs
+;
+; int main(int argc, char *argv[]) {
+;   int i = 2;
+;   i += 1;
+;   return i;
+; }
+
+; CHECK: _main:
+; CHECK-NEXT: ; int main(int argc, char *argv[]) {
+; CHECK: sub sp,
+
+; CHECK: ; int i = 2;
+; CHECK: str {{w.*}}, [sp, [[IPTR:#.*]]]
+
+; CHECK: ; i += 1;
+; CHECK: ldr [[VAR:w.*]], [sp, [[IPTR]]]
+; CHECK: add [[NEW:w.*]], [[VAR]], #1
+; CHECK: str [[NEW]], [sp, [[IPTR]]]
+
+; CHECK: ; return i;
+; CHECK: ldr w0, [sp, [[IPTR]]]
+; CHECK: ret

llvm/tools/llvm-objdump/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   MCDisassembler
   Object
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-objdump
   llvm-objdump.cpp
+  SourcePrinter.cpp
   COFFDump.cpp
   ELFDump.cpp
   MachODump.cpp
   WasmDump.cpp
   XCOFFDump.cpp
   )
 
 if(HAVE_LIBXAR)
   target_link_libraries(llvm-objdump PRIVATE ${XAR_LIB})
 endif()
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objdump llvm-objdump)
 endif()

llvm/tools/llvm-objdump/MachODump.cpp

 //===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the MachO-specific dumper for llvm-objdump.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MachODump.h"
 
 #include "llvm-objdump.h"
+#include "SourcePrinter.h"
 #include "llvm-c/Disassembler.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
#undef CHECK_THUMB_TARGET_INFO_CREATION
   for (dice_iterator DI = MachOOF->begin_dices(), DE = MachOOF->end_dices();
        DI != DE; ++DI) {
     uint32_t Offset;
     DI->getOffset(Offset);
     Dices.push_back(std::make_pair(BaseAddress + Offset, *DI));
   }
   array_pod_sort(Dices.begin(), Dices.end());
 
+  LiveVariablePrinter LVP(*MRI, *STI);
+
   // Try to find debug info and set up the DIContext for it.
-  std::unique_ptr<DIContext> diContext;
+  std::unique_ptr<DWARFContext> diContext;
   std::unique_ptr<Binary> DSYMBinary;
   std::unique_ptr<MemoryBuffer> DSYMBuf;
-  if (UseDbg) {
-    ObjectFile *DbgObj = MachOOF;
-
+  if (UseDbg) {
     // A separate DSym file path was specified, parse it as a macho file,
     // get the sections and supply it to the section name parsing machinery.
     if (!DSYMFile.empty()) {
       std::string DSYMPath(DSYMFile);
 
       // If DSYMPath is a .dSYM directory, append the Mach-O file.
       if (llvm::sys::fs::is_directory(DSYMPath) &&
           llvm::sys::path::extension(DSYMPath) == ".dSYM") {
if (!DSYMFile.empty()) {
         WithColor::error(errs(), "llvm-objdump")
           << DSYMPath << " is not a Mach-O or Universal file type.\n";
         return;
       }
     }
 
     // Setup the DIContext
     diContext = DWARFContext::create(*DbgObj);
+    if (objdump::DbgVariables != objdump::DVDisabled) {
+      for (const std::unique_ptr<DWARFUnit> &CU : diContext->compile_units())
+        LVP.addCompileUnit(CU->getUnitDIE(false));
     }
+  }
+  SourcePrinter SP(DbgObj, TheTarget->getName());
 
   if (FilterSections.empty())
     outs() << "(" << DisSegName << "," << DisSectName << ") section\n";
 
   for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) {
     Expected<StringRef> SecNameOrErr = Sections[SectIdx].getName();
     if (!SecNameOrErr) {
       consumeError(SecNameOrErr.takeError());
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
 
         // If this is the first symbol in the section and it was not at the
         // start of the section, see if we are at its Index now and if so print
         // the symbol name.
         if (FirstSymbol && !FirstSymbolAtSectionStart && Index == SymbolStart)
           outs() << SymName << ":\n";
 
         uint64_t PC = SectAddress + Index;
+        LVP.update({PC, SectIdx}, {PC + Size, SectIdx}, PC + Size != End);
+        if (objdump::PrintSource || objdump::PrintLines) {
+          formatted_raw_ostream FormattedOS(outs());
+          SP.printSourceLine(FormattedOS, {PC, SectIdx}, MachOOF->getFileName(),
+                             LVP);
+        }
+
         if (!NoLeadingAddr) {
           if (FullLeadingAddr) {
             if (MachOOF->is64Bit())
               outs() << format("%016" PRIx64, PC);
             else
               outs() << format("%08" PRIx64, PC);
           } else {
             outs() << format("%8" PRIx64 ":", PC);

llvm/tools/llvm-objdump/SourcePrinter.h

+//===-- SourcePrinter.h -  source interleaving utilities --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_OBJDUMP_SOURCEPRINTER_H
+#define LLVM_TOOLS_LLVM_OBJDUMP_SOURCEPRINTER_H
+
+#include "llvm/ADT/IndexedMap.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/Symbolize/Symbolize.h"
+#include "llvm/Support/FormattedStream.h"
+#include <vector>
+#include <unordered_map>
+
+namespace llvm {
+/// 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);
+
+  void print(raw_ostream &OS, const MCRegisterInfo &MRI) const;
+};
+
+/// 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);
+
+  void addFunction(DWARFDie D);
+
+  // Get the column number (in characters) at which the first live variable
+  // line should be printed.
+  unsigned getIndentLevel() const;
+
+  // 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);
+
+  unsigned findFreeColumn();
+
+public:
+  LiveVariablePrinter(const MCRegisterInfo &MRI, const MCSubtargetInfo &STI)
+      : LiveVariables(), ActiveCols(Column()), MRI(MRI), STI(STI) {}
+
+  void dump() const;
+
+  void addCompileUnit(DWARFDie D);
+
+  /// 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);
+
+  enum class LineChar {
+    RangeStart,
+    RangeMid,
+    RangeEnd,
+    LabelVert,
+    LabelCornerNew,
+    LabelCornerActive,
+    LabelHoriz,
+  };
+  const char *getLineChar(LineChar C) const;
+
+  /// 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);
+
+  /// 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);
+
+  /// Print the live variable ranges to the right of a disassembled instruction.
+  void printAfterInst(formatted_raw_ostream &OS);
+};
+
+class SourcePrinter {
+protected:
+  DILineInfo OldLineInfo;
+  const object::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 'invalid debug info' warning once.
+  bool WarnedInvalidDebugInfo = false;
+
+private:
+  bool cacheSource(const DILineInfo& LineInfoFile);
+
+  void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
+                  StringRef Delimiter, LiveVariablePrinter &LVP);
+
+  void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
+                    StringRef ObjectFilename, StringRef Delimiter,
+                    LiveVariablePrinter &LVP);
+
+public:
+  SourcePrinter() = default;
+  SourcePrinter(const object::ObjectFile *Obj, StringRef DefaultArch);
+  virtual ~SourcePrinter() = default;
+  virtual void printSourceLine(formatted_raw_ostream &OS,
+                               object::SectionedAddress Address,
+                               StringRef ObjectFilename,
+                               LiveVariablePrinter &LVP,
+                               StringRef Delimiter = "; ");
+};
+
+} // namespace llvm
+
+#endif
 No newline at end of file

llvm/tools/llvm-objdump/SourcePrinter.cpp

+//===-- SourcePrinter.cpp -  source interleaving utilities -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the LiveVariablePrinter and SourcePrinter classes to
+// keep track of DWARF info as the current address is updated, and print out the
+// source file line and variable liveness as needed.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SourcePrinter.h"
+#include "llvm-objdump.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/FormatVariadic.h"
+
+#define DEBUG_TYPE "objdump"
+
+namespace llvm {
+
+unsigned getInstStartColumn(const MCSubtargetInfo &STI) {
+  return objdump::NoShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
+}
+
+bool LiveVariable::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 LiveVariable::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);
+}
+
+void LiveVariablePrinter::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 LiveVariablePrinter::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 LiveVariablePrinter::getIndentLevel() const {
+  return objdump::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 LiveVariablePrinter::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 LiveVariablePrinter::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;
+}
+
+void LiveVariablePrinter::dump() const {
+  for (const LiveVariable &LV : LiveVariables) {
+    dbgs() << LV.VarName << " @ " << LV.LocExpr.Range << ": ";
+    LV.print(dbgs(), MRI);
+    dbgs() << "\n";
+  }
+}
+
+void LiveVariablePrinter::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 LiveVariablePrinter::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 *LiveVariablePrinter::getLineChar(LineChar C) const {
+  bool IsASCII = objdump::DbgVariables == objdump::DVASCII;
+  switch (C) {
+  case LineChar::RangeStart:
+    return IsASCII ? "^" : (const char *)u8"\u2548";
+  case LineChar::RangeMid:
+    return IsASCII ? "|" : (const char *)u8"\u2503";
+  case LineChar::RangeEnd:
+    return IsASCII ? "v" : (const char *)u8"\u253b";
+  case LineChar::LabelVert:
+    return IsASCII ? "|" : (const char *)u8"\u2502";
+  case LineChar::LabelCornerNew:
+    return IsASCII ? "/" : (const char *)u8"\u250c";
+  case LineChar::LabelCornerActive:
+    return IsASCII ? "|" : (const char *)u8"\u2520";
+  case LineChar::LabelHoriz:
+    return IsASCII ? "-" : (const char *)u8"\u2500";
+  }
+  llvm_unreachable("Unhandled LineChar enum");
+}
+
+/// 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 LiveVariablePrinter::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 LiveVariablePrinter::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 LiveVariablePrinter::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!");
+  }
+}
+
+bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
+  std::unique_ptr<MemoryBuffer> Buffer;
+  if (LineInfo.Source) {
+    Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
+  } else {
+    auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName);
+    if (!BufferOrError) {
+      if (MissingSources.insert(LineInfo.FileName).second)
+        objdump::reportWarning("failed to find source " + LineInfo.FileName,
+                               Obj->getFileName());
+      return false;
+    }
+    Buffer = std::move(*BufferOrError);
+  }
+  // Chomp the file to get lines
+  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(formatted_raw_ostream &OS,
+                                    object::SectionedAddress Address,
+                                    StringRef ObjectFilename,
+                                    LiveVariablePrinter &LVP,
+                                    StringRef Delimiter) {
+  if (!Symbolizer)
+    return;
+
+  DILineInfo LineInfo = DILineInfo();
+  Expected<DILineInfo> ExpectedLineInfo =
+      Symbolizer->symbolizeCode(*Obj, Address);
+  std::string ErrorMessage;
+  if (ExpectedLineInfo) {
+    LineInfo = *ExpectedLineInfo;
+  } else if (!WarnedInvalidDebugInfo) {
+    WarnedInvalidDebugInfo = true;
+    // TODO Untested.
+    objdump::reportWarning("failed to parse debug information: " +
+                               toString(ExpectedLineInfo.takeError()),
+                           ObjectFilename);
+  }
+
+  if (!objdump::Prefix.empty() &&
+      sys::path::is_absolute_gnu(LineInfo.FileName)) {
+    // FileName has at least one character since is_absolute_gnu is false for
+    // an empty string.
+    assert(!LineInfo.FileName.empty());
+    if (objdump::PrefixStrip > 0) {
+      uint32_t Level = 0;
+      auto StrippedNameStart = LineInfo.FileName.begin();
+
+      // Path.h iterator skips extra separators. Therefore it cannot be used
+      // here to keep compatibility with GNU Objdump.
+      for (auto Pos = StrippedNameStart + 1, End = LineInfo.FileName.end();
+           Pos != End && Level < objdump::PrefixStrip; ++Pos) {
+        if (sys::path::is_separator(*Pos)) {
+          StrippedNameStart = Pos;
+          ++Level;
+        }
+      }
+
+      LineInfo.FileName =
+          std::string(StrippedNameStart, LineInfo.FileName.end());
+    }
+
+    SmallString<128> FilePath;
+    sys::path::append(FilePath, objdump::Prefix, LineInfo.FileName);
+
+    LineInfo.FileName = std::string(FilePath);
+  }
+
+  if (objdump::PrintLines)
+    printLines(OS, LineInfo, Delimiter, LVP);
+  if (objdump::PrintSource)
+    printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP);
+  OldLineInfo = LineInfo;
+}
+
+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;
+    LVP.printBetweenInsts(OS, true);
+  }
+}
+
+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()) {
+      objdump::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];
+    LVP.printBetweenInsts(OS, true);
+  }
+}
+
+SourcePrinter::SourcePrinter(const object::ObjectFile *Obj,
+                             StringRef DefaultArch)
+    : Obj(Obj) {
+  symbolize::LLVMSymbolizer::Options SymbolizerOpts;
+  SymbolizerOpts.PrintFunctions =
+      DILineInfoSpecifier::FunctionNameKind::LinkageName;
+  SymbolizerOpts.Demangle = objdump::Demangle;
+  SymbolizerOpts.DefaultArch = std::string(DefaultArch);
+  Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
+}
+
+} // namespace llvm
 No newline at end of file

llvm/tools/llvm-objdump/llvm-objdump.h

 class ELFSectionRef;
 class MachOObjectFile;
 class MachOUniversalBinary;
 class RelocationRef;
 } // namespace object
 
 namespace objdump {
 
+enum DebugVarsFormat {
+  DVDisabled,
+  DVUnicode,
+  DVASCII,
+};
+
 extern cl::opt<bool> ArchiveHeaders;
+extern cl::opt<int> DbgIndent;
+extern cl::opt<DebugVarsFormat> DbgVariables;
 extern cl::opt<bool> Demangle;
 extern cl::opt<bool> Disassemble;
 extern cl::opt<bool> DisassembleAll;
 extern cl::opt<DIDumpType> DwarfDumpType;
 extern cl::list<std::string> FilterSections;
 extern cl::list<std::string> MAttrs;
 extern cl::opt<std::string> MCPU;
 extern cl::opt<bool> NoShowRawInsn;
 extern cl::opt<bool> NoLeadingAddr;
 extern cl::opt<std::string> Prefix;
 extern cl::opt<uint32_t> PrefixStrip;
 extern cl::opt<bool> PrintImmHex;
+extern cl::opt<bool> PrintLines;
+extern cl::opt<bool> PrintSource;
 extern cl::opt<bool> PrivateHeaders;
 extern cl::opt<bool> Relocations;
 extern cl::opt<bool> SectionHeaders;
 extern cl::opt<bool> SectionContents;
 extern cl::opt<bool> SymbolDescription;
 extern cl::opt<bool> SymbolTable;
 extern cl::opt<std::string> TripleName;
 extern cl::opt<bool> UnwindInfo;

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

 // flags.
 //
 // The flags and output of this program should be near identical to those of
 // binutils objdump.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-objdump.h"
+#include "SourcePrinter.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/ADT/Twine.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
static cl::alias SectionContentsShort("s",
                                       cl::NotHidden, cl::Grouping,
                                       cl::aliasopt(SectionContents));
 
 static cl::list<std::string> InputFilenames(cl::Positional,
                                             cl::desc("<input object files>"),
                                             cl::ZeroOrMore,
                                             cl::cat(ObjdumpCat));
 
-static cl::opt<bool>
-    PrintLines("line-numbers",
+cl::opt<bool>
+    objdump::PrintLines("line-numbers",
                         cl::desc("Display source line numbers with "
                                  "disassembly. Implies disassemble object"),
                         cl::cat(ObjdumpCat));
 static cl::alias PrintLinesShort("l", cl::desc("Alias for --line-numbers"),
                                  cl::NotHidden, cl::Grouping,
                                  cl::aliasopt(PrintLines));
 
 static cl::opt<bool> MachOOpt("macho",
                               cl::desc("Use MachO specific object file parser"),
                               cl::cat(ObjdumpCat));
 static cl::alias MachOm("m", cl::desc("Alias for --macho"), cl::NotHidden,
static cl::alias SectionHeadersShorter("h",
                                        cl::NotHidden, cl::Grouping,
                                        cl::aliasopt(SectionHeaders));
 
 static cl::opt<bool>
     ShowLMA("show-lma",
             cl::desc("Display LMA column when dumping ELF section headers"),
             cl::cat(ObjdumpCat));
 
-static cl::opt<bool> PrintSource(
+cl::opt<bool> objdump::PrintSource(
     "source",
     cl::desc(
         "Display source inlined with disassembly. Implies disassemble object"),
     cl::cat(ObjdumpCat));
 static cl::alias PrintSourceShort("S", cl::desc("Alias for --source"),
                                   cl::NotHidden, cl::Grouping,
                                   cl::aliasopt(PrintSource));
 
cl::opt<std::string> objdump::Prefix("prefix",
                                      cl::cat(ObjdumpCat));
 
 cl::opt<uint32_t>
     objdump::PrefixStrip("prefix-strip",
                          cl::desc("Strip out initial directories from absolute "
                                   "paths. No effect without --prefix"),
                          cl::init(0), cl::cat(ObjdumpCat));
 
-enum DebugVarsFormat {
-  DVDisabled,
-  DVUnicode,
-  DVASCII,
-};
-
-static cl::opt<DebugVarsFormat> DbgVariables(
+cl::opt<DebugVarsFormat> objdump::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));
+cl::opt<int> objdump::DbgIndent(
+    "debug-vars-indent", cl::init(40),
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 static StringSet<> DisasmSymbolSet;
 StringSet<> objdump::FoundSectionSet;
 static StringRef ToolName;
 

 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 ? "^" : (const char *)u8"\u2548";
-    case LineChar::RangeMid:
-      return IsASCII ? "|" : (const char *)u8"\u2503";
-    case LineChar::RangeEnd:
-      return IsASCII ? "v" : (const char *)u8"\u253b";
-    case LineChar::LabelVert:
-      return IsASCII ? "|" : (const char *)u8"\u2502";
-    case LineChar::LabelCornerNew:
-      return IsASCII ? "/" : (const char *)u8"\u250c";
-    case LineChar::LabelCornerActive:
-      return IsASCII ? "|" : (const char *)u8"\u2520";
-    case LineChar::LabelHoriz:
-      return IsASCII ? "-" : (const char *)u8"\u2500";
-    }
-    llvm_unreachable("Unhandled LineChar enum");
-  }
-
-  /// 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 'invalid debug info' warning once.
-  bool WarnedInvalidDebugInfo = false;
-
-private:
-  bool cacheSource(const DILineInfo& LineInfoFile);
-
-  void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
-                  StringRef Delimiter, LiveVariablePrinter &LVP);
-
-  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) {
-    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(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 {
-    auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName);
-    if (!BufferOrError) {
-      if (MissingSources.insert(LineInfo.FileName).second)
-        reportWarning("failed to find source " + LineInfo.FileName,
-                      Obj->getFileName());
-      return false;
-    }
-    Buffer = std::move(*BufferOrError);
-  }
-  // Chomp the file to get lines
-  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(formatted_raw_ostream &OS,
-                                    object::SectionedAddress Address,
-                                    StringRef ObjectFilename,
-                                    LiveVariablePrinter &LVP,
-                                    StringRef Delimiter) {
-  if (!Symbolizer)
-    return;
-
-  DILineInfo LineInfo = DILineInfo();
-  Expected<DILineInfo> ExpectedLineInfo =
-      Symbolizer->symbolizeCode(*Obj, Address);
-  std::string ErrorMessage;
-  if (ExpectedLineInfo) {
-    LineInfo = *ExpectedLineInfo;
-  } else if (!WarnedInvalidDebugInfo) {
-    WarnedInvalidDebugInfo = true;
-    // TODO Untested.
-    reportWarning("failed to parse debug information: " +
-                      toString(ExpectedLineInfo.takeError()),
-                  ObjectFilename);
-  }
-
-  if (!Prefix.empty() && sys::path::is_absolute_gnu(LineInfo.FileName)) {
-    // FileName has at least one character since is_absolute_gnu is false for
-    // an empty string.
-    assert(!LineInfo.FileName.empty());
-    if (PrefixStrip > 0) {
-      uint32_t Level = 0;
-      auto StrippedNameStart = LineInfo.FileName.begin();
-
-      // Path.h iterator skips extra separators. Therefore it cannot be used
-      // here to keep compatibility with GNU Objdump.
-      for (auto Pos = StrippedNameStart + 1, End = LineInfo.FileName.end();
-           Pos != End && Level < PrefixStrip; ++Pos) {
-        if (sys::path::is_separator(*Pos)) {
-          StrippedNameStart = Pos;
-          ++Level;
-        }
-      }
-
-      LineInfo.FileName =
-          std::string(StrippedNameStart, LineInfo.FileName.end());
-    }
-
-    SmallString<128> FilePath;
-    sys::path::append(FilePath, Prefix, LineInfo.FileName);
-
-    LineInfo.FileName = std::string(FilePath);
-  }
-
-  if (PrintLines)
-    printLines(OS, LineInfo, Delimiter, LVP);
-  if (PrintSource)
-    printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP);
-  OldLineInfo = LineInfo;
-}
-
-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;
-    LVP.printBetweenInsts(OS, true);
-  }
-}
-
-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];
-    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;