[Symbolizer] Implement data symbolizer markup element.

[mysterymath]

Summary

This connects the Symbolizer to the markup filter and enables the first
working end-to-end flow using the filter.

[phosek]

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

462–469

This should be moved as well so we can use debuginfod with the symbolizer filter.

471–477

This is not something that needs to be addressed in this change, but I think it would be valuable to support different output styles with the symbolizer filter as well, ideally by extending and using the existing printers. The JSON output in particular would be useful for consumption from other tools and scripts.

[mysterymath]

Address review comments.

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

462–469

Ah, good catch. Done.

471–477

The use case makes sense, but it would be a somewhat odd way of interpreting the symbolizer markup. For the output to make sense as (e.g.) JSON, you'd need to have the filter ignore any text and SGR nodes present in the log, or you'd need to expect that the input is only markup and whitespace.

Maybe we could support an auxiliary output for this. When the log symbolizer encounters a presentation element, it could also tee the results to the auxiliary in one of these existing formats. This would keep the semantics of the main log symbolization pipeline simple and consistent, while still allowing machine processing of the referenced symbols, perhaps in concert with the filtered markup output.

[mysterymath]

Integrate from upstream.

[peter.smith]

One small comment on the test, I'll be out on vacation next week so may be slow to respond. I've not got any objections so please don't wait for me if others are happy to approve.

llvm/test/DebugInfo/symbolize-filter-markup-data.test

18

Possibly worth a test with too many fields?

33

I can't see a label l in the test. Was the intention to set the size of long to 4? If so I think you'll need .size long, 4. The same applies to .size b, 1 below.

Checking the object file the sizes of long and byte are 0.

[mysterymath]

Correct size directive.

llvm/test/DebugInfo/symbolize-filter-markup-data.test

18

Eh, for that test to fail and this one to pass, there would have to be a discontinuity in how the implementation handles inputs with too many fields vs too few fields. The implementation currently uses "==", and that's rather unlikely to accidentally change. A possible class of errors would be to swap checkNumFields with checkNumFieldsAtLeast or similar, but these each come with different messages.

33

Yep, these didn't get updated when I renamed the variables. Done.

[peter.smith]

Apologies for the delay in responding, have been on vacation. I've got one suggestion on the output of the module line having looked at the test. Otherwise looks good to me.

llvm/test/DebugInfo/symbolize-filter-markup-data.test

13

I don't know how much scope there is to change the output format of the mmap information in the module line given that this is based on a pre-existing markup. When I saw 0x0(r) - 0x10(r) I wasn't sure whether this was one contiguous range [0x0, 0x10) or two separate ranges, not necessarily contiguous with one starting at 0x0 and one at 0x10. I guessed at the latter given the {{{mmap}}} elements but it would have been harder to understand if I'd just seen the output and not the input.

Perhaps use a comma instead of a dash to separate the mmaps? As an alternative I guess the size could be incorporated in some way.

No worries if this isn't possible.

[mysterymath]

Address review comments.

llvm/test/DebugInfo/symbolize-filter-markup-data.test

13

Generally agree; there shouldn't be anything that hard-depends on the format, as this is intended to be human readable, not machine readable. I think we can mostly escape Hyrum's law too, since usage of this markup format is pretty limited at present.

Spent a bit of time thinking about this, and ended up with [0x0-0x9](r),[0x10-0x11](r). Using brackets agrees with the mathematical notation for inclusive ranges. Using inclusive ranges and dashes inside makes this also readable to those unfamiliar with that notation.

[peter.smith]

Thanks for the update. Looks good to me.

llvm/docs/CommandGuide/llvm-symbolizer.rst

.. option:: --fallback-debug-path <path>
   When a separate file contains debug data, and is referenced by a GNU debug
   link section, use the specified path as a basis for locating the debug data if
   it cannot be found relative to the object.
 
 .. option:: --filter-markup
 
   Reads from standard input, converts contained
   :doc:`Symbolizer Markup </SymbolizerMarkupFormat>` into human-readable form,
-  and prints the results to standard output. Presently, only the following
-  markup elements are supported:
+  and prints the results to standard output. The following markup elements are
+  not yet supported:
 
