Add support for JSON output style to llvm-symbolizer

[aorlov]

Summary

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

[aorlov]

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

113–117

I'm using the exact type that symbolizeFrame() returns.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

161

Please note JSON allows 53-bits numbers. So we print huge numbers as strings "0x...".

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

161

We need the error code for the clear logic while error handling. The error message may be localized, etc.
DIPrinter must only print the data but do not handle errors.
It is impossible to get the error code from the Error without handling.
Initially I have used ErrorInfoBase instead to pass the error information to DIPrinter.
Now DICommon contains ErrorCode (it can be used as "success" flag too).
The error message is stored in DICommon<std::string>.Result only in case of error.

[aorlov]

The refactoring is done.
Thanks for reviewing!

[jhenderson]

To separate concerns, it would be a good idea to put the DIPrinter refactoring in a separate prerequisite patch, that the JSON implementation patch depends on.

I'll probably have loads more comments once that is done, but it'll be easier to sift through them once it is.

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

31

This isn't a good type name. What is a "Common"? Would it make more sense to pass the common data as a separate argument to the non-common Result?

54

Perhaps printError is good, because the type signature in its current form doesn't make it clear that this is for error reporting.

57

We should probably have DIPrinterLLVM and DIPrinterGNU. The two could largely share functionality under the hood, but I think it is a cleaner interface than one implementation of DIPrinter controlling all its output style, and the other having to look at another variable to choose between styles.

119

Make sure to run clang-format on all your new code.

135–136

Use StringRef, not const std::string &.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

203

Delete this. We don't use arbitrary comment markers to divide up files in LLVM coding style.

207

You seem to have ignored my earlier comments re. printing everything?

219

[aorlov]

Please review the separate DIPrinter refactoring patch here https://reviews.llvm.org/D98994

[jhenderson]

Thanks for the other patch. I'll take a look at it shortly. Could you rebase this patch on that one, please, so that it's easier to see what the adding of a new output style will entail, once the refactoring has been done?

Also, if you add "Depends on DXXXXXX" (where XXXXXX is the number from the patch URL) to this patch description, it will automatically do some Phabricator magic to allow people reviewing this to see that there are other prerequisite patches.

[aorlov]

Ping.

Note the build status is red because of a problem not related to this patch.

[aorlov]

Ping.

[aorlov]

One more ping.

[jhenderson]

Apologies for disappearing @aorlov - I was off work for over two weeks, and only started back today. I'm working through a big backlog, and will hopefully get to look at this patch in the next day or two.

[jhenderson]

I've not looked at the testing yet. Here are comments on the code to keep you going though.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

226

static

228

static

233

I suspect from a user's perspective they won't expect to see an Error attribute if there's no error.

234

What is ErrorCode supposed to represent? How will a user benefit from it beyond the information provided in the message?

252

This is intended to be machine readable. "Noise" in the output isn't an issue. In fact, as previously mentioned, not having these and other attributes is actively harmful to the user experience, as it makes it harder to write a parser that consumes this JSON.

In the case where you have a BadString output, I'd just print an empty string. Example:

{ "Source" : "", "FunctionName" : "", ... , "Line" : 0, "Column" : 0, "Discriminator" : 0 }

274

What's the point of the new line? Same goes elsewhere where you are adding new lines. If the output is intended to be machine readable, there is no need for the new lines.

325

Same as above - just print everything.

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

158–162

I missed this in the other review. We don't need to make an ErrorInfo here at all. Just pass the InputString in instead. That will simplify both the call-site and the printInvalidCommand function.

361–364

I would make it always a list, not just for multiple input addresses. Also, shouldn't this be using the json stream arrayBegin/End methods?

367

There's no need for this outer if.

368–371

How about:

StringRef Sep = "";
for (StringRef Address : InputAddresses) {
  outs() << Sep;
  Sep = ",";
  symbolizeInput(Args, AdjustVMA, IsAddr2Line, Style, Address, Symbolizer,
              *Printer);
}

This may be moot however, if you are using the JSON stream to use the proper JSON array methods.

[aorlov]

I do not think we should always include everything and anything into JSON. There is nothing wrong with skipping parameters with unknown values, not applicable data and such.

For example DILocal contains Optional<int64_t> FrameOffset. In JS it would be declared as FrameOffset?: number; and handled natively.

If FrameOffset is not specified we cannot print out the value, any number is a valid offset, and a non-number string would confuse the parses much more than just the optional field which is skipped when N/A.

Besides, our customers are happy with the proposed JSON and do not have any problem parsing optional data.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

233

Error: {Code: 0} – is a standard way to say success. And it is a bad idea to omit Error if it should be checked first.

234

The ErrorCode is more important than a message when automating the error handling. The error message may be localized, depend on OS, etc.

252

Ok, but I still omit empty Error Message and FrameOffset.

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

368–371

Did you forget about different commas in GNU/LLVM output style? I do not want any functional change in that area as a part of this patch.
I have added groupBegin() and groupEnd() to DIPrinter interface and moved all logic to JSONPrinter implementation.

[jhenderson]

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

233

Right, but basically the behaviour of checking whether "Error" exists is no more complicated in most languages than checking whether it has value zero.

I would kind of think there would be two possible JSON objects produced per query (possibly three if we handle invalid commands differently to other errors for JSON output):

{"Error":"some message/code/whatever"}
{"Source":"some path",...}

Where the response had an error, it is unlikely the other parameters can be relied upon in any meaningful way, so it's probably better to omit them than potentially cause confusion.
The pseudo-python logic for this might look something like:

response = json.load(output)
if 'Error' in response:
  handleError(response)
else:
  handleNormalResponse(response)

234

The error codes contained in llvm::Error and llvm::Expected are quite often somewhat arbitrary, and inconsistent. It won't be possible to safely rely on these codes for any useful automated processing. Furthermore, some Errors could contain inconvertibleErrorCode which will cause a problem if these end up back here.

