[Symbolizer] Add flag to dump process context JSON from markup

[mysterymath]

Summary

This creates a simple JSON format for representing the process contexts
encountered by the markup filter and a flag, --dump-process-context, for
exporting it. Using this flag suppresses the usual symbolized log output
and instead emits this JSON. This provides a machine-readable
representation of the layouts of the processes that emitted the
marked-up logs.

[mysterymath]

Minimize diff.

[mysterymath]

Add check for flag validity.

[jhenderson]

A few minor points from me that I spotted whilst skimming over this due to my herald rule pinging me. I am not familiar enough with the markup stuff to be able to review that.

llvm/test/DebugInfo/symbolize-filter-markup-dump-context.test

5–6 ↗

(On Diff #508252)

You should check that the error message is the expected error message here. Otherwise, these could be failing for an unrelated reason and you wouldn't notice.

9 ↗

(On Diff #508252)

CHECK-NEXT (or CHECK-SAME) here and below?

llvm/tools/llvm-symbolizer/Opts.td

34

Nit: for consistency with other options.

[mysterymath]

Address review comments.

[jhenderson]

Thanks. No more comments from me.

[dblaikie]

"context" as the name for this confuses me a bit - perhaps you can describe it more (maybe I'm jus tthinking about it wrong, or maybe it could benefit from a rename)

When I think of "dumping context" - I think of dumping the text surrounding the symbolizer markup, which it isn't doing. It looks like it's something like "dump markup as json", is that accurate? (& it drops/doesn't print out any of the non-markup content present in the input?)

[phosek]

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

451

For attribute naming, in JSON generated from LLVM tools we typically use either PascalCase or snake_case, camelCase is a bit unusual.

[mysterymath]

In D146854#4227650, @dblaikie wrote:

"context" as the name for this confuses me a bit - perhaps you can describe it more (maybe I'm jus tthinking about it wrong, or maybe it could benefit from a rename)

When I think of "dumping context" - I think of dumping the text surrounding the symbolizer markup, which it isn't doing. It looks like it's something like "dump markup as json", is that accurate? (& it drops/doesn't print out any of the non-markup content present in the input?)

The term "context" comes from the symbolizer markup format: https://llvm.org/docs/SymbolizerMarkupFormat.html#contextual-elements
In this case it's not actually dumping the presentation requests from the markup, it's dumping a completed representation of the process layout contained in the "contextual elements" of the markup. These contextualize virtual addresses to allow symbolizing them later; and it's that contextual information that it'd be useful to export and import into other tools.

[mysterymath]

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

451

I did a quick search around the codebase, and it doesn't look like there's a consistent convention; there's kebab case, pascal case, and camelCase all represented. Didn't really take the time to get accurate counts, but it does seem that various style guides suggest lower camel case:

https://google.github.io/styleguide/jsoncstyleguide.xml
https://jsonapi.org/recommendations/

[mysterymath]

Rebase.

[mysterymath]

Dump name field as well.

[MaskRay]

In D146854#4228721, @mysterymath wrote:

In D146854#4227650, @dblaikie wrote:

"context" as the name for this confuses me a bit - perhaps you can describe it more (maybe I'm jus tthinking about it wrong, or maybe it could benefit from a rename)

When I think of "dumping context" - I think of dumping the text surrounding the symbolizer markup, which it isn't doing. It looks like it's something like "dump markup as json", is that accurate? (& it drops/doesn't print out any of the non-markup content present in the input?)

The term "context" comes from the symbolizer markup format: https://llvm.org/docs/SymbolizerMarkupFormat.html#contextual-elements
In this case it's not actually dumping the presentation requests from the markup, it's dumping a completed representation of the process layout contained in the "contextual elements" of the markup. These contextualize virtual addresses to allow symbolizing them later; and it's that contextual information that it'd be useful to export and import into other tools.

I have the same confusion as well. If there are most significant contextual elements, can their names be mentioned in the help message of --dump-context? Just mentioning the element name should still make the message brief.

llvm/docs/CommandGuide/llvm-symbolizer.rst

247

[mysterymath]

Defined markup contexts briefly in the flag help message and more thoroughly in
the rst documentation.

[mysterymath]

Make --filter-markup a doc reference.

[mysterymath]

Rename "[markup] context" to "process context".

[mcgrathr]

llvm/docs/CommandGuide/llvm-symbolizer.rst

248

I think these should be independent options: that is, you can produce filter output, or JSON output, or both.
To me, it seems reasonable to have the JSON switch take a separate explicit output file and have a separate flag that says whether or not to filtered markup output, e.g. --parse-markup that is implied by --filter-markup but can be specified separately to consume that input (and which is superfluous with --filter-markup and useless without either --filter-markup or --dump-context).

As I mentioned pedantically in another change, I think "process" is actually overly and unnecessarily specific here. Perhaps in the context (pun intention unspecified) of llvm-symbolizer, "context" alone is sufficient, but "address context" also seems pretty clear, specific, and precisely applicable to what matters about it to symbolization.

In the long run, I think it makes sense for this not to even imply --parse-markup because we can and should eventually have other sources for the same kind of information, such as switches like elfutils tools such as eu-unstrip have, for /proc/PID/maps (Linux format) text files, live process IDs (that on systems like Linux means read /proc/PID/maps), ELF core files that have NT_GNU_BUILD_ID notes themselves and/or PT_LOAD memory images with enough ELF data to reconstruct runtime layouts and build IDs post mortem, Linux kernel module layouts, and more not covered in elfutils, like minidump format or whatever else. Of course, there could be separate tools that produce this same JSON schema for each of those things, but for at least some of them building direct command-line switch support that can be used in llvm-symbolizer and other tools will make sense.

I think --parse-markup also has a nice parity with the coming switch to parse this JSON format as the input source.

Furthermore, --parse-markup alone is useful for traditional llvm-symbolizer uses without --filter-markup: I can use --parse-markup=logfile when feeding the symbolizer addresses manually on the command line (or via the stdin protocol if markup input and symbolization-request input formats can come from different explicit inputs since only one or the other can be stdin).

252

When we implement support for the trigger elements (dumpfile), that will be a separate reason to distinguish different context snapshot states. (In between reset elements, trigger elements need to be associated with the context snapshot formed from only the module+mmap elements that were emitted before the trigger element, not later additions/changes.)

So I think it makes sense to preemptively describe it here, and specify the JSON schema, as being an array of context snapshots. In future each one might contain descriptors for additional non-context elements that are to be interpreted in the context of the snapshot they appear in. In fact, it could be an option in the JSON dumper feature even now to include the bt et al that were mentioned as if they were trigger elements. That's really tantamount to implementing trigger elements and then adding another switch that says "make all the presentation elements act as trigger elements" too, so it might as well come after trigger elements. But in how we prepare the schema for future optional expansion, we should think about those cases now even if we take a while to implement them all.

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

35

It seems like it might be a nicer structure to keep this just responsible for the parsing and not the dumping per se.
That is, instead of just a built-in flag here, this could be an optional callback to make with ProcessContext whenever a new one is ready, paired with a flag about whether to produce the transformed version of the input text (that could just be a nullable OS pointer here).

Then a separate ProcessContext->JSON layer can be trivially plumbed to build a callback to pass here.

When you add the JSON input option, then plumbing that to do JSON->ProcessContext->JSON and markup->ProcessContext->JSON and various such combinations as unit tests becomes very attractive.

llvm/docs/CommandGuide/llvm-symbolizer.rst

 .. _llvm-symbolizer-opt-C:
 
 .. option:: --demangle, -C
 
   Print demangled function names, if the names are mangled (e.g. the mangled
   name `_Z3bazv` becomes `baz()`, whilst the non-mangled name `foz` is printed
   as is). Defaults to true.
 
+.. option:: --dump-process-context, --no-dump-process-context
+
+  Only valid with :option:`--filter-markup`. Emits a JSON representation of the
+  encountered process contexts instead of symbolizing the markup. A process
+  context is a map of the process's runtime memory layout obtained from the
+  contextual markup elements, i.e. `module`, `mmap`, etc.
+
+  Markup may have multiple contexts separated by `reset` elements. The contexts
+  are returned as a JSON array of objects, even if only one context is present.
+
 .. option:: --dwp <path>
 
   Use the specified DWP file at ``<path>`` for any CUs that have split DWARF
   debug data.
 
 .. option:: --fallback-debug-path <path>
 
   When a separate file contains debug data, and is referenced by a GNU debug

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_MARKUPFILTER_H
 #define LLVM_DEBUGINFO_SYMBOLIZE_MARKUPFILTER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/Symbolize/Markup.h"
 #include "llvm/Object/BuildID.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace llvm {
 namespace symbolize {
 
 class LLVMSymbolizer;
 
 /// Filter to convert parsed log symbolizer markup elements into human-readable
 /// text.
 class MarkupFilter {
 public:
+  /// @param DumpProcessContext If true, instead of symbolizing the log, emit a
+  ///   JSON representation of the encountered process contexts.
   MarkupFilter(raw_ostream &OS, LLVMSymbolizer &Symbolizer,
-               std::optional<bool> ColorsEnabled = std::nullopt);
+               std::optional<bool> ColorsEnabled = std::nullopt,
+               bool DumpProcessContext = false);
 
   /// 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:
   void filterNode(const MarkupNode &Node);
 
   bool tryPresentation(const MarkupNode &Node);
   bool trySymbol(const MarkupNode &Node);
   bool tryPC(const MarkupNode &Node);
   bool tryBackTrace(const MarkupNode &Node);
   bool tryData(const MarkupNode &Node);
 
+  bool tryTrigger(const MarkupNode &Node);
+
   bool trySGR(const MarkupNode &Node);
 
   void highlight();
   void highlightValue();
   void restoreColor();
   void resetColor();
 
   void printRawElement(const MarkupNode &Element);
   void printValue(Twine Value);
 
+  void dumpProcessContext();
+
   std::optional<Module> parseModule(const MarkupNode &Element) const;
   std::optional<MMap> parseMMap(const MarkupNode &Element) const;
 
   std::optional<uint64_t> parseAddr(StringRef Str) const;
   std::optional<uint64_t> parseModuleID(StringRef Str) const;
   std::optional<uint64_t> parseSize(StringRef Str) const;
   object::BuildID parseBuildID(StringRef Str) const;
   std::optional<std::string> parseMode(StringRef Str) const;
private:
   const MMap *getOverlappingMMap(const MMap &Map) const;
   const MMap *getContainingMMap(uint64_t Addr) const;
 
   uint64_t adjustAddr(uint64_t Addr, PCType Type) const;
 
   StringRef lineEnding() const;
 
   raw_ostream &OS;
+  std::unique_ptr<json::OStream> JOS;
   LLVMSymbolizer &Symbolizer;
   const bool ColorsEnabled;
 
   MarkupParser Parser;
 
   // Current line being filtered.
   StringRef Line;
 

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

 #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/Format.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 using namespace llvm;
 using namespace llvm::symbolize;
 
 MarkupFilter::MarkupFilter(raw_ostream &OS, LLVMSymbolizer &Symbolizer,
-                           std::optional<bool> ColorsEnabled)
+                           std::optional<bool> ColorsEnabled,
+                           bool DumpProcessContext)
     : OS(OS), Symbolizer(Symbolizer),
       ColorsEnabled(
-          ColorsEnabled.value_or(WithColor::defaultAutoDetectFunction()(OS))) {}
+          ColorsEnabled.value_or(WithColor::defaultAutoDetectFunction()(OS))) {
+  if (DumpProcessContext) {
+    ColorsEnabled = false;
+    JOS = std::make_unique<json::OStream>(OS, /*Indent=*/2);
+    JOS->arrayBegin();
+  }
+}
 
 void MarkupFilter::filter(StringRef Line) {
   this->Line = Line;
   resetColor();
 
   Parser.parseLine(Line);
   SmallVector<MarkupNode> DeferredNodes;
   // See if the line is a contextual (i.e. contains a contextual element).

 }
 
 void MarkupFilter::finish() {
   Parser.flush();
   while (std::optional<MarkupNode> Node = Parser.nextNode())
     filterNode(*Node);
   endAnyModuleInfoLine();
   resetColor();
+  if (JOS) {
+    dumpProcessContext();
+    JOS->arrayEnd();
+    OS << '\n';
+  }
   Modules.clear();
   MMaps.clear();
 }
 
 // See if the given node is a contextual element and handle it if so. This may
 // either output or defer the element; in the former case, it will first emit
 // any DeferredNodes.
 //
bool MarkupFilter::tryMMap(const MarkupNode &Node,
   assert(Res.second && "Overlap check should ensure emplace succeeds.");
   MMap &MMap = Res.first->second;
 
   if (!MIL || MIL->Mod != MMap.Mod) {
     endAnyModuleInfoLine();
     for (const MarkupNode &Node : DeferredNodes)
       filterNode(Node);
     beginModuleInfoLine(MMap.Mod);
+    if (!JOS)
       OS << "; adds";
   }
   MIL->MMaps.push_back(&MMap);
   return true;
 }
 
 bool MarkupFilter::tryReset(const MarkupNode &Node,
                             const SmallVector<MarkupNode> &DeferredNodes) {
   if (Node.Tag != "reset")
     return false;
   if (!checkNumFields(Node, 0))
     return true;
 
+  if (JOS)
+    dumpProcessContext();
+
   if (!Modules.empty() || !MMaps.empty()) {
     endAnyModuleInfoLine();
     for (const MarkupNode &Node : DeferredNodes)
       filterNode(Node);
+
+    if (!JOS) {
       highlight();
       OS << "[[[reset]]]" << lineEnding();
       restoreColor();
+    }
 
     Modules.clear();
     MMaps.clear();
   }
   return true;
 }
 
 bool MarkupFilter::tryModule(const MarkupNode &Node,
if (!Res.second) {
     return true;
   }
   Module &Module = *Res.first->second;
 
   endAnyModuleInfoLine();
   for (const MarkupNode &Node : DeferredNodes)
     filterNode(Node);
   beginModuleInfoLine(&Module);
+  if (!JOS) {
     OS << "; BuildID=";
     printValue(toHex(Module.BuildID, /*LowerCase=*/true));
+  }
   return true;
 }
 
 void MarkupFilter::beginModuleInfoLine(const Module *M) {
+  if (!JOS) {
     highlight();
     OS << "[[[ELF module";
     printValue(formatv(" #{0:x} ", M->ID));
     OS << '"';
     printValue(M->Name);
     OS << '"';
+  }
   MIL = ModuleInfoLine{M};
 }
 
 void MarkupFilter::endAnyModuleInfoLine() {
   if (!MIL)
     return;
+  if (!JOS) {
     llvm::stable_sort(MIL->MMaps, [](const MMap *A, const MMap *B) {
       return A->Addr < B->Addr;
     });
     for (const MMap *M : MIL->MMaps) {
       OS << (M == MIL->MMaps.front() ? ' ' : ',');
       OS << '[';
       printValue(formatv("{0:x}", M->Addr));
       OS << '-';
       printValue(formatv("{0:x}", M->Addr + M->Size - 1));
       OS << "](";
       printValue(M->Mode);
       OS << ')';
     }
     OS << "]]]" << lineEnding();
     restoreColor();
+  }
   MIL.reset();
 }
 
 // Handle a node that is known not to be a contextual element.
 void MarkupFilter::filterNode(const MarkupNode &Node) {
   if (!checkTag(Node))
     return;
+  if (JOS)
+    return;
   if (tryPresentation(Node))
     return;
   if (trySGR(Node))
     return;
 
   OS << Node.Text;
 }
 
bool MarkupFilter::tryData(const MarkupNode &Node) {
   }
 
   highlight();
   OS << Symbol->Name;
   restoreColor();
   return true;
 }
 
+void MarkupFilter::dumpProcessContext() {
+  JOS->object([&] {
+    JOS->attributeArray("modules", [&] {
+      for (const auto &[_, Module] : Modules) {
+        JOS->objectBegin();
+        JOS->attribute("id", Module->ID);
+        JOS->attribute("name", Module->Name);
+        JOS->attribute("type", "elf");
+        JOS->attribute("buildID", toHex(Module->BuildID, /*LowerCase=*/true));
+        JOS->objectEnd();
+      }
+    });
+    JOS->attributeArray("mmaps", [&] {
+      for (const auto &[_, Map] : MMaps) {
+        JOS->objectBegin();
+        JOS->attribute("address", Map.Addr);
+        JOS->attribute("size", Map.Size);
+        JOS->attribute("type", "load");
+        JOS->attribute("moduleID", Map.Mod->ID);
+        JOS->attribute("mode", Map.Mode);
+        JOS->attribute("moduleRelativeAddress", Map.ModuleRelativeAddr);
+        JOS->objectEnd();
+      }
+    });
+  });
+}
+
 bool MarkupFilter::trySGR(const MarkupNode &Node) {
   if (Node.Text == "\033[0m") {
     resetColor();
     return true;
   }
   if (Node.Text == "\033[1m") {
     Bold = true;
     if (ColorsEnabled)

llvm/test/DebugInfo/symbolize-filter-markup-dump-process-context.test

+RUN: split-file %s %t
+RUN: llvm-symbolizer --filter-markup --dump-process-context < %t/log > %t.out
+RUN: FileCheck %s --input-file=%t.out --match-full-lines \
+RUN:   --implicit-check-not {{.}}
+RUN: not llvm-symbolizer --dump-process-context 2>&1 | FileCheck --match-full-lines --implicit-check-not {{.}} --check-prefix ERR %s
+RUN: not llvm-symbolizer --no-dump-process-context 2>&1 | FileCheck --match-full-lines --implicit-check-not {{.}} --check-prefix ERR %s
+
+CHECK:      [
+CHECK-NEXT:   {
+CHECK-NEXT:     "modules": [
+CHECK-NEXT:       {
+CHECK-NEXT:         "id": 0,
+CHECK-NEXT:         "name": "b.o",
+CHECK-NEXT:         "type": "elf",
+CHECK-NEXT:         "buildID": "ab"
+CHECK-NEXT:       },
+CHECK-NEXT:       {
+CHECK-NEXT:         "id": 1,
+CHECK-NEXT:         "name": "a.o",
+CHECK-NEXT:         "type": "elf",
+CHECK-NEXT:         "buildID": "cd"
+CHECK-NEXT:       }
+CHECK-NEXT:     ],
+CHECK-NEXT:     "mmaps": [
+CHECK-NEXT:       {
+CHECK-NEXT:         "address": 16,
+CHECK-NEXT:         "size": 16,
+CHECK-NEXT:         "type": "load",
+CHECK-NEXT:         "moduleID": 1,
+CHECK-NEXT:         "mode": "r",
+CHECK-NEXT:         "moduleRelativeAddress": 2
+CHECK-NEXT:       },
+CHECK-NEXT:       {
+CHECK-NEXT:         "address": 32,
+CHECK-NEXT:         "size": 48,
+CHECK-NEXT:         "type": "load",
+CHECK-NEXT:         "moduleID": 1,
+CHECK-NEXT:         "mode": "w",
+CHECK-NEXT:         "moduleRelativeAddress": 3
+CHECK-NEXT:       },
+CHECK-NEXT:       {
+CHECK-NEXT:         "address": 80,
+CHECK-NEXT:         "size": 96,
+CHECK-NEXT:         "type": "load",
+CHECK-NEXT:         "moduleID": 0,
+CHECK-NEXT:         "mode": "rx",
+CHECK-NEXT:         "moduleRelativeAddress": 4
+CHECK-NEXT:       }
+CHECK-NEXT:     ]
+CHECK-NEXT:   },
+CHECK-NEXT:   {
+CHECK-NEXT:     "modules": [
+CHECK-NEXT:       {
+CHECK-NEXT:         "id": 0,
+CHECK-NEXT:         "name": "c.o",
+CHECK-NEXT:         "type": "elf",
+CHECK-NEXT:         "buildID": "ef"
+CHECK-NEXT:       }
+CHECK-NEXT:     ],
+CHECK-NEXT:     "mmaps": []
+CHECK-NEXT:   }
+CHECK-NEXT: ]
+
+ERR: error: --[no-]dump-process-context can only be used with --filter-markup
+
+;--- log
+{{{module:1:a.o:elf:cd}}}
+{{{module:0:b.o:elf:ab}}}
+{{{mmap:0x10:0x10:load:1:r:0x2}}}
+{{{mmap:0x20:0x30:load:1:w:0x3}}}
+{{{mmap:0x50:0x60:load:0:rx:0x4}}}
+{{{pc:0x20}}}
+{{{reset}}}
+{{{module:0:c.o:elf:ef}}}

llvm/tools/llvm-symbolizer/Opts.td

 def color : F<"color", "Use color when symbolizing log markup.">;
 def color_EQ : Joined<["--"], "color=">, HelpText<"Whether to use color when symbolizing log markup: always, auto, never">, Values<"always,auto,never">;
 defm debug_file_directory : Eq<"debug-file-directory", "Path to directory where to look for debug files">, MetaVarName<"<dir>">;
 defm debuginfod : B<"debuginfod", "Use debuginfod to find debug binaries", "Don't use debuginfod to find debug binaries">;
 defm default_arch
     : Eq<"default-arch", "Default architecture (for multi-arch objects)">,
       Group<grp_mach_o>;
 defm demangle : B<"demangle", "Demangle function names", "Don't demangle function names">;
+defm dump_process_context : B<"dump-process-context", "Dump process context JSON from markup instead of symbolizing", "Don't dump process contexts">;
 def filter_markup : Flag<["--"], "filter-markup">, HelpText<"Filter symbolizer markup from stdin.">;
 def functions : F<"functions", "Print function name for a given address">;
 def functions_EQ : Joined<["--"], "functions=">, HelpText<"Print function name for a given address">, Values<"none,short,linkage">;
 def help : F<"help", "Display this help">;
 defm dwp : Eq<"dwp", "Path to DWP file to be use for any split CUs">, MetaVarName<"<file>">;
 defm dsym_hint
     : Eq<"dsym-hint",
          "Path to .dSYM bundles to search for debug info for the object files">,

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

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, LLVMSymbolizer &Symbolizer) {
-  MarkupFilter Filter(outs(), Symbolizer, parseColorArg(Args));
+  MarkupFilter Filter(outs(), Symbolizer, parseColorArg(Args),
+                      Args.hasFlag(OPT_dump_process_context,
+                                   OPT_no_dump_process_context, false));
   std::string InputString;
   while (std::getline(std::cin, InputString)) {
     InputString += '\n';
     Filter.filter(InputString);
   }
   Filter.finish();
 }
 
#endif
   if (Args.hasFlag(OPT_debuginfod, OPT_no_debuginfod, canUseDebuginfod()))
     enableDebuginfod(Symbolizer, Args);
 
   if (Args.hasArg(OPT_filter_markup)) {
     filterMarkup(Args, Symbolizer);
     return 0;
   }
 
+  if (Args.hasArg(OPT_dump_process_context) ||
+      Args.hasArg(OPT_no_dump_process_context)) {
+    errs() << "error: --[no-]dump-process-context can only be used with "
+              "--filter-markup\n";
+    return EXIT_FAILURE;
+  }
+
   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;