-  * ``{{symbol}}``
-  * ``{{reset}}``
-  * ``{{module}}``
-  * ``{{mmap}}``
+  * ``{{pc}}``
+  * ``{{bt}}``
+  * ``{{hexdict}}``
+  * ``{{dumpfile}}``
 
 .. _llvm-symbolizer-opt-f:
 
 .. option:: --functions [=<none|short|linkage>], -f
 
   Specify the way function names are printed (omit function name, print short
   function name, or print full linkage name, respectively). Defaults to
   ``linkage``.

llvm/docs/SymbolizerMarkupFormat.rst

``{{{pc:%p}}}``, ``{{{pc:%p:ra}}}``, ``{{{pc:%p:pc}}}`` [#not_yet_implemented]_
   function name and source location. The second two forms distinguish the kind of
   code location, as described in detail for bt elements below.
 
   Examples::
 
     {{{pc:0x12345678}}}
     {{{pc:0xffffffff9abcdef0}}}
 
-``{{{data:%p}}}`` [#not_yet_implemented]_
+``{{{data:%p}}}``
 
   Here ``%p`` is the memory address of a data location. It might be presented as
   the name of a global variable at that location.
 
   Examples::
 
     {{{data:0x12345678}}}
     {{{data:0xffffffff9abcdef0}}}

llvm/include/llvm/DebugInfo/Symbolize/MarkupFilter.h

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace symbolize {
 
+class LLVMSymbolizer;
+
 /// Filter to convert parsed log symbolizer markup elements into human-readable
 /// text.
 class MarkupFilter {
 public:
-  MarkupFilter(raw_ostream &OS, Optional<bool> ColorsEnabled = llvm::None);
+  MarkupFilter(raw_ostream &OS, LLVMSymbolizer &Symbolizer,
+               Optional<bool> ColorsEnabled = llvm::None);
 
   /// Filters a line containing symbolizer markup and writes the human-readable
   /// results to the output stream.
   ///
   /// Invalid or unimplemented markup elements are removed. Some output may be
   /// deferred until future filter() or finish() call.
   void filter(StringRef Line);
 
private:
   struct MMap {
     uint64_t Addr;
     uint64_t Size;
     const Module *Module;
     std::string Mode; // Lowercase
     uint64_t ModuleRelativeAddr;
 
     bool contains(uint64_t Addr) const;
+    uint64_t getModuleRelativeAddr(uint64_t Addr) const;
   };
 
   // An informational module line currently being constructed. As many mmap
   // elements as possible are folded into one ModuleInfo line.
   struct ModuleInfoLine {
     const Module *Module;
 
     SmallVector<const MMap *> MMaps = {};
private:
 
   void beginModuleInfoLine(const Module *M);
   void endModuleInfoLine();
 
   void filterNode(const MarkupNode &Node);
 
   bool tryPresentation(const MarkupNode &Node);
   bool trySymbol(const MarkupNode &Node);
+  bool tryData(const MarkupNode &Node);
 
   bool trySGR(const MarkupNode &Node);
 
   void highlight();
   void highlightValue();
   void restoreColor();
   void resetColor();
 
   Optional<Module> parseModule(const MarkupNode &Element) const;
   Optional<MMap> parseMMap(const MarkupNode &Element) const;
 
   Optional<uint64_t> parseAddr(StringRef Str) const;
   Optional<uint64_t> parseModuleID(StringRef Str) const;
   Optional<uint64_t> parseSize(StringRef Str) const;
   Optional<SmallVector<uint8_t>> parseBuildID(StringRef Str) const;
   Optional<std::string> parseMode(StringRef Str) const;
 
   bool checkTag(const MarkupNode &Node) const;
   bool checkNumFields(const MarkupNode &Element, size_t Size) const;
   bool checkNumFieldsAtLeast(const MarkupNode &Element, size_t Size) const;
 
   void reportTypeError(StringRef Str, StringRef TypeName) const;
   void reportLocation(StringRef::iterator Loc) const;
 
-  const MMap *overlappingMMap(const MMap &Map) const;
+  const MMap *getOverlappingMMap(const MMap &Map) const;
+  const MMap *getContainingMMap(uint64_t Addr) const;
 
   StringRef lineEnding() const;
 
   raw_ostream &OS;
+  LLVMSymbolizer &Symbolizer;
   const bool ColorsEnabled;
 
   MarkupParser Parser;
 
   // Current line being filtered.
   StringRef Line;
 
   // A module info line currently being built. This incorporates as much mmap

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

 
 #include "llvm/DebugInfo/Symbolize/MarkupFilter.h"
 
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/DebugInfo/Symbolize/Markup.h"
+#include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::symbolize;
 
-MarkupFilter::MarkupFilter(raw_ostream &OS, Optional<bool> ColorsEnabled)
-    : OS(OS), ColorsEnabled(ColorsEnabled.value_or(
-                  WithColor::defaultAutoDetectFunction()(OS))) {}
+MarkupFilter::MarkupFilter(raw_ostream &OS, LLVMSymbolizer &Symbolizer,
+                           Optional<bool> ColorsEnabled)
+    : OS(OS), Symbolizer(Symbolizer),
+      ColorsEnabled(
+          ColorsEnabled.value_or(WithColor::defaultAutoDetectFunction()(OS))) {}
 
 void MarkupFilter::filter(StringRef Line) {
   this->Line = Line;
   resetColor();
 
   Parser.parseLine(Line);
   SmallVector<MarkupNode> DeferredNodes;
   while (Optional<MarkupNode> Node = Parser.nextNode()) {

 bool MarkupFilter::tryMMap(const MarkupNode &Node,
                            const SmallVector<MarkupNode> &DeferredNodes) {
   if (Node.Tag != "mmap")
     return false;
   Optional<MMap> ParsedMMap = parseMMap(Node);
   if (!ParsedMMap)
     return true;
 
-  if (const MMap *M = overlappingMMap(*ParsedMMap)) {
+  if (const MMap *M = getOverlappingMMap(*ParsedMMap)) {
     WithColor::error(errs())
         << formatv("overlapping mmap: #{0:x} [{1:x},{2:x})\n", M->Module->ID,
                    M->Addr, M->Addr + M->Size);
     reportLocation(Node.Fields[0].begin());
     return true;
   }
 
   auto Res = MMaps.emplace(ParsedMMap->Addr, std::move(*ParsedMMap));
if (tryPresentation(Node))
     return;
   if (trySGR(Node))
     return;
 
   OS << Node.Text;
 }
 
 bool MarkupFilter::tryPresentation(const MarkupNode &Node) {
-  return trySymbol(Node);
+  if (trySymbol(Node))
+    return true;
+  return tryData(Node);
 }
 
 bool MarkupFilter::trySymbol(const MarkupNode &Node) {
   if (Node.Tag != "symbol")
     return false;
   if (!checkNumFields(Node, 1))
     return true;
 
   highlight();
   OS << llvm::demangle(Node.Fields.front().str());
   restoreColor();
   return true;
 }
 
+bool MarkupFilter::tryData(const MarkupNode &Node) {
+  if (Node.Tag != "data")
+    return false;
+  if (!checkNumFields(Node, 1))
+    return true;
+  Optional<uint64_t> Addr = parseAddr(Node.Fields[0]);
+  if (!Addr)
+    return true;
+
+  const auto PrintRaw = [&]() {
+    highlight();
+    OS << "[[[data:";
+    highlightValue();
+    OS << "0x" << toHex(*Addr, /*LowerCase=*/true);
+    highlight();
+    OS << "]]]\n";
+    restoreColor();
+  };
+
+  const MMap *MMap = getContainingMMap(*Addr);
+  if (!MMap) {
+    WithColor::error() << "no mmap covers address\n";
+    reportLocation(Node.Fields[0].begin());
+    PrintRaw();
+    return true;
+  }
+
+  Expected<DIGlobal> Symbol = Symbolizer.symbolizeData(
+      MMap->Module->BuildID, {MMap->getModuleRelativeAddr(*Addr)});
+  if (!Symbol) {
+    WithColor::defaultErrorHandler(Symbol.takeError());
+    PrintRaw();
+    return true;
+  }
+
+  highlight();
+  OS << Symbol->Name;
+  restoreColor();
+  return true;
+}
+
 bool MarkupFilter::trySGR(const MarkupNode &Node) {
   if (Node.Text == "\033[0m") {
     resetColor();
     return true;
   }
   if (Node.Text == "\033[1m") {
     Bold = true;
     if (ColorsEnabled)
if (any_of(Node.Tag, [](char C) { return C < 'a' || C > 'z'; })) {
     return false;
   }
   return true;
 }
 
 bool MarkupFilter::checkNumFields(const MarkupNode &Element,
                                   size_t Size) const {
   if (Element.Fields.size() != Size) {
-    WithColor::error(errs()) << "expected " << Size << " fields; found "
+    WithColor::error(errs()) << "expected " << Size << " field(s); found "
                              << Element.Fields.size() << "\n";
     reportLocation(Element.Tag.end());
     return false;
   }
   return true;
 }
 
 bool MarkupFilter::checkNumFieldsAtLeast(const MarkupNode &Element,
                                          size_t Size) const {
   if (Element.Fields.size() < Size) {
     WithColor::error(errs())
-        << "expected at least " << Size << " fields; found "
+        << "expected at least " << Size << " field(s); found "
         << Element.Fields.size() << "\n";
     reportLocation(Element.Tag.end());
     return false;
   }
   return true;
 }
 
 void MarkupFilter::reportTypeError(StringRef Str, StringRef TypeName) const {
   WithColor::error(errs()) << "expected " << TypeName << "; found '" << Str
                            << "'\n";
   reportLocation(Str.begin());
 }
 
 // Prints two lines that point out the given location in the current Line using
 // a caret. The iterator must be within the bounds of the most recent line
 // passed to beginLine().
 void MarkupFilter::reportLocation(StringRef::iterator Loc) const {
   errs() << Line;
   WithColor(errs().indent(Loc - Line.begin()), HighlightColor::String) << '^';
   errs() << '\n';
 }
 
 // Checks for an existing mmap that overlaps the given one and returns a
 // pointer to one of them.
-const MarkupFilter::MMap *MarkupFilter::overlappingMMap(const MMap &Map) const {
+const MarkupFilter::MMap *MarkupFilter::getOverlappingMMap(const MMap &Map) const {
   // If the given map contains the start of another mmap, they overlap.
   auto I = MMaps.upper_bound(Map.Addr);
   if (I != MMaps.end() && Map.contains(I->second.Addr))
     return &I->second;
 
   // If no element starts inside the given mmap, the only possible overlap would
   // be if the preceding mmap contains the start point of the given mmap.
   if (I != MMaps.begin()) {
     --I;
     if (I->second.contains(Map.Addr))
       return &I->second;
   }
   return nullptr;
 }
 
+// Returns the MMap that contains the given address or nullptr if none.
+const MarkupFilter::MMap *MarkupFilter::getContainingMMap(uint64_t Addr) const {
+  // Find the first mmap starting >= Addr.
+  auto I = MMaps.lower_bound(Addr);
+  if (I != MMaps.end() && I->second.contains(Addr))
+    return &I->second;
+
+  // The previous mmap is the last one starting < Addr.
+  if (I == MMaps.begin())
+    return nullptr;
+  --I;
+  return I->second.contains(Addr) ? &I->second : nullptr;
+}
+
 StringRef MarkupFilter::lineEnding() const {
   return Line.endswith("\r\n") ? "\r\n" : "\n";
 }
 
 bool MarkupFilter::MMap::contains(uint64_t Addr) const {
   return this->Addr <= Addr && Addr < this->Addr + Size;
 }
+
+// Returns the module-relative address for a given virtual address.
+uint64_t MarkupFilter::MMap::getModuleRelativeAddr(uint64_t Addr) const {
+  return Addr - this->Addr + ModuleRelativeAddr;
+}

llvm/test/DebugInfo/symbolize-filter-markup-data.test

+REQUIRES: x86-registered-target
+RUN: split-file %s %t
+RUN: mkdir -p %t/.build-id/ab
+RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t/asm.s \
+RUN:   -o %t/.build-id/ab/cdef.debug
+RUN: llvm-symbolizer --debug-file-directory=%t --filter-markup < %t/input \
+RUN:   > %t.output 2> %t.err
+RUN: FileCheck %s --input-file=%t.output --match-full-lines \
+RUN:   --implicit-check-not {{.}}
+RUN: FileCheck %s --check-prefix=ERR --input-file=%t.err --match-full-lines
+
+CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=abcdef 0x0(r)-0x10(r)[[END:\]{3}]]
+CHECK: long long byte
+CHECK: long byte
+CHECK: [[BEGIN]]data:0x05[[END]]
+
+ERR: error: expected 1 field(s); found 0
+ERR: error: no mmap covers address
+
+;--- input
+{{{module:0:a.o:elf:abcdef}}}
+{{{mmap:0:5:load:0:r:0}}}
+{{{mmap:0x10:2:load:0:r:0x3}}}
+{{{data:0x0}}} {{{data:0x1}}} {{{data:0x4}}}
+{{{data:0x10}}} {{{data:0x11}}}
+
+{{{data}}}
+{{{data:0x5}}}
+;--- asm.s
+long:
+  .long 0x11223344
+  .size l, 4
+byte:
+  .byte 0x42
+  .size b, 1

llvm/test/DebugInfo/symbolize-filter-markup-error-location.test

 RUN: split-file %s %t
 RUN: llvm-symbolizer --filter-markup < %t/log > /dev/null 2> %t.err
 RUN: FileCheck %s -input-file=%t.err --match-full-lines --strict-whitespace
 
-CHECK:error: expected 1 fields; found 0
+CHECK:error: expected 1 field(s); found 0
 CHECK:[[BEGIN:[{]{3}]]symbol[[END:[}]{3}]]
 CHECK:         ^
-CHECK:error: expected 1 fields; found 0
+CHECK:error: expected 1 field(s); found 0
 CHECK:foo[[BEGIN]]symbol[[END]]bar[[BEGIN]]symbol[[END]]baz
 CHECK:            ^
-CHECK:error: expected 1 fields; found 0
+CHECK:error: expected 1 field(s); found 0
 CHECK:foo[[BEGIN]]symbol[[END]]bar[[BEGIN]]symbol[[END]]baz
 CHECK:                           ^
 
 ;--- log
 {{{symbol}}}
 foo{{{symbol}}}bar{{{symbol}}}baz

llvm/test/DebugInfo/symbolize-filter-markup-mmap.test

 RUN: split-file %s %t
 RUN: llvm-symbolizer --filter-markup < %t/log > %t.out 2> %t.err
 RUN: FileCheck %s --input-file=%t.out --match-full-lines \
 RUN:   --implicit-check-not {{.}}
 RUN: FileCheck %s --check-prefix=ERR -input-file=%t.err --match-full-lines
 
 CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=abb50d82b6bdc861 0x0(rwx)-0x1(r)-0x2(w)-0x3(x)-0x4(rwx)-0xa(r)[[END:\]{3}]]
 
-ERR: error: expected at least 3 fields; found 0
+ERR: error: expected at least 3 field(s); found 0
 ERR: error: unknown mmap type
-ERR: error: expected 6 fields; found 3
+ERR: error: expected 6 field(s); found 3
 ERR: error: expected address; found '1'
 ERR: error: expected size; found '-1'
 ERR: error: expected mode; found ''
 ERR: error: expected mode; found 'g'
 ERR: error: expected mode; found 'wr'
 ERR: error: overlapping mmap: #0x0 [0xa,0xc)
 ERR: error: overlapping mmap: #0x0 [0xa,0xc)
 ERR: error: overlapping mmap: #0x0 [0xa,0xc)

llvm/test/DebugInfo/symbolize-filter-markup-module.test

 RUN: split-file %s %t
 RUN: llvm-symbolizer --filter-markup < %t/log > %t.out 2> %t.err
 RUN: FileCheck %s --input-file=%t.out --match-full-lines \
 RUN:   --implicit-check-not {{.}}
 RUN: FileCheck %s --check-prefix=ERR -input-file=%t.err --match-full-lines
 
 CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=ab[[END:\]{3}]]
 CHECK: [[BEGIN]]ELF module #0x1 "b.o"; BuildID=abb50d82b6bdc861[[END]]
 CHECK: [[BEGIN]]ELF module #0x2 "c.o"; BuildID=cd[[END]]
 CHECK: [[BEGIN]]ELF module #0x1 "b.o"; adds 0x0(r)[[END]]
 
-ERR: error: expected at least 3 fields; found 0
+ERR: error: expected at least 3 field(s); found 0
 ERR: error: unknown module type
 ERR: error: duplicate module ID
-ERR: error: expected 4 fields; found 3
+ERR: error: expected 4 field(s); found 3
 
 ;--- log
 {{{module:0:a.o:elf:ab}}}
 {{{module:1:b.o:elf:abb50d82b6bdc861}}}
 {{{module:2:c.o:elf:cd}}}
 {{{mmap:0:10000000:load:1:r:0}}}
 
 {{{module}}}
 {{{module:3:d.o:foo}}}
 {{{module:0:d.o:elf:ef}}}
 {{{module:4:d.o:elf}}}

llvm/test/DebugInfo/symbolize-filter-markup-reset.test

 RUN: split-file %s %t
 RUN: llvm-symbolizer --filter-markup < %t/log > %t.out 2> %t.err
 RUN: FileCheck %s --input-file=%t.out --match-full-lines \
 RUN:   --implicit-check-not {{.}}
 RUN: FileCheck %s --check-prefix=ERR -input-file=%t.err --match-full-lines
 
 CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=ab 0x0(r)[[END:\]{3}]]
 CHECK: {{  }}[[BEGIN]]reset[[END]]
 CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "b.o"; BuildID=cd 0x1(r)[[END:\]{3}]]
 
-ERR: error: expected 0 fields; found 1
+ERR: error: expected 0 field(s); found 1
 
 ;--- log
   {{{reset}}}
 {{{module:0:a.o:elf:ab}}}
 {{{mmap:0:1:load:0:r:0}}}
   {{{reset}}}
 {{{module:0:b.o:elf:cd}}}
 {{{mmap:0x1:1:load:0:r:0}}}
 
 {{{reset:}}}

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

static SmallVector<uint8_t> parseBuildIDArg(const opt::InputArgList &Args,
   if (BuildID.empty()) {
     errs() << A->getSpelling() + ": expected a build ID, but got '" + V + "'\n";
     exit(1);
   }
   return BuildID;
 }
 
 // Symbolize markup from stdin and write the result to stdout.
-static void filterMarkup(const opt::InputArgList &Args) {
-  MarkupFilter Filter(outs(), parseColorArg(Args));
+static void filterMarkup(const opt::InputArgList &Args, LLVMSymbolizer &Symbolizer) {
+  MarkupFilter Filter(outs(), Symbolizer, parseColorArg(Args));
   for (std::string InputString; std::getline(std::cin, InputString);) {
     InputString += '\n';
     Filter.filter(InputString);
   }
   Filter.finish();
 }
 
 ExitOnError ExitOnErr;
for (const opt::Arg *A : Args.filtered(OPT_dsym_hint_EQ)) {
     if (sys::path::extension(Hint) == ".dSYM") {
       Opts.DsymHints.emplace_back(Hint);
     } else {
       errs() << "Warning: invalid dSYM hint: \"" << Hint
              << "\" (must have the '.dSYM' extension).\n";
     }
   }
 
+  LLVMSymbolizer Symbolizer(Opts);
+
   if (Args.hasArg(OPT_filter_markup)) {
-    filterMarkup(Args);
+    filterMarkup(Args, Symbolizer);
     return 0;
   }
 
   auto Style = IsAddr2Line ? OutputStyle::GNU : OutputStyle::LLVM;
   if (const opt::Arg *A = Args.getLastArg(OPT_output_style_EQ)) {
     if (strcmp(A->getValue(), "GNU") == 0)
       Style = OutputStyle::GNU;
     else if (strcmp(A->getValue(), "JSON") == 0)
       Style = OutputStyle::JSON;
     else
       Style = OutputStyle::LLVM;
   }
 
   if (Args.hasArg(OPT_build_id_EQ) && Args.hasArg(OPT_obj_EQ)) {
     errs() << "error: cannot specify both --build-id and --obj\n";
     return EXIT_FAILURE;
   }
   SmallVector<uint8_t> BuildID = parseBuildIDArg(Args, OPT_build_id_EQ);
 
-  LLVMSymbolizer Symbolizer(Opts);
-
   // A debuginfod lookup could succeed if a HTTP client is available and at
   // least one backing URL is configured.
   bool ShouldUseDebuginfodByDefault =
       HTTPClient::isAvailable() &&
       !ExitOnErr(getDefaultDebuginfodUrls()).empty();
   if (Args.hasFlag(OPT_debuginfod, OPT_no_debuginfod,
                    ShouldUseDebuginfodByDefault))
     enableDebuginfod(Symbolizer);
 
   std::unique_ptr<DIPrinter> Printer;
   if (Style == OutputStyle::GNU)
     Printer = std::make_unique<GNUPrinter>(outs(), errs(), Config);
   else if (Style == OutputStyle::JSON)
     Printer = std::make_unique<JSONPrinter>(outs(), Config);
   else
     Printer = std::make_unique<LLVMPrinter>(outs(), errs(), Config);
 
   std::vector<std::string> InputAddresses = Args.getAllArgValues(OPT_INPUT);
   if (InputAddresses.empty()) {
     const int kMaxInputStringLength = 1024;
     char InputString[kMaxInputStringLength];
 
     while (fgets(InputString, sizeof(InputString), stdin)) {
       // Strip newline characters.