What's the use-case for handling different error kinds differently? I'm not saying there isn't a motivation for that, I'm just trying to understand how you plan to use it. If you have no such plan, it doesn't make sense to add additional logic to distinguish errors by code as well as message.

252

That seems reasonable, thanks for the explanation.

268

I didn't think of this earlier, but it makes a lot of sense to have the pretty printing form be more human readable, with indentation and new lines as appropriate. Thanks!

284

Did you consider having a single json::OStream as a member of the JSONPrinter class, so that it only needs constructing (with the Pretty check) in one place?

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

368–371

Thanks, yes, I'd forgotten this was the higher-level printer area.

"group" doesn't obviously mean anything to me. Could you consider renaming it to something like "listBegin" etc? I think that more clearly indicates what you're doing.

[aorlov]

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

284

Note there is no way to reset json::OStream context, so we cannot reuse the same instance to print 2 or more objects while processing stdin.
I have moved json::OStream to printJSON(json::Value).

[aorlov]

I disagree and still think the ErrorCode is needed for the proper error handling, even if it is arbitrary and inconsistent, which is the usual case everywhere anyway.
I see your point, though, and did what you suggested to unblock this patch and get it committed.

[jhenderson]

I've reviewed the test cases more thoroughly today. I think you need test cases where the addresses are specified on the command-line rather than via stdin, because there's a behaviour difference (objects are in list or not as the case may be).

llvm/docs/CommandGuide/llvm-symbolizer.rst

256

Perhaps worth briefly mentioning the behaviour changes for the following cases:

1. Stdin versus addresses on command-line (i.e. separate individual objects versus list of objects)
2. --pretty-print versus no --pretty-print. Optionally, this could be under the --pretty-print option discussion.

I don't think you need concrete examples of the differences. Just a one/two sentence description.

279

Maybe use the --pretty-print option to make this example a bit more readable?

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

124

I guess it might be helpful to know what this list is of (e.g. ObjectList or whatever).

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

4–10

My understanding is that the --no-inlines option has no impact on the output here, so I think you can drop one of these cases?

12

Rather than use {{.*}}/no-file.exe here and similar situations for paths below, I'd recommend using FileCheck's -D option to ensure the correct path is printed, i.e:

# RUN:   FileCheck %s ... -DFILE=%p/no-file.exe

# NO-FILE: ... "ModuleName":"[[FILE]]" ...

16

Maybe rather than NOT-FOUND-1 and NOT-FOUND-2, it would be more self-descriptive using NOT-FOUND-NOINLINES and NOT-FOUND-INLINES or something like that?

18

Just thinking about usability - what is the canonical way for users to know that their address hasn't been found in JSON output? It might be worth documenting this somewhere.

26

Consider a comment for this case, introducing the following set of test cases. In particular, it's important to note that this is using a stdin argument. You could also move all the references to "no-inlines" to one place. I.e. something like "this test case is testing stdin input, with the --no-inlines option" would do the trick.

Same sort of thing goes below.

29

Nit: missing full stop.

30

I find the "Address":"0x0" bit here somewhat confusing, given this is an error case. I'd consider omitting it entirely. Alternatively, simply print what the input address was specified as (in this case "Address":"some text").

33

It would be nice to have one or more test cases with a non-zero discriminator value. Also, where the "Source" parameter is non-empty.

You can simplify {{/|\\\\}} to this: {{[\\/]}}. I think it's slightly more readable due to avoiding the quadruple backslash. Same goes elsewhere below.

50

I guess the obvious question is: why do we have a difference in behaviour surrounding the FunctionName attribute? The motivation for different symbolizer/addr2line output is because llvm-addr2line needs to be compatible with GNU addr2line, but that principle doesn't apply for JSON output (which AFAIK is not a GNU addr2line supported feature).

54

Nit: missing full stop.

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

33

I'd make one of these addresses non-zero, as that will show that the "Address" and "Start" parameters are not just always 0.

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

30

I think you need a test case with a non-empty "TagOffset".

42

It looks like me like this hasn't been addressed?

[aorlov]

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

12

Unfortunately -D would not work in this case, as JSON has own rules for escaping special symbols in paths.

16

It is not applicable anymore.

18

Yes. This is the Symbolize library design issue. As far as I can tell there is no reliable way to get a distinct result for the symbol not found case.
For now I just keep it transparent by serializing whatever the library returns, as addressing the library issue is out of the scope of this patch.

33

I have added the test for a non-zero discriminator. Note the address is hardcoded. It is more correct to use /Inputs/discrim.inp via stdin, but I just copied the address from discriminator.test.
It seems currently we have no binaries in llvm/test/tools/llvm-symbolizer/Inputs with a valid Source info.

You can simplify

No, it does not work because JSON has own rules for escaping special symbols in paths.

[aorlov]

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

50

This behavior is a part of llvm-symbolizer and does not depend on the output styles and does not belong to the printer (look at decideHowToPrintFunctions()).
Not sure if I understand what you are saying. Changing the behavior is out of the scope of this patch.
I agree that it does not make much sense in testing that, but one of the reviewers requested these tests.

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

42

Intention was to break a dependency on DWARF generation in clang. But I have changed it build from the C source to keep it simple for reading.

[aorlov]

Ping.

[jhenderson]

Hi @aorlov,

The community norm is for a week between updates and a ping/between consecutive pings. I haven't had a chance to come back to this just yet due to my workload. I hope to get to it in the next day or two.

[jhenderson]

Out of time for today. Will come back to this another time.

llvm/docs/CommandGuide/llvm-symbolizer.rst

256–258

Make this all one paragraph, and reflow to 80 character limit. I'd actually rephrase it slightly too:

"If addresses are supplied via stdin, the output JSON will be a series of individual objects. Otherwise, all results will be contained in a single array."

279

Sorry, use -p, not --pretty-print (I just realised that's what's used in the previous example).

294–296

I'd rephrase as in the inline comment (please make sure to reflow if necessary).

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

