Add support for YAML output style to llvm-symbolizer

[aorlov]

Summary

This patch adds YAML output style to llvm-symbolizer to better support CLI automation by providing a machine readable output.

[dblaikie]

Generally doesn't seem too bad to me, but I hope to hear others weigh in as well.

Is this all of it? or are there more patches you're expecting to need for this to meet your needs?

[jhenderson]

Please remember to upload your diffs with full context, as per this article: https://llvm.org/docs/Phabricator.html.

You'll need to document the new output style in the llvm-symbolizer and llvm-addr2line documentation located in llvm\docs\CommandGuide, preferably with one or more examples.

How does this new output style interact with existing options (I'm thinking -p, -a, -i and any other option that affects the output)? What about DATA etc output? You need testing which shows this interaction.

You also need testing for addresses not found.

If we're going to add support for this, I don't think in YAML output mode that it's a good idea to print lines of output that aren't part of the YAML (in this case the "some text" lines which correspond to invalid input addresses).

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

42

What's this for? clang-tidy is complaining it is unused.

166

i -> I to match LLVM style.

llvm/test/tools/llvm-symbolizer/output-style-yaml.test

2–26

It's somewhat traditional for tests I've seen to have comment markers for all lit and FileCheck lines, plus genuine comments, even if they aren't really needed. This makes it easier to maintain them going forwards too.

In this case, I'd add ## for the real comment line, and # before each RUN and CHECK line (with the space between # and the start of the rest of the line in all cases).

4

Add a matching line for llvm-addr2line --output-style=YAML too, to show the different default can still be overridden.

[aorlov]

Thanks for the comments, James! I’ll post the updated patch shortly.

David, yes, the change seems relatively small and looks clean with all the YAML support we already have in LLVM.

I expect a couple more patches. One will add a few additional data fields requested by our users, and then, I think, something will come up upon real world usage.

[aorlov]

I have updated the patch. It

• addresses the review comments,
• adds more tests for YAML output style similar to the existing tests we have for other output styles. In particular output-style-yaml-data.test is based on untag-addresses.test, output-style-yaml-frame.test is based on frame-types.s.
• updates llvm-symbolizer documentation.

Unless I’m missing something, addr2line documentation is not affected, as it just provides a reference to the llvm-symbolizer doc, which is changed by this patch.

By the way, while looking at the addr2line documentation, I have noticed that the documentation does not match the code. In particular, -f flag is ignored for llvm-adr2line. This issue is out of the scope of this patch, though.

[jhenderson]

I've still got to review the testing further, but here are some comments for now.

As a tip, once you have addressed an inline comment, mark it as done, by clicking the checkbox on the comment, before uploading your latest patch version, as it will make it easier to see what you've attempted to address already.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

43

Please reformat using clang-format, as per the linter comment.

Why add the llvm:: namespace qualifier? You're already in the llvm namespace and use DILineInfo in the function signature without it.

Same goes elsewhere below.

116

Re. the comment - I wonder if that's a bug in the << implementation? Does it need a const adding to its signature, or does that break other things?

llvm/test/tools/llvm-symbolizer/output-style-yaml-data.test

2

8

This could be simplified slightly, I believe, as shown in the inline edit.

It would also be a good idea to add --strict-whitespace, --match-full-lines and --implicit-check-not={{.}} to ensure that the output tested exactly matches what you expect.

--strict-whitespace ensures strings of multiple whitespace characters are not converted to a single space (in both input and check patterns), --match-full-lines ensures each check line matches the entirety of an input line, and --implicit-check-not in this case ensures there's no output apart from what is being explicitly checked for.

10–13

A slight snag with the above suggestion is that the space between the ':' and the start of the check needs to go. You can make it look a little nicer by indenting the first CHECK line to line up the colons as shown in the inline edit.

llvm/test/tools/llvm-symbolizer/output-style-yaml-frame.test

2

8

Same comments as the DATA test apply here.

[MaskRay]

The line based output can be straightforwardly parsed, e.g. https://github.com/google/pprof/blob/master/internal/binutils/addr2liner_llvm.go#L113

There is a question on https://github.com/google/pprof/issues/606 : why is JSON picked over YAML? "JSON is a more common choice for machine-readable output. YAML is used more as a configuration language - i.e. human-read and -written."

[aorlov]

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

43

I added redundant llvm:: to see if that would make a pre-commit Debian bot happy. It didn’t, so I removed.

116

You are right, this lookd strange, however changing this is out of the scope of this patch.
My solution is based on the following code
https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clangd/index/YAMLSerialization.cpp#L493

[aorlov]

In D96289#2560919, @MaskRay wrote:

The line based output can be straightforwardly parsed

And this is fine. I do not see how this patch could prevent your users from parsing the line based output. It is quite the opposite, they are even better protected, as any change in YAML output style would not change what they depend on.

[MaskRay]

In D96289#2562717, @aorlov wrote:

In D96289#2560919, @MaskRay wrote:

The line based output can be straightforwardly parsed

And this is fine. I do not see how this patch could prevent your users from parsing the line based output. It is quite the opposite, they are even better protected, as any change in YAML output style would not change what they depend on.

It is not that this patch could prevent my users. It is my question about whether the YAML output adds new value.

• Most users parse the line based output, as they did with addr2line. There is a --verbose option which can make the output less ambiguous. https://github.com/google/pprof/blob/master/internal/binutils/addr2liner_llvm.go#L113 is an example how easy/robust it is. (The Go tool is used by many groups in production.)
• Users want a lot of flexibility - they should use the DebugInfo/Symbolize APIs.

The two cover the spectrum I can think of. If really we need an interchange format (I have some doubts, after asking others, so it is not my own opinion), JSON seems a better choice.

[jhenderson]

In D96289#2563945, @MaskRay wrote:

In D96289#2562717, @aorlov wrote:

In D96289#2560919, @MaskRay wrote:

The line based output can be straightforwardly parsed

• Most users parse the line based output, as they did with addr2line. There is a --verbose option which can make the output less ambiguous. https://github.com/google/pprof/blob/master/internal/binutils/addr2liner_llvm.go#L113 is an example how easy/robust it is. (The Go tool is used by many groups in production.)

I don't really have any particular stake in this either way. I know our users in the past have wanted GNU addr2line-compatible output, which implies that they parse the output directly, and already have scripts to do so. Indeed the symbolizer is possibly the most commonly used tool from the smaller tools used by our end users. On the one hand, a JSON or YAML output would make new users' jobs simpler because it's easier to work with such output than having to manually write a parser. On the other hand, as you've pointed out, writing the parser for it isn't that complicated. Is it really worth us carrying the maintenance burden for this additional output style? I'm not opposed if there have been end user requests for it.

• Users want a lot of flexibility - they should use the DebugInfo/Symbolize APIs.

This only works if a user is writing their parsing in C++, right? That being said, I don't know if there are any real users for this situation who wouldn't be building using the LLVM libraries.

The two cover the spectrum I can think of. If really we need an interchange format (I have some doubts, after asking others, so it is not my own opinion), JSON seems a better choice.

Having given it more thought, +1 to using JSON over YAML. JSON has the advantage that it can be consumed directly by native python, without needing additional modules, and python is a regular choice for people writing scripts to parse output like this.

[dblaikie]

In D96289#2564889, @jhenderson wrote:

In D96289#2563945, @MaskRay wrote:

The two cover the spectrum I can think of. If really we need an interchange format (I have some doubts, after asking others, so it is not my own opinion), JSON seems a better choice.

Having given it more thought, +1 to using JSON over YAML. JSON has the advantage that it can be consumed directly by native python, without needing additional modules, and python is a regular choice for people writing scripts to parse output like this.

Given we already have YAML APIs in LLVM, there's some convenience/reduced cost (for perhaps an already marginal use case, I'd rather keep the code complexity lower - and this seems pretty low at the moment) to sticking with that, I think? Or is there some equivalently tidy way to emit JSON?

