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

118–119

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

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

147

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

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

158

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

32

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?

53

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

56

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.

121

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

140–141

Use StringRef, not const std::string &.

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

191

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

195

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

207

[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

213

static

215

static

220

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

221

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

239

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 }

261

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.

312

Same as above - just print everything.

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

156–157

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.

354–357

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?

360

There's no need for this outer if.

361–364

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

220

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.

221

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

239

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

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

361–364

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

220

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)

221

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.

239

That seems reasonable, thanks for the explanation.

255

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!

271

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

361–364

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

271

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.

281

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

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

126

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

29 ↗

(On Diff #339311)

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

41 ↗

(On Diff #330008)

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

41 ↗

(On Diff #330008)

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."

281

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

331–333

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

99–100

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

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

217–218

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

219

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

234–235

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.

238

Object maybe?

248

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

99–100

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

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

238

It is not necessary anymore because Source has been removed.

[dblaikie]

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

99–100

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

99–100

Ah, good spot!

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

218

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

227

Same comment as above. How about InliningInfo?

235

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

247

J -> Json or Object

260

Object or Json.

271

Local

272

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

283

Json or RequestJson or similar.

302

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

38 ↗

(On Diff #343427)

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

38 ↗

(On Diff #343649)

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

2

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

21

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

26

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

2

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

21

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.

26

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

2

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

38–40

Why have these superfluous semi-colons reappeared?

99–100

Ditto.

[MaskRay]

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

39–40

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

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

[dblaikie]

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

39–40

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. 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.
+
   .. 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 -p
+    [
+      {
+        "Address": "0x4004be",
+        "ModuleName": "inlined.elf",
+        "Symbol": [
+          {
+            "Column": 18,
+            "Discriminator": 0,
+            "FileName": "/tmp/test.cpp",
+            "FunctionName": "baz()",
+            "Line": 11,
+            "Source": "",
+            "StartFileName": "/tmp/test.cpp",
+            "StartLine": 9
+          },
+          {
+            "Column": 0,
+            "Discriminator": 0,
+            "FileName": "/tmp/test.cpp",
+            "FunctionName": "main",
+            "Line": 15,
+            "Source": "",
+            "StartFileName": "/tmp/test.cpp",
+            "StartLine": 14
+          }
+        ]
+      },
+      {
+        "Address": "0x400486",
+        "ModuleName": "inlined.elf",
+        "Symbol": [
+          {
+            "Column": 3,
+            "Discriminator": 0,
+            "FileName": "/tmp/test.cpp",
+            "FunctionName": "foo()",
+            "Line": 6,
+            "Source": "",
+            "StartFileName": "/tmp/test.cpp",
+            "StartLine": 5
+          }
+        ]
+      }
+    ]
+
 .. option:: --pretty-print, -p
 
   Print human readable output. If :option:`--inlining` is specified, the
   enclosing scope is prefixed by (inlined by).
+  For JSON output, the option will cause JSON to be indented and split over
+  new lines. Otherwise, the JSON output will be printed in a compact form.
 
   .. 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
 

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

 // structures defined in DebugInfo/DIContext.h
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_DIPRINTER_H
 #define LLVM_DEBUGINFO_SYMBOLIZE_DIPRINTER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/JSON.h"
 #include <string>
 #include <vector>
 
 namespace llvm {
 struct DILineInfo;
 class DIInliningInfo;
 struct DIGlobal;
 struct DILocal;
 class ErrorInfoBase;
 class raw_ostream;
 
 namespace symbolize {
 
 struct Request {
   StringRef ModuleName;
-  uint64_t Address = 0;
+  Optional<uint64_t> Address;
 };
 
 class DIPrinter {
 public:
-  DIPrinter(){};
-  virtual ~DIPrinter(){};
+  DIPrinter() {}
+  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 void printInvalidCommand(const Request &Request,
-                                   const ErrorInfoBase &ErrorInfo) = 0;
+                                   StringRef Command) = 0;
 
   virtual bool printError(const Request &Request,
                           const ErrorInfoBase &ErrorInfo,
                           StringRef ErrorBanner) = 0;
+
+  virtual void listBegin() = 0;
+  virtual void listEnd() = 0;
 };
 
 struct PrinterConfig {
   bool PrintAddress;
   bool PrintFunctions;
   bool Pretty;
   bool Verbose;
   int SourceContextLines;
PlainPrinterBase(raw_ostream &OS, raw_ostream &ES, PrinterConfig &Config)
       : DIPrinter(), OS(OS), ES(ES), Config(Config) {}
 
   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;
 
-  void printInvalidCommand(const Request &Request,
-                           const ErrorInfoBase &ErrorInfo) override;
+  void printInvalidCommand(const Request &Request, StringRef Command) override;
 
   bool printError(const Request &Request, const ErrorInfoBase &ErrorInfo,
                   StringRef ErrorBanner) override;
+
+  void listBegin() override {}
+  void listEnd() override {}
 };
 
 class LLVMPrinter : public PlainPrinterBase {
 private:
   void printSimpleLocation(StringRef Filename, const DILineInfo &Info) override;
   void printFooter() override;
 
 public:
   LLVMPrinter(raw_ostream &OS, raw_ostream &ES, PrinterConfig &Config)
       : PlainPrinterBase(OS, ES, Config) {}
 };
 
 class GNUPrinter : public PlainPrinterBase {
 private:
   void printSimpleLocation(StringRef Filename, const DILineInfo &Info) override;
 
 public:
   GNUPrinter(raw_ostream &OS, raw_ostream &ES, PrinterConfig &Config)
       : PlainPrinterBase(OS, ES, Config) {}
 };
+
+class JSONPrinter : public DIPrinter {
+private:
+  raw_ostream &OS;
+  PrinterConfig Config;
+  std::unique_ptr<json::Array> ObjectList;
+
+  void printJSON(const json::Value &V) {
+    json::OStream JOS(OS, Config.Pretty ? 2 : 0);
+    JOS.value(V);
+    OS << '\n';
+  }
+
+public:
+  JSONPrinter(raw_ostream &OS, PrinterConfig &Config)
+      : DIPrinter(), OS(OS), Config(Config) {}
+
+  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;
+
+  void printInvalidCommand(const Request &Request, StringRef Command) override;
+
+  bool printError(const Request &Request, const ErrorInfoBase &ErrorInfo,
+                  StringRef ErrorBanner) override;
+
+  void listBegin() override;
+  void listEnd() override;
+};
 } // namespace symbolize
 } // namespace llvm
 
 #endif

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
 namespace symbolize {
 
 void PlainPrinterBase::printHeader(uint64_t Address) {
   if (Config.PrintAddress) {
     OS << "0x";
     OS.write_hex(Address);
     StringRef Delimiter = Config.Pretty ? ": " : "\n";
     OS << Delimiter;
   }
 }
 
 // Prints source code around in the FileName the Line.
 void PlainPrinterBase::printContext(StringRef FileName, int64_t Line) {
   if (Config.SourceContextLines <= 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 - Config.SourceContextLines / 2);
   int64_t LastLine = FirstLine + Config.SourceContextLines;
if (Filename == DILineInfo::BadString)
     Filename = DILineInfo::Addr2LineBadString;
   if (Config.Verbose)
     printVerbose(Filename, Info);
   else
     printSimpleLocation(Filename, Info);
 }
 
 void PlainPrinterBase::print(const Request &Request, const DILineInfo &Info) {
-  printHeader(Request.Address);
+  printHeader(*Request.Address);
   print(Info, false);
   printFooter();
 }
 
 void PlainPrinterBase::print(const Request &Request,
                              const DIInliningInfo &Info) {
-  printHeader(Request.Address);
+  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);
+  printHeader(*Request.Address);
   StringRef Name = Global.Name;
   if (Name == DILineInfo::BadString)
     Name = DILineInfo::Addr2LineBadString;
   OS << Name << "\n";
   OS << Global.Start << " " << Global.Size << "\n";
   printFooter();
 }
 
 void PlainPrinterBase::print(const Request &Request,
                              const std::vector<DILocal> &Locals) {
-  printHeader(Request.Address);
+  printHeader(*Request.Address);
   if (Locals.empty())
     OS << DILineInfo::Addr2LineBadString << '\n';
   else
     for (const DILocal &L : Locals) {
       if (L.FunctionName.empty())
         OS << DILineInfo::Addr2LineBadString;
       else
         OS << L.FunctionName;
for (const DILocal &L : Locals) {
         OS << *L.FrameOffset;
       else
         OS << DILineInfo::Addr2LineBadString;
       OS << ' ';
 
       if (L.Size)
         OS << *L.Size;
       else
         OS << DILineInfo::Addr2LineBadString;
       OS << ' ';
 
       if (L.TagOffset)
         OS << *L.TagOffset;
       else
         OS << DILineInfo::Addr2LineBadString;
       OS << '\n';
     }
   printFooter();
 }
 
 void PlainPrinterBase::printInvalidCommand(const Request &Request,
-                                           const ErrorInfoBase &ErrorInfo) {
-  OS << ErrorInfo.message() << '\n';
+                                           StringRef Command) {
+  OS << Command << '\n';
 }
 
 bool PlainPrinterBase::printError(const Request &Request,
                                   const ErrorInfoBase &ErrorInfo,
                                   StringRef ErrorBanner) {
   ES << ErrorBanner;
   ErrorInfo.log(ES);
   ES << '\n';
   // Print an empty struct too.
   return true;
 }
 
+static std::string toHex(uint64_t V) {
+  return ("0x" + Twine::utohexstr(V)).str();
+}
+
+static json::Object toJSON(const Request &Request, StringRef ErrorMsg = "") {
+  json::Object Json({{"ModuleName", Request.ModuleName.str()}});
+  if (Request.Address)
+    Json["Address"] = toHex(*Request.Address);
+  if (!ErrorMsg.empty())
+    Json["Error"] = json::Object({{"Message", ErrorMsg.str()}});
+  return Json;
+}
+
+void JSONPrinter::print(const Request &Request, const DILineInfo &Info) {
+  DIInliningInfo InliningInfo;
+  InliningInfo.addFrame(Info);
+  print(Request, InliningInfo);
+}
+
+void JSONPrinter::print(const Request &Request, const DIInliningInfo &Info) {
+  json::Array Array;
+  for (uint32_t I = 0, N = Info.getNumberOfFrames(); I < N; ++I) {
+    const DILineInfo &LineInfo = Info.getFrame(I);
+    Array.push_back(json::Object(
+        {{"FunctionName", LineInfo.FunctionName != DILineInfo::BadString
+                              ? LineInfo.FunctionName
+                              : ""},
+         {"StartFileName", LineInfo.StartFileName != DILineInfo::BadString
+                               ? LineInfo.StartFileName
+                               : ""},
+         {"StartLine", LineInfo.StartLine},
+         {"FileName",
+          LineInfo.FileName != DILineInfo::BadString ? LineInfo.FileName : ""},
+         {"Line", LineInfo.Line},
+         {"Column", LineInfo.Column},
+         {"Discriminator", LineInfo.Discriminator}}));
+  }
+  json::Object Json = toJSON(Request);
+  Json["Symbol"] = std::move(Array);
+  if (ObjectList)
+    ObjectList->push_back(std::move(Json));
+  else
+    printJSON(std::move(Json));
+}
+
+void JSONPrinter::print(const Request &Request, const DIGlobal &Global) {
+  json::Object Data(
+      {{"Name", Global.Name != DILineInfo::BadString ? Global.Name : ""},
+       {"Start", toHex(Global.Start)},
+       {"Size", toHex(Global.Size)}});
+  json::Object Json = toJSON(Request);
+  Json["Data"] = std::move(Data);
+  if (ObjectList)
+    ObjectList->push_back(std::move(Json));
+  else
+    printJSON(std::move(Json));
+}
+
+void JSONPrinter::print(const Request &Request,
+                        const std::vector<DILocal> &Locals) {
+  json::Array Frame;
+  for (const DILocal &Local : Locals) {
+    json::Object FrameObject(
+        {{"FunctionName", Local.FunctionName},
+         {"Name", Local.Name},
+         {"DeclFile", Local.DeclFile},
+         {"DeclLine", int64_t(Local.DeclLine)},
+         {"Size", Local.Size ? toHex(*Local.Size) : ""},
+         {"TagOffset", Local.TagOffset ? toHex(*Local.TagOffset) : ""}});
+    if (Local.FrameOffset)
+      FrameObject["FrameOffset"] = *Local.FrameOffset;
+    Frame.push_back(std::move(FrameObject));
+  }
+  json::Object Json = toJSON(Request);
+  Json["Frame"] = std::move(Frame);
+  if (ObjectList)
+    ObjectList->push_back(std::move(Json));
+  else
+    printJSON(std::move(Json));
+}
+
+void JSONPrinter::printInvalidCommand(const Request &Request,
+                                      StringRef Command) {
+  printError(Request,
+             StringError("unable to parse arguments: " + Command,
+                         std::make_error_code(std::errc::invalid_argument)),
+             "");
+}
+
+bool JSONPrinter::printError(const Request &Request,
+                             const ErrorInfoBase &ErrorInfo,
+                             StringRef ErrorBanner) {
+  json::Object Json = toJSON(Request, ErrorInfo.message());
+  if (ObjectList)
+    ObjectList->push_back(std::move(Json));
+  else
+    printJSON(std::move(Json));
+  return false;
+}
+
+void JSONPrinter::listBegin() {
+  assert(!ObjectList);
+  ObjectList = std::make_unique<json::Array>();
+}
+
+void JSONPrinter::listEnd() {
+  assert(ObjectList);
+  printJSON(std::move(*ObjectList));
+  ObjectList.release();
+}
+
 } // end namespace symbolize
 } // end namespace llvm

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

+## This test checks JSON output for CODE.
+
+## If the addresses are specified on the command-line, the output JSON will
+## contain an array of the results for all of the given addresses.
+
+## Show how library errors are reported in the output.
+# 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:[{"Address":"0x0","Error":{"Message":"[[MSG]]"},"ModuleName":"{{.*}}/no-file.exe"}]
+
+## Resolve out of range address.
+## Expected a list with one empty object with default values.
+# RUN: llvm-symbolizer --output-style=JSON -e %p/Inputs/addr.exe 0x10000000 | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+# NOT-FOUND:[{"Address":"0x10000000","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":0,"Discriminator":0,"FileName":"","FunctionName":"","Line":0,"StartFileName":"","StartLine":0}]}]
+
+## Check a non-zero discriminator.
+# RUN: llvm-symbolizer --output-style=JSON --obj=%p/Inputs/discrim 0x400575 | \
+# RUN:   FileCheck %s --check-prefix=DISCRIM --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+# DISCRIM:[{"Address":"0x400575","ModuleName":"{{.*}}/Inputs/discrim","Symbol":[{"Column":17,"Discriminator":2,"FileName":"/tmp{{/|\\\\}}discrim.c","FunctionName":"foo","Line":5,"StartFileName":"/tmp{{/|\\\\}}discrim.c","StartLine":4}]}]
+
+## In case of stdin input the output will contain a single JSON object for each input string.
+
+## This test case is testing stdin input, with the --no-inlines option.
+# 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:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+## Resolve valid address.
+# NO-INLINES-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":3,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2}]}
+## Invalid argument after a valid one.
+# NO-INLINES-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+
+## This test case is testing stdin input, inlines by default.
+# 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.
+# INLINE:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+## Resolve valid address.
+# INLINE-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inctwo","Line":3,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inc","Line":7,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":14,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
+## Invalid argument after a valid one.
+# INLINE-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+
+## Also check the last test case with llvm-adr2line.
+## The expected result is the same with -f -i.
+# RUN: llvm-addr2line --output-style=JSON -f -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.
+# INLINE-A2L:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+## Resolve valid address.
+# INLINE-A2L-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inctwo","Line":3,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"inc","Line":7,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"main","Line":14,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
+## Invalid argument after a valid one.
+# INLINE-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+
+## Note llvm-addr2line without -f does not print the function name in JSON too.
+# RUN: llvm-addr2line --output-style=JSON -i -e %p/Inputs/addr.exe < %p/Inputs/addr.inp | \
+# RUN:   FileCheck %s --check-prefix=NO-FUNC-A2L --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+## Invalid first argument before any valid one.
+# NO-FUNC-A2L:{"Error":{"Message":"unable to parse arguments: some text"},"ModuleName":"{{.*}}/Inputs/addr.exe"}
+## Resolve valid address.
+# NO-FUNC-A2L-NEXT:{"Address":"0x40054d","ModuleName":"{{.*}}/Inputs/addr.exe","Symbol":[{"Column":3,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":3,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":2},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":7,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":6},{"Column":0,"Discriminator":0,"FileName":"/tmp{{/|\\\\}}x.c","FunctionName":"","Line":14,"StartFileName":"/tmp{{/|\\\\}}x.c","StartLine":12}]}
+## Invalid argument after a valid one.
+# NO-FUNC-A2L-NEXT:{"Error":{"Message":"unable to parse arguments: some text2"},"ModuleName":"{{.*}}/Inputs/addr.exe"}

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

+## This test checks JSON output for DATA.
+
+# REQUIRES: x86-registered-target
+
+## Show how library errors are reported in the output.
+# 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:[{"Address":"0x0","Error":{"Message":"[[MSG]]"},"ModuleName":"{{.*}}no-file.o"}]
+
+## 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:[{"Error":{"Message":"unable to parse arguments: DATA tmp.o Z"},"ModuleName":"tmp.o"}]
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+
+## Resolve out of range address.
+# RUN: llvm-symbolizer "DATA %t.o 0x10000000" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+# NOT-FOUND:[{"Address":"0x10000000","Data":{"Name":"","Size":"0x0","Start":"0x0"},"ModuleName":"{{.*}}.o"}]
+
+## 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:[{"Address":"0x0","Data":{"Name":"d1","Size":"0x8","Start":"0x0"},"ModuleName":"{{.*}}.o"}]
+
+## Test multiple addresses on the command-line.
+# RUN: llvm-symbolizer -e=%t.o "DATA 2" "DATA 8" --output-style=JSON | \
+# RUN:   FileCheck %s --check-prefix=MULTI --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+# MULTI:[{"Address":"0x2","Data":{"Name":"d1","Size":"0x8","Start":"0x0"},"ModuleName":"{{.*}}.o"},{"Address":"0x8","Data":{"Name":"d2","Size":"0x4","Start":"0x8"},"ModuleName":"{{.*}}.o"}]
+
+d1:
+    .quad 0x1122334455667788
+    .size d1, 8
+
+d2:
+    .long 0x99aabbcc
+    .size d2, 4

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

+; This test checks JSON output for FRAME.
+
+; Show how library errors are reported in the output.
+; 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:[{"Address":"0x0","Error":{"Message":"[[MSG]]"},"ModuleName":"{{.*}}no-file.o"}]
+
+; 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:[{"Error":{"Message":"unable to parse arguments: FRAME tmp.o Z"},"ModuleName":"tmp.o"}]
+
+; RUN: llc -filetype=obj -o %t.o %s 
+
+; Resolve out of range address. Expected an empty array.
+; RUN: llvm-symbolizer "FRAME %t.o 0x10000000" --output-style=JSON | \
+; RUN:   FileCheck %s --check-prefix=NOT-FOUND --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+; NOT-FOUND:[{"Address":"0x10000000","Frame":[],"ModuleName":"{{.*}}.o"}]
+
+; Resolve valid address. Note we check 0, non-zero and missing TagOffset too.
+; RUN: llvm-symbolizer "FRAME %t.o 0" --output-style=JSON | \
+; RUN:   FileCheck %s --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+; CHECK:[{"Address":"0x0","Frame":[{"DeclFile":"/x.c","DeclLine":2,"FrameOffset":24,"FunctionName":"f","Name":"a","Size":"0x8","TagOffset":"0x0"},{"DeclFile":"/x.c","DeclLine":3,"FrameOffset":16,"FunctionName":"f","Name":"b","Size":"0x8","TagOffset":"0x1"},{"DeclFile":"/x.c","DeclLine":4,"FrameOffset":12,"FunctionName":"f","Name":"c","Size":"0x4","TagOffset":""}],"ModuleName":"{{.*}}.o"}]
+
+target triple="aarch64--"
+
+define void @f() !dbg !6 {
+entry:
+  %a = alloca i8*
+  %b = alloca i8*
+  %c = alloca i32
+  call void @llvm.dbg.declare(metadata i8** %a, metadata !12, metadata !DIExpression(DW_OP_LLVM_tag_offset, 0)), !dbg !15
+  call void @llvm.dbg.declare(metadata i8** %b, metadata !13, metadata !DIExpression(DW_OP_LLVM_tag_offset, 1)), !dbg !16
+  call void @llvm.dbg.declare(metadata i32* %c, metadata !14, metadata !DIExpression()), !dbg !17
+  ret void, !dbg !18
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "x.c", directory: "/")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang"}
+!6 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags:
+DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null, !9}
+!9 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!10 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !11)
+!11 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!19 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DILocalVariable(name: "a", scope: !6, file: !1, line: 2, type: !9)
+!13 = !DILocalVariable(name: "b", scope: !6, file: !1, line: 3, type: !9)
+!14 = !DILocalVariable(name: "c", scope: !6, file: !1, line: 4, type: !19)
+!15 = !DILocation(line: 2, column: 10, scope: !6)
+!16 = !DILocation(line: 3, column: 11, scope: !6)
+!17 = !DILocation(line: 4, column: 12, scope: !6)
+!18 = !DILocation(line: 5, column: 13, scope: !6)

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

handleAllErrors(std::move(ResOrErr.takeError()),
                     PrintEmpty = Printer.printError(
                         Request, EI, "LLVMSymbolizer: error reading file: ");
                   });
 
   if (PrintEmpty)
     Printer.print(Request, T());
 }
 