4–5

Please reflow this comment to 80-character limit.

7

12–13

As before, do we need both --no-inlines and --inlines cases?

33

It seems currently we have no binaries in llvm/test/tools/llvm-symbolizer/Inputs with a valid Source info.

Consider generating one at test time using assembly or yaml2obj.

You can simplify

No, it does not work because JSON has own rules for escaping special symbols in paths.

Okay - I missed the double backslash.

50

Ah, I think we've hit on a fundamental question regarding JSON output - what should the options that change what information is printed do to JSON output? I'm thinking here specifically both --functions and --addresses, but it may apply to others too.

[aorlov]

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

7

But note the library name is symbolize, not symbolizer.

33

I have added output-style-json-code-source.c.

[aorlov]

Used --print-source-context-lines to control Source printout in JSON.

[aorlov]

Ping.

[jhenderson]

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

94–95

Is this clang-formatted properly? Slightly surprised there's no space after override.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

230–231

ErrorCode is unused now. Also, no need for the const on ErrorMsg.

232

Usually we use StringRef.str() to convert to a std::string. Same applies below in the error message line.

247–248

Don't abbeviate these names unnecessarily like this. Array and FrameCount would both be acceptable, for example. In general, avoid single letter variable names except for loop counters. Same goes throughout this patch. See https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly for details:

We cannot stress enough how important it is to use descriptive names. Pick names that match the semantics and role of the underlying entities, within reason. Avoid abbreviations unless they are well known.

I think you can inline N into the initialising part of the for loop? I don't see it being used outside the loop.

251

Object maybe?

261

I think adding source context can be a later patch. Let's try to avoid adding more than we have to in this one patch.

llvm/test/tools/llvm-symbolizer/output-style-json-code-source.c

3 ↗