[jhenderson]

In D96289#2566187, @dblaikie wrote:

In D96289#2564889, @jhenderson wrote:

In D96289#2563945, @MaskRay wrote:

The two cover the spectrum I can think of. If really we need an interchange format (I have some doubts, after asking others, so it is not my own opinion), JSON seems a better choice.

Having given it more thought, +1 to using JSON over YAML. JSON has the advantage that it can be consumed directly by native python, without needing additional modules, and python is a regular choice for people writing scripts to parse output like this.

Given we already have YAML APIs in LLVM, there's some convenience/reduced cost (for perhaps an already marginal use case, I'd rather keep the code complexity lower - and this seems pretty low at the moment) to sticking with that, I think? Or is there some equivalently tidy way to emit JSON?

I've not looked too much in detail, but there's JSON.h in the Support library. A casual glance suggests this will have most of what is needed, so using JSON shouldn't be significantly different in terms of additional complexity, compared to using YAML.

[aorlov]

Here is the patch for supporting JSON - https://reviews.llvm.org/D96883
Now we can look at the changes side by side and decide which one is the way to go.

Thanks for reviewing!

[dblaikie]

In D96289#2567701, @jhenderson wrote:

In D96289#2566187, @dblaikie wrote:

In D96289#2564889, @jhenderson wrote:

In D96289#2563945, @MaskRay wrote:

The two cover the spectrum I can think of. If really we need an interchange format (I have some doubts, after asking others, so it is not my own opinion), JSON seems a better choice.

Having given it more thought, +1 to using JSON over YAML. JSON has the advantage that it can be consumed directly by native python, without needing additional modules, and python is a regular choice for people writing scripts to parse output like this.

Given we already have YAML APIs in LLVM, there's some convenience/reduced cost (for perhaps an already marginal use case, I'd rather keep the code complexity lower - and this seems pretty low at the moment) to sticking with that, I think? Or is there some equivalently tidy way to emit JSON?

I've not looked too much in detail, but there's JSON.h in the Support library. A casual glance suggests this will have most of what is needed, so using JSON shouldn't be significantly different in terms of additional complexity, compared to using YAML.

Oh, fair enough - I don't mind either way, then.

llvm/docs/CommandGuide/llvm-symbolizer.rst

 
 .. option:: --obj <path>, --exe, -e
 
   Path to object file to be symbolized. If ``-`` is specified, read the object
   directly from the standard input stream.
 
 .. _llvm-symbolizer-opt-output-style:
 