-enum class OutputStyle { LLVM, GNU };
+enum class OutputStyle { LLVM, GNU, JSON };
 
 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";

 static void symbolizeInput(const opt::InputArgList &Args, uint64_t AdjustVMA,
                            bool IsAddr2Line, OutputStyle Style,
                            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.printInvalidCommand(
-        {ModuleName, Offset},
-        StringError(InputString,
-                    std::make_error_code(std::errc::invalid_argument)));
+    Printer.printInvalidCommand({ModuleName, None}, InputString);
     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(
for (const opt::Arg *A : Args.filtered(OPT_dsym_hint_EQ)) {
     } else {
       errs() << "Warning: invalid dSYM hint: \"" << Hint
              << "\" (must have the '.dSYM' extension).\n";
     }
   }
 
   auto Style = IsAddr2Line ? OutputStyle::GNU : OutputStyle::LLVM;
   if (const opt::Arg *A = Args.getLastArg(OPT_output_style_EQ)) {
-    Style = strcmp(A->getValue(), "GNU") == 0 ? OutputStyle::GNU
-                                              : OutputStyle::LLVM;
+    if (strcmp(A->getValue(), "GNU") == 0)
+      Style = OutputStyle::GNU;
+    else if (strcmp(A->getValue(), "JSON") == 0)
+      Style = OutputStyle::JSON;
+    else
+      Style = OutputStyle::LLVM;
   }
 
   LLVMSymbolizer Symbolizer(Opts);
   std::unique_ptr<DIPrinter> Printer;
   if (Style == OutputStyle::GNU)
     Printer = std::make_unique<GNUPrinter>(outs(), errs(), Config);
+  else if (Style == OutputStyle::JSON)
+    Printer = std::make_unique<JSONPrinter>(outs(), Config);
   else
     Printer = std::make_unique<LLVMPrinter>(outs(), errs(), Config);
 
   std::vector<std::string> InputAddresses = Args.getAllArgValues(OPT_INPUT);
   if (InputAddresses.empty()) {
     const int kMaxInputStringLength = 1024;
     char InputString[kMaxInputStringLength];
 
     while (fgets(InputString, sizeof(InputString), stdin)) {
       // Strip newline characters.
       std::string StrippedInputString(InputString);
       llvm::erase_if(StrippedInputString,
                      [](char c) { return c == '\r' || c == '\n'; });
       symbolizeInput(Args, AdjustVMA, IsAddr2Line, Style, StrippedInputString,
                      Symbolizer, *Printer);
       outs().flush();
     }
   } else {
+    Printer->listBegin();
     for (StringRef Address : InputAddresses)
       symbolizeInput(Args, AdjustVMA, IsAddr2Line, Style, Address, Symbolizer,
                      *Printer);
+    Printer->listEnd();
   }
 
   return 0;
 }