(On Diff #342279)

This won't work. clang isn't available in llvm-symbolizer tests, as the latter are part of the LLVM layer. Clang depends on the LLVM layer, but not vice-versa. You might be able to use llvm-mc -g to compile some assembly to be able to test this though.

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

4

7

Fair point. How about simply ## Show how library errors are reported in the output.

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

6

Same comment as the code test.

28

Same comment as above.

llvm/test/tools/llvm-symbolizer/output-style-json-frame.c

24 ↗

(On Diff #342279)

As above. This won't work. You should use llvm-mc to build from assembly, as in other test cases.

[aorlov]

I think adding source context can be a later patch. Let's try to avoid adding more than we have to in this one patch.

Nice.
Note you asked for a new test for Source a week ago.
Ok, I have removed Source from the JSON output and removed the new test for Source.

I have restored output-style-json-frame.test instead of output-style-json-frame.c
Note output-style-json-frame.test is huge because it is machine generated and you asked for a non zero and non empty TagOffset.
I don't like an idea to clean up or optimize it anyway.

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

94–95

It is generated by clang-format and validated by clang-tidy.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

251

It is not necessary anymore because Source has been removed.

[dblaikie]

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

94–95

The extraneous trailing semicolon is probably confusing clang-format, so maybe remove those and see how it gets formatted?

[jhenderson]

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

94–95

Ah, good spot!

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

231

There's still an unfortunate single-letter variable name here. I'd suggest Json or Object for the variable name.

240

Same comment as above. How about InliningInfo?

248

LI is a similar abbreviation which doesn't clearly indicate its name. What's wrong with LineInfo?

260

J -> Json or Object

273

Object or Json.

284

Local

285

Maybe use FrameObject here to disambiguate from the toJson retiurn below.

296

Json or RequestJson or similar.

315

Json or Object

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

47

If I follow this correctly, this test case is showing that llvm-addr2line with -f results in the function name being printed? Assuming that's correct, I think you need to show that llvm-addr2line without -f results in the function name not being included in the JSON output too.

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

39

Please include the version of clang explicitly here, not just in the ident string below. The reason is that someone might come along and trim off the superfluous parts of the below assembly to minimise the test case, but it would still be helpful to know how to generate the unmodified part. I would also use a final release version of clang, so that a future user can easily get the exact version of clang well into the future.

[dblaikie]

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

39

This seems like a fairly non-trivial build - might be worth an explanation about what's interesting about this case that's not exercised by simpler cases (such as ones without sanitizers, maybe also x86 plain (not a necessity, but curious if it's something ARM specific here), etc)

[aorlov]

I have replaced output-style-json-frame.test with output-style-json-frame.ll, which is much friendlier but still contains non-zero TagOffset.

[jhenderson]

llvm/test/tools/llvm-symbolizer/output-style-json-frame.ll

1 ↗

(On Diff #343923)

Does this need a REQUIRES: aarch64-registered-target or equivalent?

20 ↗

(On Diff #343923)

Perhaps highlight that you are testing both 0 and non-zero frame offsets with a comment.

25 ↗

(On Diff #343923)

This code could probably do with some comments highlighting what the key elements are, so that future changes don't lose them.

[aorlov]

llvm/test/tools/llvm-symbolizer/output-style-json-frame.ll

1 ↗

(On Diff #343923)

It does not require any ARM target.
Note this test is passed on x64 Windows and x64 Debian.

20 ↗

(On Diff #343923)

I have updated output-style-json-frame.ll.
Now it contains 0, non-zero and empty (missing) TagOffset to cover all possible cases.
I added a comment too.

25 ↗

(On Diff #343923)

There are no any key elements. I just declared 3 variables with different type, size and all possible TagOffset per your requests.
I personally think it is overkill, and does not really belong to the JSON patch, as there is nothing JSON specific there.
It seems a test for the symbolize library and the symbolizer itself.

[aorlov]

I have added the aarch64 requirements, and a few comments in that test for target offsets. Hope this should address it.

[jhenderson]

LGTM, with one nit.

llvm/test/tools/llvm-symbolizer/output-style-json-frame.ll

1 ↗

(On Diff #344183)

Nit: similar to the ## in the other tests, use ;; for comments in this test to help the comments stand out from lit and FileCheck directives.

[jhenderson]

Please make another commit to fix the unnecessary introduction of semi-colons in the places I've highlighted.

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

40–49

Why have these superfluous semi-colons reappeared?

94–95

Ditto.

[MaskRay]

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

49

virtual ~DIPrinter(){}; => virtual ~DIPrinter() {}

Does clang-format complain on virtual ~DIPrinter(){}; ?

[dblaikie]

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

49

clang-format doesn't have warnings/errors really - it does it's best to guess at what's going on and format it.

The extra ';' confuse clang-format and so it formats poorly.

@jhenderson also asked @aorlov to remove the unnecessary semicolons earlier:

Please make another commit to fix the unnecessary introduction of semi-colons in the places I've highlighted.

@aorlov - could you take a look at this & ensure the semicolons have been removed?

[aorlov]

In D96883#2750037, @jhenderson wrote:

Please make another commit to fix the unnecessary introduction of semi-colons in the places I've highlighted.

Done.
Sorry for that. Something went wrong when switching branches.

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|JSON>
 
   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.
 
+  ``JSON`` style provides a machine readable output in JSON.
+
   .. 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=JSON --obj=inlined.elf 0x4004be 0x400486
+    [{"ModuleName":"inlined.elf","Address":"0x4004be","Error":{"Code":0},"DIInliningInfo":{"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}]}},
+    {"ModuleName":"inlined.elf","Address":"0x400486","Error":{"Code":0},"DIInliningInfo":{"Frames":[
+    {"FunctionName":"foo()","StartFileName":"/tmp/test.cpp","StartLine":5,"FileName":"/tmp/test.cpp","Line": 6,"Column": 3}]}}]
+
+    $ llvm-symbolizer --output-style=JSON --obj=inlined.elf 0x4004be --no-inlines
+    {"ModuleName":"inlined.elf","Address":"0x4004be","Error":{"Code":0},"DILineInfo":
+    {"FunctionName":"main","StartFileName":"/tmp/test.cpp","StartLine":14,"FileName":"/tmp/test.cpp","Line":11,"Column":18}}
+
 .. 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
     baz() at /tmp/test.cpp:11:18
      (inlined by) main at /tmp/test.cpp:15:0
 
 .. option:: --print-address, --addresses, -a
 
   Print address before the source code location. Defaults to false.
 

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

 class DIInliningInfo;
 struct DIGlobal;
 struct DILocal;
 class ErrorInfoBase;
 class raw_ostream;
 
 namespace symbolize {
 
 struct Request {
   StringRef ModuleName;
   uint64_t Address = 0;
   Request(const StringRef ModuleName, uint64_t Address)
       : ModuleName(ModuleName), Address(Address){};
 };
 
 class DIPrinter {
 public:
-  enum class OutputStyle { LLVM, GNU };
+  enum class OutputStyle { LLVM, GNU, JSON };
 
 protected:
   raw_ostream &OutputStream;
   raw_ostream &ErrorStream;
 
 public:
   DIPrinter(raw_ostream &OS, raw_ostream &ES)
       : OutputStream(OS), ErrorStream(ES) {}
   virtual ~DIPrinter(){};
 
   virtual void print(const Request &Request, const DILineInfo &Info) = 0;
   virtual void print(const Request &Request, const DIInliningInfo &Info) = 0;
   virtual void print(const Request &Request, const DIGlobal &Global) = 0;
   virtual void print(const Request &Request,
                      const std::vector<DILocal> &Locals) = 0;
 
   virtual bool printError(const Request &Request,
                           const ErrorInfoBase &ErrorInfo,
                           const StringRef ErrorBanner = "") = 0;
 };
 
 class PlainPrinterBase : public DIPrinter {
 protected:
   bool PrintAddress;
   bool PrintFunctionNames;
public:
   void print(const Request &Request, const DIInliningInfo &Info) override;
   void print(const Request &Request, const DIGlobal &Global) override;
   void print(const Request &Request,
              const std::vector<DILocal> &Locals) override;
 
   bool printError(const Request &Request, const ErrorInfoBase &ErrorInfo,
                   const StringRef ErrorBanner = "") override;
 };
 
 class LLVMPrinter : public PlainPrinterBase {
 private:
   void print(const DILineInfo &Info, bool Inlined) override;
   void printFooter() override;
 
 public:
   LLVMPrinter(raw_ostream &OS, raw_ostream &ES, bool PrintAddress = false,
               bool PrintFunctionNames = true, bool PrintPretty = false,
               int PrintSourceContext = 0, bool Verbose = false)
       : PlainPrinterBase(OS, ES, PrintAddress, PrintFunctionNames, PrintPretty,
                          PrintSourceContext, Verbose) {}
 };
 
 class GNUPrinter : public PlainPrinterBase {
 private:
   void print(const DILineInfo &Info, bool Inlined) override;
 
 public:
   GNUPrinter(raw_ostream &OS, raw_ostream &ES, bool PrintAddress = false,
              bool PrintFunctionNames = true, bool PrintPretty = false,
              int PrintSourceContext = 0, bool Verbose = false)
       : PlainPrinterBase(OS, ES, PrintAddress, PrintFunctionNames, PrintPretty,
                          PrintSourceContext, Verbose) {}
 };
+
+class JSONPrinter : public DIPrinter {
+public:
+  JSONPrinter(raw_ostream &OS, raw_ostream &ES) : DIPrinter(OS, ES) {}
+
+  void print(const Request &Request, const DILineInfo &Info) override;
+  void print(const Request &Request, const DIInliningInfo &Info) override;
+  void print(const Request &Request, const DIGlobal &Global) override;
+  void print(const Request &Request,
+             const std::vector<DILocal> &Locals) override;
+
+  bool printError(const Request &Request, const ErrorInfoBase &ErrorInfo,
+                  const StringRef ErrorBanner = "") override;
+};
+
 } // namespace symbolize
 } // namespace llvm
 
 #endif

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/JSON.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
 namespace symbolize {
 
 // Prints source code around in the FileName the Line.
 void PlainPrinterBase::printContext(const StringRef FileName, int64_t Line) {
   if (PrintSourceContext <= 0)
     return;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(FileName);
   if (!BufOrErr)
     return;
 
   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
   int64_t FirstLine =
       std::max(static_cast<int64_t>(1), Line - PrintSourceContext / 2);
   int64_t LastLine = FirstLine + PrintSourceContext;
   size_t MaxLineNumberWidth = std::ceil(std::log10(LastLine));
 
   for (line_iterator I = line_iterator(*Buf, false);
        !I.is_at_eof() && I.line_number() <= LastLine; ++I) {
     int64_t L = I.line_number();
     if (L >= FirstLine && L <= LastLine) {
       OutputStream << format_decimal(L, MaxLineNumberWidth);
       if (L == Line)
         OutputStream << " >: ";

 }
 
 void PlainPrinterBase::print(const Request &Request,
                              const DIInliningInfo &Info) {
   printHeader(Request.Address);
   uint32_t FramesNum = Info.getNumberOfFrames();
   if (FramesNum == 0)
     print(DILineInfo(), false);
   else
     for (uint32_t I = 0; I < FramesNum; ++I)
       print(Info.getFrame(I), I > 0);
   printFooter();
 }
 
 void PlainPrinterBase::print(const Request &Request, const DIGlobal &Global) {
   printHeader(Request.Address);
   StringRef Name = Global.Name;
   if (Name == DILineInfo::BadString)
     Name = DILineInfo::Addr2LineBadString;
   OutputStream << Name << "\n";
   OutputStream << Global.Start << " " << Global.Size << "\n";
   printFooter();
 }
 
 void PlainPrinterBase::print(const Request &Request,
                              const std::vector<DILocal> &Locals) {
   printHeader(Request.Address);
   if (Locals.empty())
     OutputStream << DILineInfo::Addr2LineBadString << '\n';
for (const DILocal &L : Locals) {
         OutputStream << *L.FrameOffset;
       else
         OutputStream << DILineInfo::Addr2LineBadString;
       OutputStream << ' ';
 
       if (L.Size)
         OutputStream << *L.Size;
       else
         OutputStream << DILineInfo::Addr2LineBadString;
       OutputStream << ' ';
 
       if (L.TagOffset)
         OutputStream << *L.TagOffset;
       else
         OutputStream << DILineInfo::Addr2LineBadString;
       OutputStream << '\n';
     }
   printFooter();
 }
 
 bool PlainPrinterBase::printError(const Request &Request,
                                   const ErrorInfoBase &ErrorInfo,
                                   const StringRef ErrorBanner) {
   if (!ErrorBanner.empty()) {
     ErrorStream << ErrorBanner;
     ErrorInfo.log(ErrorStream);
     ErrorStream << '\n';
     // Print an empty struct too.
     return true;
   }
   OutputStream << ErrorInfo.message() << '\n';
   return false;
 }
 
+std::string toHex(uint64_t V) { return ("0x" + Twine::utohexstr(V)).str(); }
+
+static void toJSON(json::OStream &J, const DILineInfo &Info) {
+  J.objectBegin();
+  if (Info.Source)
+    J.attribute("Source", *Info.Source);
+  if (Info.FunctionName != DILineInfo::BadString)
+    J.attribute("FunctionName", Info.FunctionName);
+  if (Info.StartFileName != DILineInfo::BadString)
+    J.attribute("StartFileName", Info.StartFileName);
+  if (Info.StartLine)
+    J.attribute("StartLine", Info.StartLine);
+  if (Info.FileName != DILineInfo::BadString)
+    J.attribute("FileName", Info.FileName);
+  // Print only valid line and column to reduce noise in the output.
+  if (Info.Line)
+    J.attribute("Line", Info.Line);
+  if (Info.Column)
+    J.attribute("Column", Info.Column);
+  if (Info.Discriminator)
+    J.attribute("Discriminator", Info.Discriminator);
+  J.objectEnd();
+}
+
+void JSONPrinter::print(const Request &Request, const DILineInfo &Info) {
+  {
+    json::OStream J(OutputStream);
+    J.objectBegin();
+    if (!Request.ModuleName.empty())
+      J.attribute("ModuleName", Request.ModuleName);
+    J.attribute("Address", toHex(Request.Address));
+    J.attributeObject("Error", [&] { J.attribute("Code", 0); });
+    J.attributeBegin("DILineInfo");
+    toJSON(J, Info);
+    J.attributeEnd();
+    J.objectEnd();
+  }
+  OutputStream << '\n';
+}
+
+void JSONPrinter::print(const Request &Request, const DIInliningInfo &Info) {
+  {
+    json::OStream J(OutputStream);
+    J.objectBegin();
+    if (!Request.ModuleName.empty())
+      J.attribute("ModuleName", Request.ModuleName);
+    J.attribute("Address", toHex(Request.Address));
+    J.attributeObject("Error", [&] { J.attribute("Code", 0); });
+    J.attributeBegin("DIInliningInfo");
+    J.objectBegin();
+    J.attributeBegin("Frames");
+    J.arrayBegin();
+    uint32_t FramesNum = Info.getNumberOfFrames();
+    for (uint32_t I = 0; I < FramesNum; ++I) {
+      OutputStream << '\n';
+      toJSON(J, Info.getFrame(I));
+    }
+    J.arrayEnd();
+    J.attributeEnd(); // Frames
+    J.objectEnd();
+    J.attributeEnd(); // DIInliningInfo
+    J.objectEnd();
+  }
+  OutputStream << '\n';
+}
+
+void JSONPrinter::print(const Request &Request, const DIGlobal &Global) {
+  {
+    json::OStream J(OutputStream);
+    J.objectBegin();
+    if (!Request.ModuleName.empty())
+      J.attribute("ModuleName", Request.ModuleName);
+    J.attribute("Address", toHex(Request.Address));
+    J.attributeObject("Error", [&] { J.attribute("Code", 0); });
+    J.attributeBegin("DIGlobal");
+    J.objectBegin();
+    if (Global.Name != DILineInfo::BadString)
+      J.attribute("Name", Global.Name);
+    J.attribute("Start", toHex(Global.Start));
+    J.attribute("Size", toHex(Global.Size));
+    J.objectEnd();
+    J.attributeEnd();
+    J.objectEnd();
+  }
+  OutputStream << '\n';
+}
+
+void JSONPrinter::print(const Request &Request,
+                        const std::vector<DILocal> &Locals) {
+  {
+    json::OStream J(OutputStream);
+    J.objectBegin();
+    if (!Request.ModuleName.empty())
+      J.attribute("ModuleName", Request.ModuleName);
+    J.attribute("Address", toHex(Request.Address));
+    J.attributeObject("Error", [&] { J.attribute("Code", 0); });
+    J.attributeBegin("vector_DILocal");
+    J.arrayBegin();
+    for (const DILocal &L : Locals) {
+      OutputStream << '\n';
+      J.objectBegin();
+      if (!L.FunctionName.empty())
+        J.attribute("FunctionName", L.FunctionName);
+      if (!L.Name.empty())
+        J.attribute("Name", L.Name);
+      if (!L.DeclFile.empty())
+        J.attribute("DeclFile", L.DeclFile);
+      J.attribute("DeclLine", int64_t(L.DeclLine));
+      if (L.FrameOffset)
+        J.attribute("FrameOffset", *L.FrameOffset);
+      if (L.Size)
+        J.attribute("Size", toHex(*L.Size));
+      if (L.TagOffset)
+        J.attribute("TagOffset", toHex(*L.TagOffset));
+      J.objectEnd();
+    }
+    J.arrayEnd();
+    J.attributeEnd();
+    J.objectEnd();
+  }
+  OutputStream << '\n';
+}
+
+bool JSONPrinter::printError(const Request &Request,
+                             const ErrorInfoBase &ErrorInfo,
+                             const StringRef ErrorBanner) {
+  {
+    json::OStream J(OutputStream);
+    J.objectBegin();
+    if (!Request.ModuleName.empty())
+      J.attribute("ModuleName", Request.ModuleName);
+    J.attribute("Address", toHex(Request.Address));
+    J.attributeObject("Error", [&] {
+      J.attribute("Code", ErrorInfo.convertToErrorCode().value());
+      std::string Banner;
+      if (ErrorBanner.empty())
+        Banner = "unable to parse arguments: ";
+      J.attribute("Message", Banner + ErrorInfo.message());
+    });
+    J.objectEnd();
+  }
+  OutputStream << '\n';
+  return false;
+}
+
 } // end namespace symbolize
 } // end namespace llvm

llvm/test/tools/llvm-symbolizer/output-style-json-code.test

+## This test checks JSON output for CODE.
+
+## Handle symbolize library error - file does not exist, no-inlines.
+# RUN: llvm-symbolizer --output-style=JSON --no-inlines -e %p/no-file.exe 0 | \
+# RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+## Handle symbolize library error - file does not exist, inline.
+# RUN: llvm-symbolizer --output-style=JSON -e %p/no-file.exe 0 | \
+# RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NO-FILE:{"ModuleName":"{{.*}}/no-file.exe","Address":"0x0","Error":{"Code":2,"Message":"[[MSG]]"}}
+
+## Resolve out of range address, no-inlines. Expected empty object, as all the default values are omitted.
+# RUN: llvm-symbolizer --output-style=JSON --no-inlines -e %p/Inputs/addr.exe 1000000000 | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND-1 --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NOT-FOUND-1:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x3b9aca00","Error":{"Code":0},"DILineInfo":{}}
+
+## Resolve out of range address, inlines. Expected a Frames list with one empty object, as all the default values are omitted.
+# RUN: llvm-symbolizer --output-style=JSON -e %p/Inputs/addr.exe 1000000000 | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND-2 --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      NOT-FOUND-2:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x3b9aca00","Error":{"Code":0},"DIInliningInfo":{"Frames":[
+# NOT-FOUND-2-NEXT:{}]}}
+
+# RUN: llvm-symbolizer --output-style=JSON --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={{.}}
+
+## Invalid first argument before any valid one, no-inlines
+#      NO-INLINES:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text"}}
+
+## Resolve valid address, no-inlines.
+# NO-INLINES-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x40054d","Error":{"Code":0},"DILineInfo":{"FunctionName":"main","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2,"FileName":"/tmp{{/|\\\\}}x.c","Line":3,"Column":3}}
+
+## Invalid argument after a valid one, no-inlines.
+# NO-INLINES-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text2"}}
+
+# RUN: llvm-symbolizer --output-style=JSON -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
+# RUN:   FileCheck %s --check-prefix=INLINE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+## Invalid first argument before any valid one, inlines
+#      INLINE:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text"}}
+
+## Resolve valid address, inlines.
+# INLINE-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x40054d","Error":{"Code":0},"DIInliningInfo":{"Frames":[
+# INLINE-NEXT:{"FunctionName":"inctwo","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2,"FileName":"/tmp{{/|\\\\}}x.c","Line":3,"Column":3}
+# INLINE-NEXT:,{"FunctionName":"inc","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6,"FileName":"/tmp{{/|\\\\}}x.c","Line":7}
+# INLINE-NEXT:,{"FunctionName":"main","StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12,"FileName":"/tmp{{/|\\\\}}x.c","Line":14}]}}
+
+## Invalid argument after a valid one, inlines.
+# INLINE-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text2"}}
+
+## Also check the last 3 test cases with llvm-adr2line. The expected result is the same but missing the FunctionName.
+# RUN: llvm-addr2line --output-style=JSON -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={{.}}
+
+## Invalid first argument before any valid one, inlines
+#      INLINE-A2L:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text"}}
+
+## Resolve valid address, inlines.
+# INLINE-A2L-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x40054d","Error":{"Code":0},"DIInliningInfo":{"Frames":[
+# INLINE-A2L-NEXT:{"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2,"FileName":"/tmp{{/|\\\\}}x.c","Line":3,"Column":3}
+# INLINE-A2L-NEXT:,{"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6,"FileName":"/tmp{{/|\\\\}}x.c","Line":7}
+# INLINE-A2L-NEXT:,{"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12,"FileName":"/tmp{{/|\\\\}}x.c","Line":14}]}}
+
+## Invalid argument after a valid one, inlines.
+# INLINE-A2L-NEXT:{"ModuleName":"{{.*}}/Inputs/addr.exe","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: some text2"}}

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

+## This test checks JSON output for DATA.
+
+# REQUIRES: x86-registered-target
+
+## Handle symbolize library error - file does not exist.
+# RUN: llvm-symbolizer "DATA %t-no-file.o 0" --output-style=JSON | \
+# RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NO-FILE:{"ModuleName":"{{.*}}no-file.o","Address":"0x0","Error":{"Code":2,"Message":"[[MSG]]"}}
+
+## Handle invalid argument.
+# RUN: llvm-symbolizer "DATA tmp.o Z" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# INVARG:{"ModuleName":"tmp.o","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: DATA tmp.o Z"}}
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+
+## Resolve out of range address. Only Start and Size is expected.
+# RUN: llvm-symbolizer "DATA %t.o 1000000000" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NOT-FOUND:{"ModuleName":"{{.*}}.o","Address":"0x3b9aca00","Error":{"Code":0},"DIGlobal":{"Start":"0x0","Size":"0x0"}}
+
+## Resolve valid address.
+# RUN: llvm-symbolizer "DATA %t.o 0" --output-style=JSON | \
+# RUN:   FileCheck %s --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# CHECK:{"ModuleName":"{{.*}}.o","Address":"0x0","Error":{"Code":0},"DIGlobal":{"Name":"foo","Start":"0x0","Size":"0x4"}}
+
+## Test multiple addresses in the command line.
+# RUN: llvm-symbolizer -e=%t.o "DATA 0" "DATA 0" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=MULTI --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      MULTI:[{"ModuleName":"{{.*}}.o","Address":"0x0","Error":{"Code":0},"DIGlobal":{"Name":"foo","Start":"0x0","Size":"0x4"}}
+# MULTI-NEXT:,{"ModuleName":"{{.*}}.o","Address":"0x0","Error":{"Code":0},"DIGlobal":{"Name":"foo","Start":"0x0","Size":"0x4"}}
+# MULTI-NEXT:]
+
+.data
+.globl foo
+.type foo, @object
+.size foo, 4
+foo = . + 0x1100000000000000
+.4byte 1

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

+## This test checks JSON output for FRAME.
+
+# REQUIRES: x86-registered-target
+
+## Handle symbolize library error - file does not exist.
+# RUN: llvm-symbolizer "FRAME %t-no-file.o 0" --output-style=JSON | \
+# RUN:   FileCheck %s -DMSG=%errc_ENOENT --check-prefix=NO-FILE --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NO-FILE:{"ModuleName":"{{.*}}no-file.o","Address":"0x0","Error":{"Code":2,"Message":"[[MSG]]"}}
+
+## Handle invalid argument.
+# RUN: llvm-symbolizer "FRAME tmp.o Z" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=INVARG --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# INVARG:{"ModuleName":"tmp.o","Address":"0x0","Error":{"Code":22,"Message":"unable to parse arguments: FRAME tmp.o Z"}}
+
+# RUN: llvm-mc -filetype=obj -triple=i386-linux-gnu -o %t.o %s
+
+## Resolve out of range address. Expected an empty array.
+# RUN: llvm-symbolizer "FRAME %t.o 1000000000" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+# NOT-FOUND:{"ModuleName":"{{.*}}.o","Address":"0x3b9aca00","Error":{"Code":0},"vector_DILocal":[]}
+
+## Resolve valid address.
+# RUN: llvm-symbolizer "FRAME %t.o 0" --output-style=JSON | \
+# RUN:   FileCheck %s --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      CHECK:{"ModuleName":"{{.*}}.o","Address":"0x0","Error":{"Code":0},"vector_DILocal":[
+# CHECK-NEXT:{"FunctionName":"f","Name":"a","DeclFile":"/tmp/test{{/|\\\\}}frame.cpp","DeclLine":2,"FrameOffset":-1,"Size":"0x1"}
+# CHECK-NEXT:,{"FunctionName":"f","Name":"b","DeclFile":"/tmp/test{{/|\\\\}}frame.cpp","DeclLine":3,"FrameOffset":-8,"Size":"0x4"}]}
+
+## Generated from:
+##
+## void f() {
+##   char a;
+##   char *b;
+## }
+##
+## clang++ --target=i386-linux-gnu frame.cpp -g -std=c++11 -S -o frame.s 
+ 
+  .text
+  .file "frame.cpp"
+  .globl  _Z1fv                           # -- Begin function _Z1fv
+  .p2align  4, 0x90
+  .type _Z1fv,@function
+_Z1fv:                                  # @_Z1fv
+.Lfunc_begin0:
+  .file 1 "/tmp/test" "frame.cpp"
+  .loc  1 1 0                           # frame.cpp:1: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
+.Ltmp0:
+  .loc  1 4 1 prologue_end              # frame.cpp:4:1
+  popl  %ebp
+  .cfi_def_cfa %esp, 4
+  retl
+.Ltmp1:
+.Lfunc_end0:
+  .size _Z1fv, .Lfunc_end0-_Z1fv
+  .cfi_endproc
+                                        # -- End function
+  .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 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 5                               # 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 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:0x5a DW_TAG_compile_unit
+  .long .Linfo_string0                  # DW_AT_producer
+  .short  26                              # 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:0x32 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 1                               # 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 2                               # DW_AT_decl_line
+  .long 88                              # 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 3                               # DW_AT_decl_line
+  .long 95                              # DW_AT_type
+  .byte 0                               # End Of Children Mark
+  .byte 4                               # Abbrev [4] 0x58:0x7 DW_TAG_base_type
+  .long .Linfo_string6                  # DW_AT_name
+  .byte 6                               # DW_AT_encoding
+  .byte 1                               # DW_AT_byte_size
+  .byte 5                               # Abbrev [5] 0x5f:0x5 DW_TAG_pointer_type
+  .long 88                              # DW_AT_type
+  .byte 0                               # End Of Children Mark
+.Ldebug_info_end0:
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 13.0.0" # string offset=0
+.Linfo_string1:
+  .asciz  "frame.cpp"                     # string offset=105
+.Linfo_string2:
+  .asciz  "/tmp/test"   # string offset=115
+.Linfo_string3:
+  .asciz  "_Z1fv"                         # string offset=140
+.Linfo_string4:
+  .asciz  "f"                             # string offset=146
+.Linfo_string5:
+  .asciz  "a"                             # string offset=148
+.Linfo_string6:
+  .asciz  "char"                          # string offset=150
+.Linfo_string7:
+  .asciz  "b"                             # string offset=155
+  .addrsig
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

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, JSON">,
       MetaVarName<"style">,
-      Values<"LLVM,GNU">;
+      Values<"LLVM,GNU,JSON">;
 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

static void print(const StringRef ModuleName, uint64_t Address,
 
   if (PrintEmpty)
     Printer.print(Request(ModuleName, Address), T());
 }
 
 enum class Command {
   Code,
   Data,
   Frame,
 };
 
 static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
                          StringRef InputString, Command &Cmd,
                          std::string &ModuleName, uint64_t &ModuleOffset) {
   const char kDelimiters[] = " \n\r";
   ModuleName = "";
   if (InputString.consume_front("CODE ")) {

 static void symbolizeInput(const opt::InputArgList &Args, uint64_t AdjustVMA,
                            bool IsAddr2Line, DIPrinter::OutputStyle OutputStyle,
                            StringRef InputString, LLVMSymbolizer &Symbolizer,
                            DIPrinter &Printer) {
   Command Cmd;
   std::string ModuleName;
   uint64_t Offset = 0;
   if (!parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
                     StringRef(InputString), Cmd, ModuleName, Offset)) {
     Printer.printError(
         Request(ModuleName, Offset),
         StringError(InputString,
                     std::make_error_code(std::errc::invalid_argument)));
     return;
   }
 
   uint64_t AdjustedOffset = Offset - AdjustVMA;
   if (Cmd == Command::Data) {
     Expected<DIGlobal> ResOrErr = Symbolizer.symbolizeData(
         ModuleName, {AdjustedOffset, object::SectionedAddress::UndefSection});
     print(ModuleName, Offset, ResOrErr, Printer);
   } else if (Cmd == Command::Frame) {
     Expected<std::vector<DILocal>> ResOrErr = Symbolizer.symbolizeFrame(
         ModuleName, {AdjustedOffset, object::SectionedAddress::UndefSection});
     print(ModuleName, Offset, ResOrErr, Printer);
   } else if (Args.hasFlag(OPT_inlines, OPT_no_inlines, !IsAddr2Line)) {
     Expected<DIInliningInfo> ResOrErr = Symbolizer.symbolizeInlinedCode(
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(), "JSON") == 0)
+      OutputStyle = DIPrinter::OutputStyle::JSON;
+    else
+      OutputStyle = DIPrinter::OutputStyle::LLVM;
   }
 
   LLVMSymbolizer Symbolizer(Opts);
   std::unique_ptr<DIPrinter> Printer;
   if (OutputStyle == DIPrinter::OutputStyle::GNU)
     Printer.reset(new GNUPrinter(outs(), errs(), Args.hasArg(OPT_addresses),
                                  Opts.PrintFunctions != FunctionNameKind::None,
                                  Args.hasArg(OPT_pretty_print),
                                  SourceContextLines, Args.hasArg(OPT_verbose)));
+  else if (OutputStyle == DIPrinter::OutputStyle::JSON)
+    Printer.reset(new JSONPrinter(outs(), errs()));
   else
     Printer.reset(new LLVMPrinter(outs(), errs(), Args.hasArg(OPT_addresses),
                                   Opts.PrintFunctions != FunctionNameKind::None,
                                   Args.hasArg(OPT_pretty_print),
                                   SourceContextLines,
                                   Args.hasArg(OPT_verbose)));
 
   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.
       std::string StrippedInputString(InputString);
       llvm::erase_if(StrippedInputString,
                      [](char c) { return c == '\r' || c == '\n'; });
       symbolizeInput(Args, AdjustVMA, IsAddr2Line, OutputStyle,
                      StrippedInputString, Symbolizer, *Printer);
       outs().flush();
     }
   } else {
-    for (StringRef Address : InputAddresses)
+    bool ArrayJSON = false;
+    if (OutputStyle == DIPrinter::OutputStyle::JSON &&
+        InputAddresses.size() > 1) {
+      ArrayJSON = true;
+      outs() << "[";
+    }
+    bool ArrayDelimJSON = false;
+    for (StringRef Address : InputAddresses) {
+      if (ArrayJSON) {
+        if (ArrayDelimJSON)
+          outs() << ",";
+        else
+          ArrayDelimJSON = true;
+      }
       symbolizeInput(Args, AdjustVMA, IsAddr2Line, OutputStyle, Address,
                      Symbolizer, *Printer);
     }
+    if (ArrayJSON)
+      outs() << "]\n";
+  }
 
   return 0;
 }