-.. option:: --output-style <LLVM|GNU>
+.. option:: --output-style <LLVM|GNU|YAML>
 
   Specify the preferred output style. Defaults to ``LLVM``. When the output
   style is set to ``GNU``, the tool follows the style of GNU's **addr2line**.
   The differences from the ``LLVM`` style are:
   
   * Does not print the column of a source code location.
 
   * Does not add an empty line after the report for an address.
 
   * Does not replace the name of an inlined function with the name of the
     topmost caller when inlined frames are not shown and :option:`--use-symbol-table`
     is on.
 
   * Prints an address's debug-data discriminator when it is non-zero. One way to
     produce discriminators is to compile with clang's -fdebug-info-for-profiling.
 
+  ``YAML`` style provides a machine readable output.
+
   .. code-block:: console
 
     $ llvm-symbolizer --obj=inlined.elf 0x4004be 0x400486 -p
     baz() at /tmp/test.cpp:11:18
      (inlined by) main at /tmp/test.cpp:15:0
 
     foo() at /tmp/test.cpp:6:3
 
     $ llvm-symbolizer --output-style=LLVM --obj=inlined.elf 0x4004be 0x400486 -p --no-inlines
     main at /tmp/test.cpp:11:18
 
     foo() at /tmp/test.cpp:6:3
 
     $ llvm-symbolizer --output-style=GNU --obj=inlined.elf 0x4004be 0x400486 -p --no-inlines
     baz() at /tmp/test.cpp:11
     foo() at /tmp/test.cpp:6
 
     $ clang -g -fdebug-info-for-profiling test.cpp -o profiling.elf
     $ llvm-symbolizer --output-style=GNU --obj=profiling.elf 0x401167 -p --no-inlines
     main at /tmp/test.cpp:15 (discriminator 2)
 
+    $ llvm-symbolizer --output-style=YAML --obj=inlined.elf 0x4004be 0x400486
+    ---
+    Frames:
+      - FunctionName:    'baz()'
+        StartFileName:   '/tmp/test.cpp'
+        StartLine:       9
+        FileName:        '/tmp/test.cpp'
+        Line:            11
+        Column:          18
+      - FunctionName:    main
+        StartFileName:   '/tmp/test.cpp'
+        StartLine:       14
+        FileName:        '/tmp/test.cpp'
+        Line:            15
+        Column:          0
+    ...
+    ---
+    Frames:
+      - FunctionName:    'foo()'
+        StartFileName:   '/tmp/test.cpp'
+        StartLine:       5
+        FileName:        '/tmp/test.cpp'
+        Line:            6
+        Column:          3
+    ...
+
+    $ llvm-symbolizer --output-style=YAML --obj=inlined.elf 0x4004be 0x400486 --no-inlines 
+    ---
+    FunctionName:    main
+    StartFileName:   '/tmp/test.cpp'
+    StartLine:       9
+    FileName:        '/tmp/test.cpp'
+    Line:            11
+    Column:          18
+    ...
+    ---
+    FunctionName:    'foo()'
+    StartFileName:   '/tmp/test.cpp'
+    StartLine:       5
+    FileName:        '/tmp/test.cpp'
+    Line:            6
+    Column:          3
+    ...
+
 .. option:: --pretty-print, -p
 
   Print human readable output. If :option:`--inlining` is specified, the
   enclosing scope is prefixed by (inlined by).
 
   .. code-block:: console
 
     $ llvm-symbolizer --obj=inlined.elf 0x4004be --inlining --pretty-print

llvm/include/llvm/DebugInfo/Symbolize/DIPrinter.h

 struct DIGlobal;
 struct DILocal;
 class raw_ostream;
 
 namespace symbolize {
 
 class DIPrinter {
 public:
-  enum class OutputStyle { LLVM, GNU };
+  enum class OutputStyle { LLVM, GNU, YAML };
 
 private:
   raw_ostream &OS;
   bool PrintFunctionNames;
   bool PrintPretty;
   int PrintSourceContext;
   bool Verbose;
   OutputStyle Style;

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(DILineInfo)
+struct DIInliningInfoYaml {
+  std::vector<llvm::DILineInfo> Frames;
+};
+
 namespace llvm {
+
+namespace yaml {
+
+template <> struct MappingTraits<DILineInfo> {
+  static void mapping(IO &IO, DILineInfo &Value) {
+    IO.mapOptional("Source", Value.Source);
+    IO.mapOptional("FunctionName", Value.FunctionName, DILineInfo::BadString);
+    IO.mapOptional("StartFileName", Value.StartFileName, DILineInfo::BadString);
+    IO.mapOptional("StartLine", Value.StartLine, 0);
+    IO.mapOptional("FileName", Value.FileName, DILineInfo::BadString);
+    IO.mapOptional("Line", Value.Line, 0);
+    IO.mapOptional("Column", Value.Column, 0);
+    IO.mapOptional("Discriminator", Value.Discriminator, 0);
+  }
+};
+
+template <> struct MappingTraits<DIInliningInfoYaml> {
+  static void mapping(IO &IO, DIInliningInfoYaml &Value) {
+    IO.mapRequired("Frames", Value.Frames);
+  }
+};
+
+template <> struct MappingTraits<DIGlobal> {
+  static void mapping(IO &IO, DIGlobal &Value) {
+    IO.mapOptional("Name", Value.Name, DILineInfo::BadString);
+    IO.mapOptional("Start", Value.Start, 0);
+    IO.mapOptional("Size", Value.Size, 0);
+  }
+};
+
+template <> struct MappingTraits<DILocal> {
+  static void mapping(IO &IO, DILocal &Value) {
+    IO.mapOptional("FunctionName", Value.FunctionName, "");
+    IO.mapOptional("Name", Value.Name, "");
+    IO.mapOptional("DeclFile", Value.DeclFile, "");
+    IO.mapOptional("DeclLine", Value.DeclLine, 0);
+    IO.mapOptional("FrameOffset", Value.FrameOffset);
+    IO.mapOptional("Size", Value.Size);
+    IO.mapOptional("TagOffset", Value.TagOffset);
+  }
+};
+
+} // namespace yaml
+
 namespace symbolize {
 
 // Prints source code around in the FileName the Line.
 void DIPrinter::printContext(const std::string &FileName, int64_t Line) {
   if (PrintSourceContext <= 0)
     return;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
if (L >= FirstLine && L <= LastLine) {
       else
         OS << "  : ";
       OS << *I << "\n";
     }
   }
 }
 
 void DIPrinter::print(const DILineInfo &Info, bool Inlined) {
+  if (Style == OutputStyle::YAML) {
+    yaml::Output YOut(OS);
+    DILineInfo Val = Info; // copy: YOut<< requires mutability.
+    YOut << Val;
+    return;
+  }
+
   if (PrintFunctionNames) {
     std::string FunctionName = Info.FunctionName;
     if (FunctionName == DILineInfo::BadString)
       FunctionName = DILineInfo::Addr2LineBadString;
 
     StringRef Delimiter = PrintPretty ? " at " : "\n";
     StringRef Prefix = (PrintPretty && Inlined) ? " (inlined by) " : "";
     OS << Prefix << FunctionName << Delimiter;

 
 DIPrinter &DIPrinter::operator<<(const DILineInfo &Info) {
   print(Info, false);
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DIInliningInfo &Info) {
   uint32_t FramesNum = Info.getNumberOfFrames();
+
+  if (Style == OutputStyle::YAML) {
+    yaml::Output YOut(OS);
+    DIInliningInfoYaml Val;
+    for (uint32_t I = 0; I < FramesNum; I++)
+      Val.Frames.push_back(Info.getFrame(I));
+    YOut << Val;
+    return *this;
+  }
+
   if (FramesNum == 0) {
     print(DILineInfo(), false);
     return *this;
   }
-  for (uint32_t i = 0; i < FramesNum; i++)
-    print(Info.getFrame(i), i > 0);
+  for (uint32_t I = 0; I < FramesNum; I++)
+    print(Info.getFrame(I), I > 0);
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DIGlobal &Global) {
+  if (Style == OutputStyle::YAML) {
+    yaml::Output YOut(OS);
+    DIGlobal Val = Global; // copy: YOut<< requires mutability.
+    YOut << Val;
+    return *this;
+  }
+
   std::string Name = Global.Name;
   if (Name == DILineInfo::BadString)
     Name = DILineInfo::Addr2LineBadString;
   OS << Name << "\n";
   OS << Global.Start << " " << Global.Size << "\n";
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DILocal &Local) {
+  if (Style == OutputStyle::YAML) {
+    yaml::Output YOut(OS);
+    DILocal Val = Local; // copy: YOut<< requires mutability.
+    YOut << Val;
+    return *this;
+  }
+
   if (Local.FunctionName.empty())
     OS << "??\n";
   else
     OS << Local.FunctionName << '\n';
 
   if (Local.Name.empty())
     OS << "??\n";
   else

llvm/test/tools/llvm-symbolizer/output-style-yaml-data.test

+## This test checks YAML output for DATA.
+
+# REQUIRES: x86-registered-target
+
+## Test YAML output style of DIGlobal.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: llvm-symbolizer "DATA %t.o 0" --output-style=YAML \
+# RUN:   | FileCheck %s --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      CHECK:---
+# CHECK-NEXT:Name:            foo
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+
+.data
+.globl foo
+.type foo, @object
+.size foo, 4
+foo = . + 0x1100000000000000
+.4byte 1

llvm/test/tools/llvm-symbolizer/output-style-yaml-frame.test

+## This test checks YAML output for FRAME.
+
+# REQUIRES: x86-registered-target
+
+## Test YAML output style of DILocal.
+# RUN: llvm-mc -filetype=obj -triple=i386-linux-gnu -o %t.o %s
+# RUN: llvm-symbolizer "FRAME %t.o 0" --output-style=YAML \
+# RUN:   | FileCheck %s --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      CHECK:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            a
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        4
+# CHECK-NEXT:FrameOffset:     -1
+# CHECK-NEXT:Size:            1
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            b
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        5
+# CHECK-NEXT:FrameOffset:     -8
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            c
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        6
+# CHECK-NEXT:FrameOffset:     -12
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            d
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        7
+# CHECK-NEXT:FrameOffset:     -16
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            e
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        8
+# CHECK-NEXT:FrameOffset:     -32
+# CHECK-NEXT:Size:            8
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            f
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        9
+# CHECK-NEXT:FrameOffset:     -36
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            g
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        10
+# CHECK-NEXT:FrameOffset:     -37
+# CHECK-NEXT:Size:            1
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            h
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        11
+# CHECK-NEXT:FrameOffset:     -38
+# CHECK-NEXT:Size:            1
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            i
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        12
+# CHECK-NEXT:FrameOffset:     -44
+# CHECK-NEXT:Size:            4
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            j
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        14
+# CHECK-NEXT:FrameOffset:     -45
+# CHECK-NEXT:Size:            1
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            k
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        15
+# CHECK-NEXT:FrameOffset:     -57
+# CHECK-NEXT:Size:            12
+# CHECK-NEXT:...
+# CHECK-NEXT:---
+# CHECK-NEXT:FunctionName:    f
+# CHECK-NEXT:Name:            l
+# CHECK-NEXT:DeclFile:        '/tmp{{/|\\}}frame-types.cpp'
+# CHECK-NEXT:DeclLine:        16
+# CHECK-NEXT:FrameOffset:     -345
+# CHECK-NEXT:Size:            288
+# CHECK-NEXT:...
+
+## Generated from:
+##
+## struct S;
+##
+## void f() {
+##   char a;
+##   char *b;
+##   char &c = a;
+##   char &&d = 1;
+##   char (S::*e)();
+##   char S::*f;
+##   const char g = 2;
+##   volatile char h;
+##   char *__restrict i;
+##   typedef char char_typedef;
+##   char_typedef j;
+##   char k[12];
+##   char l[12][24];
+## }
+##
+## clang++ --target=i386-linux-gnu frame-types.cpp -g -std=c++11 -S -o frame-types.s 
+
+  .text
+  .file "frame-types.cpp"
+  .globl  _Z1fv                   # -- Begin function _Z1fv
+  .p2align  4, 0x90
+  .type _Z1fv,@function
+_Z1fv:                                  # @_Z1fv
+.Lfunc_begin0:
+  .file 1 "/tmp" "frame-types.cpp"
+  .loc  1 3 0                   # frame-types.cpp:3:0
+  .cfi_sections .debug_frame
+  .cfi_startproc
+# %bb.0:                                # %entry
+  pushl %ebp
+  .cfi_def_cfa_offset 8
+  .cfi_offset %ebp, -8
+  movl  %esp, %ebp
+  .cfi_def_cfa_register %ebp
+  subl  $352, %esp              # imm = 0x160
+.Ltmp0:
+  .loc  1 6 9 prologue_end      # frame-types.cpp:6:9
+  leal  -1(%ebp), %eax
+.Ltmp1:
+  #DEBUG_VALUE: f:a <- [$eax+0]
+  movl  %eax, -12(%ebp)
+  .loc  1 7 14                  # frame-types.cpp:7:14
+  movb  $1, -17(%ebp)
+  .loc  1 7 10 is_stmt 0        # frame-types.cpp:7:10
+  leal  -17(%ebp), %eax
+.Ltmp2:
+  movl  %eax, -16(%ebp)
+  .loc  1 10 14 is_stmt 1       # frame-types.cpp:10:14
+  movb  $2, -37(%ebp)
+  .loc  1 17 1                  # frame-types.cpp:17:1
+  addl  $352, %esp              # imm = 0x160
+  popl  %ebp
+  .cfi_def_cfa %esp, 4
+  retl
+.Ltmp3:
+.Lfunc_end0:
+  .size _Z1fv, .Lfunc_end0-_Z1fv
+  .cfi_endproc
+                                        # -- End function
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 9.0.0 "  # string offset=0
+.Linfo_string1:
+  .asciz  "frame-types.cpp"       # string offset=21
+.Linfo_string2:
+  .asciz  "/tmp"                  # string offset=37
+.Linfo_string3:
+  .asciz  "_Z1fv"                 # string offset=42
+.Linfo_string4:
+  .asciz  "f"                     # string offset=48
+.Linfo_string5:
+  .asciz  "a"                     # string offset=50
+.Linfo_string6:
+  .asciz  "char"                  # string offset=52
+.Linfo_string7:
+  .asciz  "b"                     # string offset=57
+.Linfo_string8:
+  .asciz  "c"                     # string offset=59
+.Linfo_string9:
+  .asciz  "d"                     # string offset=61
+.Linfo_string10:
+  .asciz  "e"                     # string offset=63
+.Linfo_string11:
+  .asciz  "S"                     # string offset=65
+.Linfo_string12:
+  .asciz  "g"                     # string offset=67
+.Linfo_string13:
+  .asciz  "h"                     # string offset=69
+.Linfo_string14:
+  .asciz  "i"                     # string offset=71
+.Linfo_string15:
+  .asciz  "j"                     # string offset=73
+.Linfo_string16:
+  .asciz  "char_typedef"          # string offset=75
+.Linfo_string17:
+  .asciz  "k"                     # string offset=88
+.Linfo_string18:
+  .asciz  "__ARRAY_SIZE_TYPE__"   # string offset=90
+.Linfo_string19:
+  .asciz  "l"                     # string offset=110
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 14                      # DW_FORM_strp
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 14                      # DW_FORM_strp
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 2                       # Abbreviation Code
+  .byte 46                      # DW_TAG_subprogram
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 17                      # DW_AT_low_pc
+  .byte 1                       # DW_FORM_addr
+  .byte 18                      # DW_AT_high_pc
+  .byte 6                       # DW_FORM_data4
+  .byte 64                      # DW_AT_frame_base
+  .byte 24                      # DW_FORM_exprloc
+  .byte 110                     # DW_AT_linkage_name
+  .byte 14                      # DW_FORM_strp
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 63                      # DW_AT_external
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 3                       # Abbreviation Code
+  .byte 52                      # DW_TAG_variable
+  .byte 0                       # DW_CHILDREN_no
+  .byte 2                       # DW_AT_location
+  .byte 24                      # DW_FORM_exprloc
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 4                       # Abbreviation Code
+  .byte 22                      # DW_TAG_typedef
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 58                      # DW_AT_decl_file
+  .byte 11                      # DW_FORM_data1
+  .byte 59                      # DW_AT_decl_line
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 36                      # DW_TAG_base_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 62                      # DW_AT_encoding
+  .byte 11                      # DW_FORM_data1
+  .byte 11                      # DW_AT_byte_size
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 6                       # Abbreviation Code
+  .byte 15                      # DW_TAG_pointer_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 7                       # Abbreviation Code
+  .byte 16                      # DW_TAG_reference_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 8                       # Abbreviation Code
+  .byte 66                      # DW_TAG_rvalue_reference_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 9                       # Abbreviation Code
+  .byte 31                      # DW_TAG_ptr_to_member_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 29                      # DW_AT_containing_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 10                      # Abbreviation Code
+  .byte 21                      # DW_TAG_subroutine_type
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 11                      # Abbreviation Code
+  .byte 5                       # DW_TAG_formal_parameter
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 52                      # DW_AT_artificial
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 12                      # Abbreviation Code
+  .byte 19                      # DW_TAG_structure_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 60                      # DW_AT_declaration
+  .byte 25                      # DW_FORM_flag_present
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 13                      # Abbreviation Code
+  .byte 38                      # DW_TAG_const_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 14                      # Abbreviation Code
+  .byte 53                      # DW_TAG_volatile_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 15                      # Abbreviation Code
+  .byte 55                      # DW_TAG_restrict_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 16                      # Abbreviation Code
+  .byte 1                       # DW_TAG_array_type
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 17                      # Abbreviation Code
+  .byte 33                      # DW_TAG_subrange_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 73                      # DW_AT_type
+  .byte 19                      # DW_FORM_ref4
+  .byte 55                      # DW_AT_count
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 18                      # Abbreviation Code
+  .byte 36                      # DW_TAG_base_type
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 11                      # DW_AT_byte_size
+  .byte 11                      # DW_FORM_data1
+  .byte 62                      # DW_AT_encoding
+  .byte 11                      # DW_FORM_data1
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 4                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x157 DW_TAG_compile_unit
+  .long .Linfo_string0          # DW_AT_producer
+  .short  4                       # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .long .Linfo_string2          # DW_AT_comp_dir
+  .long .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 2                       # Abbrev [2] 0x26:0xca DW_TAG_subprogram
+  .long .Lfunc_begin0           # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte 1                       # DW_AT_frame_base
+  .byte 85
+  .long .Linfo_string3          # DW_AT_linkage_name
+  .long .Linfo_string4          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 3                       # DW_AT_decl_line
+                                        # DW_AT_external
+  .byte 3                       # Abbrev [3] 0x3b:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 127
+  .long .Linfo_string5          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 4                       # DW_AT_decl_line
+  .long 240                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x49:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 120
+  .long .Linfo_string7          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 5                       # DW_AT_decl_line
+  .long 247                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x57:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 116
+  .long .Linfo_string8          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 6                       # DW_AT_decl_line
+  .long 252                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x65:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 112
+  .long .Linfo_string9          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 7                       # DW_AT_decl_line
+  .long 257                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x73:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 96
+  .long .Linfo_string10         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 8                       # DW_AT_decl_line
+  .long 262                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x81:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 92
+  .long .Linfo_string4          # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 9                       # DW_AT_decl_line
+  .long 292                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x8f:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 91
+  .long .Linfo_string12         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 10                      # DW_AT_decl_line
+  .long 301                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0x9d:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 90
+  .long .Linfo_string13         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 11                      # DW_AT_decl_line
+  .long 306                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0xab:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 84
+  .long .Linfo_string14         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 12                      # DW_AT_decl_line
+  .long 311                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0xb9:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 83
+  .long .Linfo_string15         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 14                      # DW_AT_decl_line
+  .long 228                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0xc7:0xe DW_TAG_variable
+  .byte 2                       # DW_AT_location
+  .byte 145
+  .byte 71
+  .long .Linfo_string17         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 15                      # DW_AT_decl_line
+  .long 316                     # DW_AT_type
+  .byte 3                       # Abbrev [3] 0xd5:0xf DW_TAG_variable
+  .byte 3                       # DW_AT_location
+  .byte 145
+  .ascii  "\247}"
+  .long .Linfo_string19         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 16                      # DW_AT_decl_line
+  .long 335                     # DW_AT_type
+  .byte 4                       # Abbrev [4] 0xe4:0xb DW_TAG_typedef
+  .long 240                     # DW_AT_type
+  .long .Linfo_string16         # DW_AT_name
+  .byte 1                       # DW_AT_decl_file
+  .byte 13                      # DW_AT_decl_line
+  .byte 0                       # End Of Children Mark
+  .byte 5                       # Abbrev [5] 0xf0:0x7 DW_TAG_base_type
+  .long .Linfo_string6          # DW_AT_name
+  .byte 6                       # DW_AT_encoding
+  .byte 1                       # DW_AT_byte_size
+  .byte 6                       # Abbrev [6] 0xf7:0x5 DW_TAG_pointer_type
+  .long 240                     # DW_AT_type
+  .byte 7                       # Abbrev [7] 0xfc:0x5 DW_TAG_reference_type
+  .long 240                     # DW_AT_type
+  .byte 8                       # Abbrev [8] 0x101:0x5 DW_TAG_rvalue_reference_type
+  .long 240                     # DW_AT_type
+  .byte 9                       # Abbrev [9] 0x106:0x9 DW_TAG_ptr_to_member_type
+  .long 271                     # DW_AT_type
+  .long 287                     # DW_AT_containing_type
+  .byte 10                      # Abbrev [10] 0x10f:0xb DW_TAG_subroutine_type
+  .long 240                     # DW_AT_type
+  .byte 11                      # Abbrev [11] 0x114:0x5 DW_TAG_formal_parameter
+  .long 282                     # DW_AT_type
+                                        # DW_AT_artificial
+  .byte 0                       # End Of Children Mark
+  .byte 6                       # Abbrev [6] 0x11a:0x5 DW_TAG_pointer_type
+  .long 287                     # DW_AT_type
+  .byte 12                      # Abbrev [12] 0x11f:0x5 DW_TAG_structure_type
+  .long .Linfo_string11         # DW_AT_name
+                                        # DW_AT_declaration
+  .byte 9                       # Abbrev [9] 0x124:0x9 DW_TAG_ptr_to_member_type
+  .long 240                     # DW_AT_type
+  .long 287                     # DW_AT_containing_type
+  .byte 13                      # Abbrev [13] 0x12d:0x5 DW_TAG_const_type
+  .long 240                     # DW_AT_type
+  .byte 14                      # Abbrev [14] 0x132:0x5 DW_TAG_volatile_type
+  .long 240                     # DW_AT_type
+  .byte 15                      # Abbrev [15] 0x137:0x5 DW_TAG_restrict_type
+  .long 247                     # DW_AT_type
+  .byte 16                      # Abbrev [16] 0x13c:0xc DW_TAG_array_type
+  .long 240                     # DW_AT_type
+  .byte 17                      # Abbrev [17] 0x141:0x6 DW_TAG_subrange_type
+  .long 328                     # DW_AT_type
+  .byte 12                      # DW_AT_count
+  .byte 0                       # End Of Children Mark
+  .byte 18                      # Abbrev [18] 0x148:0x7 DW_TAG_base_type
+  .long .Linfo_string18         # DW_AT_name
+  .byte 8                       # DW_AT_byte_size
+  .byte 7                       # DW_AT_encoding
+  .byte 16                      # Abbrev [16] 0x14f:0x12 DW_TAG_array_type
+  .long 240                     # DW_AT_type
+  .byte 17                      # Abbrev [17] 0x154:0x6 DW_TAG_subrange_type
+  .long 328                     # DW_AT_type
+  .byte 12                      # DW_AT_count
+  .byte 17                      # Abbrev [17] 0x15a:0x6 DW_TAG_subrange_type
+  .long 328                     # DW_AT_type
+  .byte 24                      # DW_AT_count
+  .byte 0                       # End Of Children Mark
+  .byte 0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .section  .debug_macinfo,"",@progbits
+  .byte 0                       # End Of Macro List Mark
+
+  .ident  "clang version 9.0.0 "
+  .section  ".note.GNU-stack","",@progbits
+  .addrsig
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

llvm/test/tools/llvm-symbolizer/output-style-yaml.test

+## This test checks YAML output for CODE.
+
+## Test YAML output style of DILineInfo.
+# RUN: llvm-symbolizer --output-style=YAML --no-inlines -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+# RUN:   | FileCheck %s --check-prefix=NO-INLINES --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      NO-INLINES:some text
+# NO-INLINES-NEXT:---
+# NO-INLINES-NEXT:FunctionName:    main
+# NO-INLINES-NEXT:StartFileName:   '/tmp{{\\|/}}x.c'
+# NO-INLINES-NEXT:StartLine:       2
+# NO-INLINES-NEXT:FileName:        '/tmp{{\\|/}}x.c'
+# NO-INLINES-NEXT:Line:            3
+# NO-INLINES-NEXT:Column:          3
+# NO-INLINES-NEXT:...
+# NO-INLINES-NEXT:some text2
+
+## Test YAML output style of DIInliningInfo.
+# RUN: llvm-symbolizer --output-style=YAML -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+# RUN:   | FileCheck %s --check-prefix=INLINE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      INLINE:some text
+# INLINE-NEXT:---
+# INLINE-NEXT:Frames:
+# INLINE-NEXT:  - FunctionName:    inctwo
+# INLINE-NEXT:    StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    StartLine:       2
+# INLINE-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    Line:            3
+# INLINE-NEXT:    Column:          3
+# INLINE-NEXT:  - FunctionName:    inc
+# INLINE-NEXT:    StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    StartLine:       6
+# INLINE-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    Line:            7
+# INLINE-NEXT:  - FunctionName:    main
+# INLINE-NEXT:    StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    StartLine:       12
+# INLINE-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-NEXT:    Line:            14
+# INLINE-NEXT:...
+# INLINE-NEXT:some text2
+
+## Test YAML output style of DIInliningInfo from llvm-addr2line without function names.
+# RUN: llvm-addr2line --output-style=YAML -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp \
+# RUN:   | FileCheck %s --check-prefix=INLINE-A2L --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      INLINE-A2L:some text
+# INLINE-A2L-NEXT:---
+# INLINE-A2L-NEXT:Frames:
+# INLINE-A2L-NEXT:  - StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    StartLine:       2
+# INLINE-A2L-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    Line:            3
+# INLINE-A2L-NEXT:    Column:          3
+# INLINE-A2L-NEXT:  - StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    StartLine:       6
+# INLINE-A2L-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    Line:            7
+# INLINE-A2L-NEXT:  - StartFileName:   '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    StartLine:       12
+# INLINE-A2L-NEXT:    FileName:        '/tmp{{\\|/}}x.c'
+# INLINE-A2L-NEXT:    Line:            14
+# INLINE-A2L-NEXT:...
+# INLINE-A2L-NEXT:some text2

llvm/tools/llvm-symbolizer/Opts.td

 defm dsym_hint : Eq<"dsym-hint", "Path to .dSYM bundles to search for debug info for the object files">, MetaVarName<"<dir>">;
 defm fallback_debug_path : Eq<"fallback-debug-path", "Fallback path for debug binaries">, MetaVarName<"<dir>">;
 defm inlines : B<"inlines", "Print all inlined frames for a given address",
                  "Do not print inlined frames">;
 defm obj
     : Eq<"obj", "Path to object file to be symbolized (if not provided, "
                 "object file should be specified for each input line)">, MetaVarName<"<file>">;
 defm output_style
-    : Eq<"output-style", "Specify print style. Supported styles: LLVM, GNU">,
+    : Eq<"output-style", "Specify print style. Supported styles: LLVM, GNU, YAML">,
       MetaVarName<"style">,
-      Values<"LLVM,GNU">;
+      Values<"LLVM,GNU,YAML">;
 def pretty_print : F<"pretty-print", "Make the output more human friendly">;
 defm print_source_context_lines : Eq<"print-source-context-lines", "Print N lines of source file context">;
 def relative_address : F<"relative-address", "Interpret addresses as addresses relative to the image base">;
 def relativenames : F<"relativenames", "Strip the compilation directory from paths">;
 defm untag_addresses : B<"untag-addresses", "", "Remove memory tags from addresses before symbolization">;
 def use_dia: F<"dia", "Use the DIA library to access symbols (Windows only)">;
 def verbose : F<"verbose", "Print verbose line info">;
 def version : F<"version", "Display the version">;

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

if (sys::path::extension(Hint) == ".dSYM") {
       errs() << "Warning: invalid dSYM hint: \"" << Hint
              << "\" (must have the '.dSYM' extension).\n";
     }
   }
 
   auto OutputStyle =
       IsAddr2Line ? DIPrinter::OutputStyle::GNU : DIPrinter::OutputStyle::LLVM;
   if (const opt::Arg *A = Args.getLastArg(OPT_output_style_EQ)) {
-    OutputStyle = strcmp(A->getValue(), "GNU") == 0
-                      ? DIPrinter::OutputStyle::GNU
-                      : DIPrinter::OutputStyle::LLVM;
+    if (strcmp(A->getValue(), "GNU") == 0) {
+      OutputStyle = DIPrinter::OutputStyle::GNU;
+    } else if (strcmp(A->getValue(), "YAML") == 0) {
+      OutputStyle = DIPrinter::OutputStyle::YAML;
+    } else {
+      OutputStyle = DIPrinter::OutputStyle::LLVM;
+    }
   }
 
   LLVMSymbolizer Symbolizer(Opts);
   DIPrinter Printer(outs(), Opts.PrintFunctions != FunctionNameKind::None,
                     Args.hasArg(OPT_pretty_print), SourceContextLines,
                     Args.hasArg(OPT_verbose), OutputStyle);
 
   std::vector<std::string> InputAddresses = Args.getAllArgValues(OPT_INPUT);