Add JSON output skeleton to llvm-readelf

[Jaysonyan]

Summary

This change adds JSON output to llvm-readelf. It is enabled through the --elf-output-style
option which now supports JSON in addition to the existing LLVM and GNU. This patch
just lays out the needed infrastructure and skeleton code but doesn't include any
implementation.

The major change was the need for a json printer that can be instantiated at the top level
of llvm-readobj. Since llvm-readobj uses ScopedPrinter this change adds a JSONScopedPrinter
as well as a ScopedPrinterBase which both ScopedPrinter and JSONScopedPrinter both
inherit from.

Corresponding RFC: https://lists.llvm.org/pipermail/llvm-dev/2021-September/152994.html

[jhenderson]

Some high-level comments:

1. Please include a link to the RFC email thread where this was discussed, in your commit/patch description, for ease of reference.
2. Please make sure to create your diff with full context, using -U999999 when you make the diff.
3. Please make sure to clang-format all your changes.
4. I think it makes sense to split this down even further than you have done. I'd start with literally just adding the option and skeleton dumping structure, without any implementation of the dump at all. Your later patches can then flesh out each individual dump option. This also means that you can have lots of child patches that base off this one, which are entirely independent, so it doesn't matter what order they get implemented or committed in.
5. You should update the llvm-readobj and llvm-readelf .rst files in llvm/docs/CommandGuide to discuss the new output mode, perhaps adding something like "Not all options are currently supported by this mode" or something to that effect.

Also, if you wish to add other commits in a series, that are built on top of this patch, you can use the "Edit Related Revisions" option. These will then appear in a new tab in the revision summary panel called "Stack", so that it's possible to get a quick overview of where things are.

Regarding the overall output appearance, it seems to me like you should have the JSON for a file formatted as a single JSON object, with each output variety in its own child object, labelled according to the option name or similar. Since llvm-readobj and llvm-readelf also both support multiple input files, you need a strategy for how these might be dumped. My instinct says that you actually have the dump output for a file added as child members to a top-level object, labelled by their file names. Finally, you should give some thought to how archive members are printed. I think you could either have them printed as individual objects within a JSON object representing the whole archive, or just as regular files, but with the names disambiguated. I've gone with the latter approach below:

{
    "object.o" : {
        "file-header" : { <output for file header> },
        "section-headers" : { <section header table> }
    },
    "archive.a(member1.o)": {
        "file-header" : { <output for file header> },
        "section-headers" : { <section header table> }
    },
    "archive.a(member2.o)": {
        "file-header" : { <output for file header> },
        "section-headers" : { <section header table> }
    }
}

I hope the reasoning for this is clear, but if you've got other ideas, I'm happy to discuss them.

[Jaysonyan]

Thanks for all the feedback! I was working on updating the patch according to your comments and I've been thinking about what you've mentioned about handling multiple object files and archives.

Finally, you should give some thought to how archive members are printed. I think you could either have them printed as individual objects within a JSON object representing the whole archive, or just as regular files, but with the names disambiguated. I've gone with the latter approach below:

Regarding the structure of outputting archives, I am leaning towards your first suggestion which is outputting each archive member as a child object within an overall JSON object. I think this would allow the output to be consumed easier since then there's no need to parse the names of archive member to determine what archive it falls under. Given your example I would like to produce this:

{
    "object.o" : {
        "file-header" : { <output for file header> },
        "section-headers" : { <section header table> }
    },
    "archive.a" : {
        "member1.o": {
            "file-header" : { <output for file header> },
            "section-headers" : { <section header table> }
        },
        "member2.o": {
            "file-header" : { <output for file header> },
            "section-headers" : { <section header table> }
        },
    }
}

In terms of outputting as a single JSON object I agree that this seems like the right approach and it also pokes some holes into my current implementation. Since we would need to print things like the outer {} or object file names we need to output JSON at a higher level than just the JSONELFDumper. Since the json::OStream being used does validation that you are outputting valid json we would need to use the same json::OStream for any time we print since it will need to have the correct context (ex: ensuring you are printing attributes inside a parent object). To avoid needing to pass a json::OStream to every method that needs printing I'm considering creating a subclass of ScopedPrinter called JSONScopedPrinter which holds on to a json::OStream rather than a raw_ostream that way we can just create a JSONScopedPrinter and pass it as a ScopedPrinter to all necessary functions since they already accept a ScopedPrinter. This would allow me to still use the same json::OStream for all printing while also not heavily impacting the existing functions.

I'm hoping this sounds reasonable and I'm interested if you have any alternative ideas.

[jhenderson]

Thinking about it further, I think the JSON output stream is conceptually a higher-level output style than just for ELF files. In particular, you could imagine the future support being added for e.g. COFF and Mach-O objects (they'd have a different internal layout, but they'd still be objects to be printed using the JSON printer). Given that, it makes sense for this printer to be owned higher up the stack, i.e. as you're suggesting, where the ScopedPrinter currently lives. You'd still want a JSON object dumper implementation. Thus, you'd have two levels: your "ScopedPrinter" replacement would be responsible for printing the outer braces and object names (and handle archives probably too, although from a pure design aesthetic, an ArchiveDumper class might be nicer to handle this), with then individual ObjDumper instances handling printing the contenst of an object (including its corresponding outer braces). This is then nice, because the ObjDumper could be used to print a JSON object of the relevant type in other situations, not just within the outer ScopedPrinter instance. Ultimately, this sounds more-or-less like what you're proposing, which is great.

One other thought I had: I think we may need to be careful about duplicate objects in the input list: at the moment, they are dumped once per instance, i.e. llvm-readobj input.o input.o prints input.o twice. We probably should replicate this behaviour, which means we can't use object names as keys directly. I think this means we actually want a top-level array, with a name field in each object, which slightly breaks my design idea above. Alternatively, you could have something like:

[
  {
    "object.o" : {
      ... # Contents of object.o
    },
  }
...
]

There's essentially the same issue with archives: it's potentially possible for an archive to have two members with the same name.

[Jaysonyan]

Add a base class ScopedPrinterBase and concrete class JSONScopedPrinter.
Update llvm-readobj to utilize the base class and concrete classes JSONScopedPrinter
and ScopedPrinter.

[jhenderson]

llvm/docs/CommandGuide/llvm-readelf.rst

78

I'd be inclined to remove the "not all options are..." bit, as that's already the case for GNU versus LLVM style, and it will avoid the comment rotting as functionality is added.

llvm/docs/CommandGuide/llvm-readobj.rst

189–190

Same comments.

llvm/include/llvm/Support/JSONScopedPrinter.h

25

Please add a blank line between the constructor and this function.

75

I'm not sure you need this particular function. const std::string & should implicitly convert to StringRef. (I see it was there before, but I'd see whether you can delete this overload entirely).

79

Ditto. const char * implicitly converts to StringRef.

114

Nit: delete blank line at end of class.

116

Nit: delete this blank line too.

llvm/include/llvm/Support/ScopedPrinter.h

82

Do you need this and the classof functions? As far as I can tell, they aren't used anywhere.

99–100

Up to you, but I don't think there's a particular need to make this constructor protected, since the class is an abstract class, so can't be directly instantiated.

103

Slight naming quibble: at the moment, it's not clear why ScopedPrinter is not the base class, and why JSONScopedPrinter is a sibling class (shares same base class) and not a derived class of ScopedPrinter. I'd make ScopedPrinter the base class, and call this derived class something else. Perhaps UnstructuredScopedPrinter or PlainScopedPrinter (other ideas welcome)?

llvm/tools/llvm-readobj/COFFDumper.cpp

250

Do you need this case purely because you're avoiding changing COFFDumper to own a ScopedPrinterBase rather than a ScopedPrinter, or does the COFFDumper make use of functionality not in the base class? If the former, just change to using the base class all the way. If the latter, that suggests there's something not quite right with our design, as ideally the dumpers shouldn't need to know which variety of dumper they're using - what functionality is in the subclass?

625

It looks to me like you've clang-formatted the whole file. Don't do this as part of this patch - only format the bits of the file you've changed (you may be able to get away with a separate patch to reformat the whole file though).

llvm/tools/llvm-readobj/ELFDumper.cpp

805

In a similar manner to the COFF dumper earlier, it would be ideal if you could avoid the cast, and just pass a ScopedPrinterBase instance into the ELFDumper constructors. This would allow you to avoid many of the changes you've made where you pass in a ScopedPrinter now, and decouple the printer style from the actual scoped printer (in some cases, this may be all you need to get some functions to work for JSON style).

7455

Don't bother with these sorts of comments: they don't add any long-term benefit (and will rot very quickly).

llvm/tools/llvm-readobj/ObjDumper.cpp

84–90

Perhaps do this slightly differently, so that we can leave a clear TODO here for JSON output:

if (auto *W = dyn_cast<JSONScopedPrinter>(WriterBase))
  continue; // TODO: implement for JSON printer.
ScopedPrinter *W = cast<ScopedPrinter>(WriterBase);

Ideally of course, we'd find a way to avoid needing the casting at all. This might be achievable by splitting the iteration away from the printing: keep the iteration in this function, but have a printStringListEntry function that is called per iteration, and is a virtual function in the ScopedPrinterBase class, implemented in the subclasses.

138

For this and the similar printSectionsAsHex, I wonder if it would make sense to make this a virtual function that the JSONELFDumper implements differently, again to avoid the casting. Thoughts?

llvm/tools/llvm-readobj/llvm-readobj.cpp

342–352

How about the following:

1. Add a printFileHeader() function to the ScopedPrinterBase interface. For the JSONScopedPrinter, it does the objectBegin calls etc. For the ScopedPrinter, it does the LLVM/filename count checks (it might even do the later Format/Arch pritning too in this case).
2. Add a endFile() function which is a noop for ScopedPrinter but for the JSONScopedPrinter does the objectEnd calls etc.

This will avoid needing additional checks for opts::JSON, and helps hide some of the details a little further - ideally once you've created a ScopedPrinterBase instance, you should be able to avoid ever referencing the subclasses.

354–356

I don't think you need this cast here?

642–648

I think it's probably fine to just leave this called Writer - the fact that it's a base class shouldn't be important to the later code.

644

In a similar manner to my earlier comment about files, how about startOutput and endOutput functions?

650

You should be able to avoid some of the changes with pointer versus reference, by doing *WriterBase.get();

[Jaysonyan]

llvm/include/llvm/Support/ScopedPrinter.h

82

I believe this is needed to perform dyn_cast. I was following the guide here: https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html

103

I agree, the naming feels a bit weird right now. I held off on renaming this class and making any changes to the interface since the ScopedPrinter is used outside of llvm-readobj and I didn't want this change to affect any other tool. Although if this is something that you think is fine to do, I'd be happy to change it. I think PlainScopedPrinter seems like an appropriate name.

llvm/tools/llvm-readobj/ObjDumper.cpp

138

I was hesitant to change too much of the ScopedPrinter interface to cater too closely to the needs of llvm-readobj since its used elsewhere as well.

llvm/tools/llvm-readobj/llvm-readobj.cpp

342–352

Similar to my feeling about adding a printSectionAsString and printSectionAsHex to the base class, I'm hesitant about adding methods to meet specific needs of llvm-readobj.

I assumed it would be nice to keep ScopedPrinter somewhat primitive but I'm interested if you have any thoughts on this?

[jhenderson]

To collate the common topics into one place, regarding additional virtual functions etc. I didn't register that ScopedPrinter is used outside the llvm-readobj code. Given that it is, I agree that modifying the base class to provide additional virtual functions would be undesirable. However, I did have another idea. Given that we ideally want a ScopedPrinter that has an interface suitable for llvm-readobj, how about we do the following:

1. Leave the original ScopedPrinter largely untouched, except making the common methods like printNumber virtual, adding a virtual destructor etc.
2. Within the llvm-readobj tree, create a new ReadobjScopedPrinter which is just an extension of the former, but with the additional methods added needed by llvm-readobj. This could be pure virtual, or provide default implementations of the extension functions.
3. Change all usages of ScopedPrinter to ReadobjScopedPrinter within the llvm-readobj code.
4. Change JSONScopedPrinter to derive from ReadobjScopedPrinter and implement the additional functions (and move it into the llvm-readobj code).

I'm not 100% happy with this last point. I feel like there's something in the Design Patterns space that would allow us to keep the JSON scoped printer generic, and provide a specialisation of it within llvm-readobj, but I haven't figured out how you'd get the llvm-readobj specific bit of the interface to work in this case yet.

llvm/include/llvm/Support/ScopedPrinter.h

82

Yes, you're right: I meant to come back and delete this comment after seeing the casting later on.

[Jaysonyan]

4. Change JSONScopedPrinter to derive from ReadobjScopedPrinter and implement the additional functions (and move it into the llvm-readobj code).

One thing that makes this implementation plan difficult is that JSONScopedPrinter needs to output valid json. There are some methods offered by ScopedPrinter that would make it difficult to ensure a JSONScopedPrinter prints valid json while still offering these methods. The most notable is startLine() which provides direct access to the underlying raw_ostream. If the JSONScopedPrinter inherits from ScopedPrinter I don't believe there is a way around not offering this method.

All implementations of ObjDumper utilize methods such as startLine() or perform other operations that may be undesirable/invalid to in json such as not enclosing each method in its own child object or having duplicate object keys (ex COFFDumper::printCOFFExports). So it may be preferable to keep the current structure and have ObjDumper implementations rely on a specific printer-type. Since passing a JSONScopedPrinter to any dumper that isn't the JSONELFDumper would likely produce invalid json.

[Jaysonyan]

Update readelf and readobj docs wording
Misc formatting and renaming changes

[Jaysonyan]

@jhenderson I was wondering if you had any more thoughts on the design on ScopedPrinter/ ScopedPrinterBase/JSONScopedPrinter? As I see it right now, it's not very feasible to treat ScopedPrinter and JSONScopedPrinter uniformly due to the usage of methods like startLine(). So a parent-child structure between ScopedPrinter and JSONScopedPrinter might not be suitable.

[jhenderson]

In D111658#3117315, @Jaysonyan wrote:

@jhenderson I was wondering if you had any more thoughts on the design on ScopedPrinter/ ScopedPrinterBase/JSONScopedPrinter? As I see it right now, it's not very feasible to treat ScopedPrinter and JSONScopedPrinter uniformly due to the usage of methods like startLine(). So a parent-child structure between ScopedPrinter and JSONScopedPrinter might not be suitable.

Sorry, I'm a little bit busy, and have a number of other reviews that are calling for my attention too. I haven't had a chance to give this too much further thought yet. One initial thought I had was that things like printLine might just be a no-op for JSON output, although I think it might be nicer if we could wrap these sorts of calls behind another interface suitable for generic llvm-readobj usage. Unfortunately, I don't have the time right now to take a look at all usages, to see if there's a way we could represent such functions in a cleaner manner. I'll try to come back to this later this week, or next week, if I can.

[Jaysonyan]

In D111658#3117710, @jhenderson wrote:

Sorry, I'm a little bit busy, and have a number of other reviews that are calling for my attention too. I haven't had a chance to give this too much further thought yet. One initial thought I had was that things like printLine might just be a no-op for JSON output, although I think it might be nicer if we could wrap these sorts of calls behind another interface suitable for generic llvm-readobj usage. Unfortunately, I don't have the time right now to take a look at all usages, to see if there's a way we could represent such functions in a cleaner manner. I'll try to come back to this later this week, or next week, if I can.

That's totally understandable and I appreciate the time you're taking to review this change. For the sake of saving time, I'll provide all of my thoughts on the design as well as my reasoning behind them in the hopes that it could save some back and forth.

I think that having JSONScopedPrinter as a subclass of ScopedPrinter would have more downsides than upsides without major refactoring to how we interact with ScopedPrinter in llvm-readobj. I believe the biggest driving force to having JSONScopedPrinter as a subclass to ScopedPrinter is with the hope that each implementation of ObjDumper can be agnostic to the type of ScopedPrinter it is using (json or regular). Although I don't believe that this is possible for a few reasons:

1. ScopedPrinter has a few template methods. I know template and virtual methods don't mix well. I'm not sure if there is a way around this that LLVM has used but I thought it'd be valuable to bring up if this is an issue.
2. The startLine() method as mentioned previously, provides access to the underlying raw_ostream. While it is possible to provide this functionality in the JSONScopedPrinter (through calling json::OStream::rawValueBegin), it would be non-trivial to ensure that the usage of this results in valid json (we would also need to find a way to call json::OStream::rawValueEnd afterwards). Alternatively, making startline() in JSONScopedPrinter an no-op may result in necessary information being omitted.
3. The structure of json can trip up certain usage of ScopedPrinter. One example is attributes inside of lists, here is an example of code inside LLVMElfDumper:

template <class ELFT> void LLVMELFDumper<ELFT>::printSectionHeaders() {
  ...
  if (opts::SectionSymbols) {
    ListScope D(W, "Symbols");
    ...
    for (const Elf_Sym &Sym : Symbols) {
      ...
      printSymbol(...);
    }
  ...
}

void LLVMELFDumper<ELFT>::printSymbol(...) {
  ...
  DictScope Group(W, "Symbol");
  W.printNumber("Name", FullSymbolName, Symbol.st_name);
  W.printHex("Value", Symbol.st_value);
  ...
}

So with a ScopedPrinter this could produce something like:

Symbols [
  Symbol {
    Name: foo (1)
    Value: 0x0
  }
  Symbol {
    Name: bar (2)
    Value: 0x0
  }
]

Although the equivalent json would not be valid due to attributes inside of a list:

"Symbols": [
  "Symbol": {
    "Name": "foo",
    "Value": "0x0"
  },
  "Symbol": {
    "Name": "bar",
    "Value": "0x0"
  }
]

So for these reasons I don't think we'd be able to have ScopedPrinter-agnostic ObjDumper implementation without significant refactors to how we interact with ScopedPrinter to ensure we're printing valid json while maintaining the current LLVM format remains unchanged. And if we don't receive this benefit I believe the downsides of having JSONScopedPrinter inherit from ScopedPrinter (JSONScopedPrinter needing offer all methods ScopedPrinter offers, many of which would be unused) outweigh the benefits.

Ultimately I think it would be ideal to reach a point where an ObjDumper can be printer-agnostic but it would require non-trivial refactors in most ObjDumper implementations to reach that point. And since currently our only need is for llvm-readelf to output json, I believe the current implementation is sufficient for addressing our needs.

[Jaysonyan]

In D111658#3121940, @Jaysonyan wrote:

I think that having JSONScopedPrinter as a subclass of ScopedPrinter would have more downsides than upsides without major refactoring to how we interact with ScopedPrinter in llvm-readobj. I believe the biggest driving force to having JSONScopedPrinter as a subclass to ScopedPrinter is with the hope that each implementation of ObjDumper can be agnostic to the type of ScopedPrinter it is using (json or regular). Although I don't believe that this is possible for a few reasons:

Since making this comment I've been thinking of possible solutions to these problems. I've uploaded D114052: Add JSONScopedPrinter as a subclass to ScopedPrinter with history stack and D114053: Add JSONScopedPrinter as a subclass to ScopedPrinter with array output which are two approaches that attempt to solve the 3 issues laid out in this comment. Hopefully either of those 2 PRs (or this one) will be a sufficient solution to meet our needs.

[jhenderson]

In D111658#3136536, @Jaysonyan wrote:

In D111658#3121940, @Jaysonyan wrote:

I think that having JSONScopedPrinter as a subclass of ScopedPrinter would have more downsides than upsides without major refactoring to how we interact with ScopedPrinter in llvm-readobj. I believe the biggest driving force to having JSONScopedPrinter as a subclass to ScopedPrinter is with the hope that each implementation of ObjDumper can be agnostic to the type of ScopedPrinter it is using (json or regular). Although I don't believe that this is possible for a few reasons:

Since making this comment I've been thinking of possible solutions to these problems. I've uploaded D114052: Add JSONScopedPrinter as a subclass to ScopedPrinter with history stack and D114053: Add JSONScopedPrinter as a subclass to ScopedPrinter with array output which are two approaches that attempt to solve the 3 issues laid out in this comment. Hopefully either of those 2 PRs (or this one) will be a sufficient solution to meet our needs.

Thanks for thinking about this, and sorry for not coming back sooner (I've been dealing with deadlines, but am now free for a bit, so hopefully will have a bit more time). I quite like the "history stack" idea of the two new approaches, and I think the solutions to the other cases are viable. Note however that your two new diffs appear to be identical? Either that or I'm missing where the problem 3 approach differs in the implementation.

Do you have a preference for an approach of the three?

[Jaysonyan]

In D111658#3136905, @jhenderson wrote:

Thanks for thinking about this, and sorry for not coming back sooner (I've been dealing with deadlines, but am now free for a bit, so hopefully will have a bit more time). I quite like the "history stack" idea of the two new approaches, and I think the solutions to the other cases are viable. Note however that your two new diffs appear to be identical? Either that or I'm missing where the problem 3 approach differs in the implementation.

Do you have a preference for an approach of the three?

The interface for ScopedPrinter can broadly be split into 2 categories. The first is methods that creates scopes, the second is printing values inside those scopes. The first categories consists of objectBegin(), arrayBegin(), objectBegin(attr), arrayBegin(attr) (and their respective end methods). The second category are methods such as printString(Label, Value) which print actual values, usually as a key-value pair. The goal for both the history
stack and array output approach is that when printing key-value pairs its inside the context of an object and when printing single values (ex: arrays, object, number, string), its inside the context of arrays.

The history stack approach utilizes saved context to conditionally output surrounding {} inside objectBegin(attr)/arrayBegin(attr) when inside the context of an array.
The array output approach doesn't hold on to any context but will rather always output arrays and enclosing {} for both objectBegin()/arrayBegin() and for all key-value pairs it will always output enclosing {}. This ensures all calls to ScopedPrinter output single values and will always be in the context of an array.

Personally I prefer the history stack approach as well, but recognize the duplicated work of keeping a history stack inside both JSONScopedPrinter and json::OStream. The benefit of the array output is that it doesn't need to do any of this work but it comes at the expense of a somewhat unintuitive output.

[jhenderson]

In D111658#3139223, @Jaysonyan wrote:

In D111658#3136905, @jhenderson wrote:

Thanks for thinking about this, and sorry for not coming back sooner (I've been dealing with deadlines, but am now free for a bit, so hopefully will have a bit more time). I quite like the "history stack" idea of the two new approaches, and I think the solutions to the other cases are viable. Note however that your two new diffs appear to be identical? Either that or I'm missing where the problem 3 approach differs in the implementation.

Do you have a preference for an approach of the three?

The interface for ScopedPrinter can broadly be split into 2 categories. The first is methods that creates scopes, the second is printing values inside those scopes. The first categories consists of objectBegin(), arrayBegin(), objectBegin(attr), arrayBegin(attr) (and their respective end methods). The second category are methods such as printString(Label, Value) which print actual values, usually as a key-value pair. The goal for both the history
stack and array output approach is that when printing key-value pairs its inside the context of an object and when printing single values (ex: arrays, object, number, string), its inside the context of arrays.

The history stack approach utilizes saved context to conditionally output surrounding {} inside objectBegin(attr)/arrayBegin(attr) when inside the context of an array.
The array output approach doesn't hold on to any context but will rather always output arrays and enclosing {} for both objectBegin()/arrayBegin() and for all key-value pairs it will always output enclosing {}. This ensures all calls to ScopedPrinter output single values and will always be in the context of an array.

Personally I prefer the history stack approach as well, but recognize the duplicated work of keeping a history stack inside both JSONScopedPrinter and json::OStream. The benefit of the array output is that it doesn't need to do any of this work but it comes at the expense of a somewhat unintuitive output.

Thanks. I'm not too fussed by this duplication, if there's no practical way of avoiding it, and I agree that the output is more logical in this form. I'm going to start reviewing the "history stack" version now.

llvm/docs/CommandGuide/llvm-readelf.rst

  Display a bucket list histogram for dynamic symbol hash tables.
 
 .. option:: --elf-linker-options
 
  Display the linker options section.
 
 .. option:: --elf-output-style=<value>
 
- Format ELF information in the specified style. Valid options are ``LLVM`` and
- ``GNU``. ``LLVM`` output is an expanded and structured format, whilst ``GNU``
- (the default) output mimics the equivalent GNU :program:`readelf` output.
+ Format ELF information in the specified style. Valid options are ``LLVM``,
+ ``GNU``, and ``JSON``. ``LLVM`` output is an expanded and structured format.
+ ``GNU`` (the default) output mimics the equivalent GNU :program:`readelf` output.
+ ``JSON`` is json formatted output intended for machine consumption.
 
 .. option:: --section-groups, -g
 
  Display section groups.
 
 .. option:: --expand-relocs
 
  When used with :option:`--relocations`, display each relocation in an expanded

llvm/docs/CommandGuide/llvm-readobj.rst

  Display a bucket list histogram for dynamic symbol hash tables.
 
 .. option:: --elf-linker-options
 
  Display the linker options section.
 
 .. option:: --elf-output-style=<value>
 
- Format ELF information in the specified style. Valid options are ``LLVM`` and
- ``GNU``. ``LLVM`` output (the default) is an expanded and structured format,
- whilst ``GNU`` output mimics the equivalent GNU :program:`readelf` output.
+ Format ELF information in the specified style. Valid options are ``LLVM``,
+ ``GNU``, and ``JSON``. ``LLVM`` output is an expanded and structured format.
+ ``GNU`` (the default) output mimics the equivalent GNU :program:`readelf` output.
+ ``JSON`` is json formatted output intended for machine consumption.
 
 .. option:: --section-groups, -g
 
  Display section groups.
 
 .. option:: --gnu-hash-table
 
  Display the GNU hash table for dynamic symbols.
 

llvm/include/llvm/Support/JSONScopedPrinter.h

+//===-- JSONScopedPrinter.h ------------------------------------*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_JSONSCOPEDPRINTER_H
+#define LLVM_SUPPORT_JSONSCOPEDPRINTER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+namespace llvm {
+class JSONScopedPrinter : public ScopedPrinterBase {
+  json::OStream JOS;
+public:
+  JSONScopedPrinter(llvm::raw_ostream &OS)
+      : ScopedPrinterBase(ScopedPrinterBase::SPK_JSONScopedPrinter),
+        JOS(OS, 2) {}
+
+  static bool classof(const ScopedPrinterBase *SPB) {
+    return SPB->getKind() == SPK_JSONScopedPrinter;
+  }
+
+  void printNumber(StringRef Label, uint64_t Value) override {
+    JOS.attribute(Label, std::to_string(Value));
+  }
+
+  void printNumber(StringRef Label, uint32_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, uint16_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, uint8_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, int64_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, int32_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, int16_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, int8_t Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printNumber(StringRef Label, const APSInt &Value) override {
+    SmallString<64> StringValue;
+    Value.toString(StringValue);
+    JOS.attribute(Label, StringValue);
+  }
+
+  void printBoolean(StringRef Label, bool Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printString(StringRef Label, StringRef Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printString(StringRef Label, const std::string &Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  void printString(StringRef Label, const char *Value) override {
+    JOS.attribute(Label, Value);
+  }
+
+  template <typename T> void printList(StringRef Label, const T &List) {
+    JOS.attributeArray(Label, [&]() {
+      for (const auto &Item : List) {
+        JOS.value(Item);
+      }
+    });
+  }
+
+  void arrayBegin() {
+    JOS.arrayBegin();
+  }
+
+  void arrayEnd() {
+    JOS.arrayEnd();
+  }
+
+  void objectBegin() {
+    JOS.objectBegin();
+  }
+
+  void objectEnd() {
+    JOS.objectEnd();
+  }
+
+  void attributeBegin(StringRef Key) {
+    JOS.attributeBegin(Key);
+  }
+
+  void attributeEnd() {
+    JOS.attributeEnd();
+  }
+};
+} // namespace llvm
+
+#endif

llvm/include/llvm/Support/ScopedPrinter.h

 
 template <class T> std::string to_string(const T &Value) {
   std::string number;
   llvm::raw_string_ostream stream(number);
   stream << Value;
   return stream.str();
 }
 
-class ScopedPrinter {
+class ScopedPrinterBase {
 public:
-  ScopedPrinter(raw_ostream &OS) : OS(OS), IndentLevel(0) {}
+  enum ScopedPrinterKind {
+    SPK_ScopedPrinter,
+    SPK_JSONScopedPrinter,
+  };
+
+private:
+  ScopedPrinterKind Kind;
+
+public:
+  ScopedPrinterBase(ScopedPrinterKind Kind) : Kind(Kind) {}
+  virtual ~ScopedPrinterBase() {}
+  ScopedPrinterKind getKind() const { return Kind; }
+
+  virtual void printNumber(StringRef Label, uint64_t Value) = 0;
+  virtual void printNumber(StringRef Label, uint32_t Value) = 0;
+  virtual void printNumber(StringRef Label, uint16_t Value) = 0;
+  virtual void printNumber(StringRef Label, uint8_t Value) = 0;
+  virtual void printNumber(StringRef Label, int64_t Value) = 0;
+  virtual void printNumber(StringRef Label, int32_t Value) = 0;
+  virtual void printNumber(StringRef Label, int16_t Value) = 0;
+  virtual void printNumber(StringRef Label, int8_t Value) = 0;
+  virtual void printNumber(StringRef Label, const APSInt &Value) = 0;
+  virtual void printBoolean(StringRef Label, bool Value) = 0;
+
+  virtual void printString(StringRef Label, StringRef Value) = 0;
+  virtual void printString(StringRef Label, const std::string &Value) = 0;
+  virtual void printString(StringRef Label, const char *Value) = 0;
+};
+
+class ScopedPrinter : public ScopedPrinterBase {
+public:
+  ScopedPrinter(raw_ostream &OS)
+      : ScopedPrinterBase(SPK_ScopedPrinter), OS(OS), IndentLevel(0) {}
+
+  static bool classof(const ScopedPrinterBase *SPB) {
+    return SPB->getKind() == SPK_ScopedPrinter;
+  }
 
   void flush() { OS.flush(); }
 
   void indent(int Levels = 1) { IndentLevel += Levels; }
 
   void unindent(int Levels = 1) {
     IndentLevel = std::max(0, IndentLevel - Levels);
   }
while (Curr > 0) {
       if (Curr & 1)
         startLine() << "  " << hex(Flag) << "\n";
       Curr >>= 1;
       Flag <<= 1;
     }
     startLine() << "]\n";
   }
 
-  void printNumber(StringRef Label, uint64_t Value) {
+  void printNumber(StringRef Label, uint64_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, uint32_t Value) {
+  void printNumber(StringRef Label, uint32_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, uint16_t Value) {
+  void printNumber(StringRef Label, uint16_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, uint8_t Value) {
+  void printNumber(StringRef Label, uint8_t Value) override {
     startLine() << Label << ": " << unsigned(Value) << "\n";
   }
 
-  void printNumber(StringRef Label, int64_t Value) {
+  void printNumber(StringRef Label, int64_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, int32_t Value) {
+  void printNumber(StringRef Label, int32_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, int16_t Value) {
+  void printNumber(StringRef Label, int16_t Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printNumber(StringRef Label, int8_t Value) {
+  void printNumber(StringRef Label, int8_t Value) override {
     startLine() << Label << ": " << int(Value) << "\n";
   }
 
-  void printNumber(StringRef Label, const APSInt &Value) {
+  void printNumber(StringRef Label, const APSInt &Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printBoolean(StringRef Label, bool Value) {
+  void printBoolean(StringRef Label, bool Value) override {
     startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
   }
 
   template <typename... T> void printVersion(StringRef Label, T... Version) {
     startLine() << Label << ": ";
     printVersionInternal(Version...);
     getOStream() << "\n";
   }
public:
 
   template <typename T>
   void printSymbolOffset(StringRef Label, StringRef Symbol, T Value) {
     startLine() << Label << ": " << Symbol << '+' << hex(Value) << '\n';
   }
 
   void printString(StringRef Value) { startLine() << Value << "\n"; }
 
-  void printString(StringRef Label, StringRef Value) {
+  void printString(StringRef Label, StringRef Value) override {
     startLine() << Label << ": " << Value << "\n";
   }
 
-  void printString(StringRef Label, const std::string &Value) {
+  void printString(StringRef Label, const std::string &Value) override {
     printString(Label, StringRef(Value));
   }
 
-  void printString(StringRef Label, const char* Value) {
+  void printString(StringRef Label, const char *Value) override {
     printString(Label, StringRef(Value));
   }
 
   template <typename T>
   void printNumber(StringRef Label, StringRef Str, T Value) {
     startLine() << Label << ": " << Str << " (" << Value << ")\n";
   }
 

llvm/test/tools/llvm-readobj/ELF/output-style.test

 ## Error for an unknown output style.
 RUN: not llvm-readobj --elf-output-style=unknown 2>&1 | FileCheck %s
 
-CHECK: error: --elf-output-style value should be either 'LLVM' or 'GNU'
+CHECK: error: --elf-output-style value should be either 'LLVM', 'GNU', or 'JSON'

llvm/tools/llvm-readobj/COFFDumper.cpp

struct LoadConfigTables {
   uint64_t GuardEHContTableVA = 0;
   uint64_t GuardEHContTableCount = 0;
 };
 
 class COFFDumper : public ObjDumper {
 public:
   friend class COFFObjectDumpDelegate;
   COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
-      : ObjDumper(Writer, Obj->getFileName()), Obj(Obj), Writer(Writer),
+      : ObjDumper(&Writer, Obj->getFileName()), Obj(Obj), W(Writer),
         Types(100) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printUnwindInfo() override;
 
   void printNeededLibraries() override;
void printRVATable(uint64_t TableVA, uint64_t Count, uint64_t EntrySize,
                      PrintExtraCB PrintExtra = 0);
 
   void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section);
   void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section);
   StringRef getFileNameForFileOffset(uint32_t FileOffset);
   void printFileNameForOffset(StringRef Label, uint32_t FileOffset);
   void printTypeIndex(StringRef FieldName, TypeIndex TI) {
     // Forward to CVTypeDumper for simplicity.
-    codeview::printTypeIndex(Writer, FieldName, TI, Types);
+    codeview::printTypeIndex(W, FieldName, TI, Types);
   }
 
   void printCodeViewSymbolsSubsection(StringRef Subsection,
                                       const SectionRef &Section,
                                       StringRef SectionContents);
 
   void printCodeViewFileChecksums(StringRef Subsection);
 
private:
   DebugChecksumsSubsectionRef CVFileChecksumTable;
 
   DebugStringTableSubsectionRef CVStringTable;
 
   /// Track the compilation CPU type. S_COMPILE3 symbol records typically come
   /// first, but if we don't see one, just assume an X64 CPU type. It is common.
   CPUType CompilationCPUType = CPUType::X64;
 
-  ScopedPrinter &Writer;
+  ScopedPrinter &W;
   BinaryByteStream TypeContents;
   LazyRandomTypeCollection Types;
 };
 
 class COFFObjectDumpDelegate : public SymbolDumpDelegate {
 public:
   COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR,
                          const COFFObjectFile *Obj, StringRef SectionContents)
private:
   StringRef SectionContents;
 };
 
 } // end namespace
 
 namespace llvm {
 
 std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
-                                            ScopedPrinter &Writer) {
-  return std::make_unique<COFFDumper>(&Obj, Writer);
+                                            ScopedPrinterBase *WriterBase) {
+  ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+  return std::make_unique<COFFDumper>(&Obj, *Writer);
 }
 
 } // namespace llvm
 
 // Given a section and an offset into this section the function returns the
 // symbol used for the relocation at the offset.
 std::error_code COFFDumper::resolveSymbol(const coff_section *Section,
                                           uint64_t Offset, SymbolRef &Sym) {

 void COFFDumper::printFileHeaders() {
   time_t TDS = Obj->getTimeDateStamp();
   char FormattedTime[20] = { };
   strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
 
   {
     DictScope D(W, "ImageFileHeader");
     W.printEnum  ("Machine", Obj->getMachine(),
                     makeArrayRef(ImageFileMachineType));
     W.printNumber("SectionCount", Obj->getNumberOfSections());
     W.printHex   ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp());
     W.printHex   ("PointerToSymbolTable", Obj->getPointerToSymbolTable());
     W.printNumber("SymbolCount", Obj->getNumberOfSymbols());
     W.printNumber("StringTableSize", Obj->getStringTableSize());
     W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader());
     W.printFlags ("Characteristics", Obj->getCharacteristics(),
                     makeArrayRef(ImageFileCharacteristics));

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/JSONScopedPrinter.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MSP430AttributeParser.h"
 #include "llvm/Support/MSP430Attributes.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MipsABIFlags.h"
 #include "llvm/Support/RISCVAttributeParser.h"
 #include "llvm/Support/RISCVAttributes.h"
 #include "llvm/Support/ScopedPrinter.h"

 };
 
 template <class ELFT> class MipsGOTParser;
 
 template <typename ELFT> class ELFDumper : public ObjDumper {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
 public:
-  ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer);
+  ELFDumper(const object::ELFObjectFile<ELFT> &ObjF,
+            ScopedPrinterBase *WriterBase);
 
-  void printUnwindInfo() override;
-  void printNeededLibraries() override;
-  void printHashTable() override;
-  void printGnuHashTable() override;
-  void printLoadName() override;
   void printVersionInfo() override;
-  void printArchSpecificInfo() override;
-  void printStackMap() const override;
 
   const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; };
 
   std::string describe(const Elf_Shdr &Sec) const;
 
   unsigned getHashTableEntSize() const {
     // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH
     // sections. This violates the ELF specification.
public:
 
   StringRef getDynamicStringTable() const { return DynamicStringTable; }
 
 protected:
   virtual void printVersionSymbolSection(const Elf_Shdr *Sec) = 0;
   virtual void printVersionDefinitionSection(const Elf_Shdr *Sec) = 0;
   virtual void printVersionDependencySection(const Elf_Shdr *Sec) = 0;
 
+  void printUnwindInfoHelper(ScopedPrinter &W);
+  void printNeededLibrariesHelper(ScopedPrinter &W);
+  void printHashTableHelper(ScopedPrinter &W);
+  void printGnuHashTableHelper(ScopedPrinter &W);
+  void printLoadNameHelper(ScopedPrinter &W);
+  void printArchSpecificInfoHelper(ScopedPrinter &W);
+  void printStackMapHelper(ScopedPrinter &W) const;
+
   void
   printDependentLibsHelper(function_ref<void(const Elf_Shdr &)> OnSectionStart,
                            function_ref<void(StringRef, uint64_t)> OnLibEntry);
 
   virtual void printRelRelaReloc(const Relocation<ELFT> &R,
                                  const RelSymbol<ELFT> &RelSym) = 0;
   virtual void printRelrReloc(const Elf_Relr &R) = 0;
   virtual void printDynamicRelocHeader(unsigned Type, StringRef Name,
if (Offset + Size < Offset || Offset + Size > Obj.getBufSize())
       return createError("offset (0x" + Twine::utohexstr(Offset) +
                          ") + size (0x" + Twine::utohexstr(Size) +
                          ") is greater than the file size (0x" +
                          Twine::utohexstr(Obj.getBufSize()) + ")");
     return DynRegionInfo(ObjF, *this, Obj.base() + Offset, Size, EntSize);
   }
 
   void printAttributes(unsigned, std::unique_ptr<ELFAttributeParser>,
-                       support::endianness);
-  void printMipsReginfo();
-  void printMipsOptions();
+                       support::endianness, ScopedPrinter &W);
+  void printMipsReginfo(ScopedPrinter &W);
+  void printMipsOptions(ScopedPrinter &W);
 
   std::pair<const Elf_Phdr *, const Elf_Shdr *> findDynamic();
   void loadDynamicTable();
   void parseDynamicTable();
 
   Expected<StringRef> getSymbolVersion(const Elf_Sym &Sym,
                                        bool &IsDefault) const;
   Expected<SmallVector<Optional<VersionEntry>, 0> *> getVersionMap() const;
void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
   printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed);
   for (const Elf_Sym &Sym : Syms)
     printSymbol(Sym, &Sym - Syms.begin(), ShndxTable, StrTable, IsDynamic,
                 NonVisibilityBitsUsed);
 }
 
 template <typename ELFT> class GNUELFDumper : public ELFDumper<ELFT> {
   formatted_raw_ostream &OS;
+  ScopedPrinter &W;
 
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
   GNUELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
-      : ELFDumper<ELFT>(ObjF, Writer),
-        OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())) {
+      : ELFDumper<ELFT>(ObjF, &Writer),
+        OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())),
+        W(Writer) {
     assert(&this->W.getOStream() == &llvm::fouts());
   }
 
   void printFileHeaders() override;
   void printGroupSections() override;
   void printRelocations() override;
   void printSectionHeaders() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
public:
   void printHashHistograms() override;
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
 
+  void printUnwindInfo() override;
+  void printNeededLibraries() override;
+  void printHashTable() override;
+  void printGnuHashTable() override;
+  void printLoadName() override;
+  void printArchSpecificInfo() override;
+  void printStackMap() const override;
+
 private:
   void printHashHistogram(const Elf_Hash &HashTable);
   void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable);
   void printHashTableSymbols(const Elf_Hash &HashTable);
   void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable);
 
   struct Field {
     std::string Str;
private:
   void printMipsABIFlags() override;
 };
 
 template <typename ELFT> class LLVMELFDumper : public ELFDumper<ELFT> {
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
   LLVMELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
-      : ELFDumper<ELFT>(ObjF, Writer), W(Writer) {}
+      : ELFDumper<ELFT>(ObjF, &Writer), W(Writer) {}
 
   void printFileHeaders() override;
   void printGroupSections() override;
   void printRelocations() override;
   void printSectionHeaders() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printDependentLibs() override;
   void printDynamicTable() override;
   void printDynamicRelocations() override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const Elf_Shdr *Sec) override;
   void printHashHistograms() override;
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
 
+  void printUnwindInfo() override;
+  void printNeededLibraries() override;
+  void printHashTable() override;
+  void printGnuHashTable() override;
+  void printLoadName() override;
+  void printArchSpecificInfo() override;
+  void printStackMap() const override;
+
 private:
   void printRelrReloc(const Elf_Relr &R) override;
   void printRelRelaReloc(const Relocation<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym) override;
 
   void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex,
                           DataRegion<Elf_Word> ShndxTable) const;
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    DataRegion<Elf_Word> ShndxTable,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) const override;
   void printProgramHeaders() override;
   void printSectionMapping() override {}
   void printStackSizeEntry(uint64_t Size,
                            ArrayRef<std::string> FuncNames) override;
 
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags() override;
 
   ScopedPrinter &W;
 };
 
+template <typename ELFT> class JSONELFDumper : public ELFDumper<ELFT> {
+  JSONScopedPrinter &W;
+
+public:
+  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
+
+  JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF,
+                JSONScopedPrinter &JSONWriter)
+      : ELFDumper<ELFT>(ObjF, &JSONWriter), W(JSONWriter) {}
+
+  void printFileHeaders() override;
+  void printGroupSections() override;
+  void printRelocations() override;
+  void printSectionHeaders() override;
+  void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
+  void printHashSymbols() override;
+  void printSectionDetails() override;
+  void printDependentLibs() override;
+  void printDynamicTable() override;
+  void printDynamicRelocations() override;
+  void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
+                          bool NonVisibilityBitsUsed) const override;
+  void printProgramHeaders(bool PrintProgramHeaders,
+                           cl::boolOrDefault PrintSectionMapping) override;
+  void printVersionSymbolSection(const Elf_Shdr *Sec) override;
+  void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
+  void printVersionDependencySection(const Elf_Shdr *Sec) override;
+  void printHashHistograms() override;
+  void printCGProfile() override;
+  void printBBAddrMaps() override;
+  void printAddrsig() override;
+  void printNotes() override;
+  void printELFLinkerOptions() override;
+  void printStackSizes() override;
+
+  void printUnwindInfo() override;
+  void printNeededLibraries() override;
+  void printHashTable() override;
+  void printGnuHashTable() override;
+  void printLoadName() override;
+  void printArchSpecificInfo() override;
+  void printStackMap() const override;
+
+private:
+  void printRelrReloc(const Elf_Relr &R) override;
+  void printRelRelaReloc(const Relocation<ELFT> &R,
+                         const RelSymbol<ELFT> &RelSym) override;
+  void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
+                   DataRegion<Elf_Word> ShndxTable,
+                   Optional<StringRef> StrTable, bool IsDynamic,
+                   bool NonVisibilityBitsUsed) const override;
+  void printDynamicRelocHeader(unsigned Type, StringRef Name,
+                               const DynRegionInfo &Reg) override;
+
+  void printProgramHeaders() override;
+  void printSectionMapping() override;
+
+  void printStackSizeEntry(uint64_t Size,
+                           ArrayRef<std::string> FuncNames) override;
+  void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
+  void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
+  void printMipsABIFlags() override;
+};
+
 } // end anonymous namespace
 
 namespace llvm {
 
 template <class ELFT>
 static std::unique_ptr<ObjDumper>
-createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) {
+createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinterBase *WriterBase) {
+  if (opts::Output == opts::JSON) {
+    JSONScopedPrinter *JSONWriter = cast<JSONScopedPrinter>(WriterBase);
+    return std::make_unique<JSONELFDumper<ELFT>>(Obj, *JSONWriter);
+  }
+  ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
   if (opts::Output == opts::GNU)
-    return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer);
-  return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer);
+    return std::make_unique<GNUELFDumper<ELFT>>(Obj, *Writer);
+  return std::make_unique<LLVMELFDumper<ELFT>>(Obj, *Writer);
 }
 
 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
-                                           ScopedPrinter &Writer) {
+                                           ScopedPrinterBase *WriterBase) {
   // Little-endian 32-bit
   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj))
-    return createELFDumper(*ELFObj, Writer);
+    return createELFDumper(*ELFObj, WriterBase);
 
   // Big-endian 32-bit
   if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj))
-    return createELFDumper(*ELFObj, Writer);
+    return createELFDumper(*ELFObj, WriterBase);
 
   // Little-endian 64-bit
   if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj))
-    return createELFDumper(*ELFObj, Writer);
+    return createELFDumper(*ELFObj, WriterBase);
 
   // Big-endian 64-bit
-  return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer);
+  return createELFDumper(*cast<ELF64BEObjectFile>(&Obj), WriterBase);
 }
 
 } // end namespace llvm
 
 template <class ELFT>
 Expected<SmallVector<Optional<VersionEntry>, 0> *>
 ELFDumper<ELFT>::getVersionMap() const {
   // If the VersionMap has already been loaded or if there is no dynamic symtab
if (IsPhdrTableValid) {
     DynamicTable = FromSec;
   }
 
   parseDynamicTable();
 }
 
 template <typename ELFT>
 ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> &O,
-                           ScopedPrinter &Writer)
-    : ObjDumper(Writer, O.getFileName()), ObjF(O), Obj(O.getELFFile()),
+                           ScopedPrinterBase *WriterBase)
+    : ObjDumper(WriterBase, O.getFileName()), ObjF(O), Obj(O.getELFFile()),
       FileName(O.getFileName()), DynRelRegion(O, *this),
       DynRelaRegion(O, *this), DynRelrRegion(O, *this),
       DynPLTRelRegion(O, *this), DynSymTabShndxRegion(O, *this),
       DynamicTable(O, *this) {
   if (!O.IsContentValid())
     return;
 
   typename ELFT::ShdrRange Sections = cantFail(Obj.sections());
if (DynamicStringTable.back() != '\0')
     return WarnAndReturn(": unable to read the string at 0x" +
                              Twine::utohexstr(Offset + Value) +
                              ": the string table is not null-terminated",
                          Offset);
 
   return DynamicStringTable.data() + Value;
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printUnwindInfo() {
+template <class ELFT>
+void ELFDumper<ELFT>::printUnwindInfoHelper(ScopedPrinter &W) {
   DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF);
   Ctx.printUnwindInformation();
 }
 
 // The namespace is needed to fix the compilation with GCC older than 7.0+.
 namespace {
-template <> void ELFDumper<ELF32LE>::printUnwindInfo() {
+template <> void ELFDumper<ELF32LE>::printUnwindInfoHelper(ScopedPrinter &W) {
   if (Obj.getHeader().e_machine == EM_ARM) {
     ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF.getFileName(),
                                             DotSymtabSec);
     Ctx.PrintUnwindInformation();
   }
   DwarfCFIEH::PrinterContext<ELF32LE> Ctx(W, ObjF);
   Ctx.printUnwindInformation();
 }
 } // namespace
 
-template <class ELFT> void ELFDumper<ELFT>::printNeededLibraries() {
+template <class ELFT>
+void ELFDumper<ELFT>::printNeededLibrariesHelper(ScopedPrinter &W) {
   ListScope D(W, "NeededLibraries");
 
   std::vector<StringRef> Libs;
   for (const auto &Entry : dynamic_table())
     if (Entry.d_tag == ELF::DT_NEEDED)
       Libs.push_back(getDynamicString(Entry.d_un.d_val));
 
   llvm::sort(Libs);
if (TableOffset + 16 + (uint64_t)GnuHashTable->nbuckets * 4 +
       Obj.getBufSize())
     return createError("unable to dump the SHT_GNU_HASH "
                        "section at 0x" +
                        Twine::utohexstr(TableOffset) +
                        ": it goes past the end of the file");
   return Error::success();
 }
 
-template <typename ELFT> void ELFDumper<ELFT>::printHashTable() {
+template <typename ELFT>
+void ELFDumper<ELFT>::printHashTableHelper(ScopedPrinter &W) {
   DictScope D(W, "HashTable");
   if (!HashTable)
     return;
 
   bool IsHeaderValid;
   Error Err = checkHashTable(*this, HashTable, &IsHeaderValid);
   if (IsHeaderValid) {
     W.printNumber("Num Buckets", HashTable->nbucket);
return createError(
         ") is greater than or equal to the number of dynamic symbols (" +
         Twine(NumSyms) + ")");
   // There is no way to represent an array of (dynamic symbols count - symndx)
   // length.
   return ArrayRef<typename ELFT::Word>();
 }
 
 template <typename ELFT>
-void ELFDumper<ELFT>::printGnuHashTable() {
+void ELFDumper<ELFT>::printGnuHashTableHelper(ScopedPrinter &W) {
   DictScope D(W, "GnuHashTable");
   if (!GnuHashTable)
     return;
 
   bool IsHeaderValid;
   Error Err = checkGNUHashTable<ELFT>(Obj, GnuHashTable, &IsHeaderValid);
   if (IsHeaderValid) {
     W.printNumber("Num Buckets", GnuHashTable->nbuckets);
reportUniqueWarning("unable to dump 'Values' for the SHT_GNU_HASH "
                         "section: " +
                         toString(Chains.takeError()));
     return;
   }
 
   W.printHexList("Values", *Chains);
 }
 
-template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
+template <typename ELFT>
+void ELFDumper<ELFT>::printLoadNameHelper(ScopedPrinter &W) {
   StringRef SOName = "<Not found>";
   if (SONameOffset)
     SOName = getDynamicString(*SONameOffset);
   W.printString("LoadName", SOName);
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() {
+template <class ELFT>
+void ELFDumper<ELFT>::printArchSpecificInfoHelper(ScopedPrinter &W) {
   switch (Obj.getHeader().e_machine) {
   case EM_ARM:
     if (Obj.isLE())
       printAttributes(ELF::SHT_ARM_ATTRIBUTES,
-                      std::make_unique<ARMAttributeParser>(&W),
-                      support::little);
+                      std::make_unique<ARMAttributeParser>(&W), support::little,
+                      W);
     else
       reportUniqueWarning("attribute printing not implemented for big-endian "
                           "ARM objects");
     break;
   case EM_RISCV:
     if (Obj.isLE())
       printAttributes(ELF::SHT_RISCV_ATTRIBUTES,
                       std::make_unique<RISCVAttributeParser>(&W),
-                      support::little);
+                      support::little, W);
     else
       reportUniqueWarning("attribute printing not implemented for big-endian "
                           "RISC-V objects");
     break;
   case EM_MSP430:
     printAttributes(ELF::SHT_MSP430_ATTRIBUTES,
                     std::make_unique<MSP430AttributeParser>(&W),
-                    support::little);
+                    support::little, W);
     break;
   case EM_MIPS: {
     printMipsABIFlags();
-    printMipsOptions();
-    printMipsReginfo();
+    printMipsOptions(W);
+    printMipsReginfo(W);
     MipsGOTParser<ELFT> Parser(*this);
     if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols()))
       reportUniqueWarning(std::move(E));
     else if (!Parser.isGotEmpty())
       printMipsGOT(Parser);
 
     if (Error E = Parser.findPLT(dynamic_table()))
       reportUniqueWarning(std::move(E));
     else if (!Parser.isPltEmpty())
       printMipsPLT(Parser);
     break;
   }
   default:
     break;
   }
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printAttributes(
     unsigned AttrShType, std::unique_ptr<ELFAttributeParser> AttrParser,
-    support::endianness Endianness) {
+    support::endianness Endianness, ScopedPrinter &W) {
   assert((AttrShType != ELF::SHT_NULL) && AttrParser &&
          "Incomplete ELF attribute implementation");
   DictScope BA(W, "BuildAttributes");
   for (const Elf_Shdr &Sec : cantFail(Obj.sections())) {
     if (Sec.sh_type != AttrShType)
       continue;
 
     ArrayRef<uint8_t> Contents;
static void printMipsReginfoData(ScopedPrinter &W,
   W.printHex("GP", Reginfo.ri_gp_value);
   W.printHex("General Mask", Reginfo.ri_gprmask);
   W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]);
   W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]);
   W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]);
   W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]);
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
+template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo(ScopedPrinter &W) {
   const Elf_Shdr *RegInfoSec = findSectionByName(".reginfo");
   if (!RegInfoSec) {
     W.startLine() << "There is no .reginfo section in the file.\n";
     return;
   }
 
   Expected<ArrayRef<uint8_t>> ContentsOrErr =
       Obj.getSectionContents(*RegInfoSec);
if (Size < ExpectedSize)
           Twine(getElfMipsOptionsOdkType(O->kind)) +
           " has an invalid size (0x" + Twine::utohexstr(Size) +
           "), the expected size is 0x" + Twine::utohexstr(ExpectedSize));
 
   SecData = SecData.drop_front(Size);
   return O;
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
+template <class ELFT> void ELFDumper<ELFT>::printMipsOptions(ScopedPrinter &W) {
   const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options");
   if (!MipsOpts) {
     W.startLine() << "There is no .MIPS.options section in the file.\n";
     return;
   }
 
   DictScope GS(W, "MIPS Options");
 
while (!Data.empty()) {
     DictScope GS(W, Type);
     if (Kind == ODK_REGINFO)
       printMipsReginfoData(W, (*OptsOrErr)->getRegInfo());
     else
       llvm_unreachable("unexpected .MIPS.options section descriptor kind");
   }
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
+template <class ELFT>
+void ELFDumper<ELFT>::printStackMapHelper(ScopedPrinter &W) const {
   const Elf_Shdr *StackMapSection = findSectionByName(".llvm_stackmaps");
   if (!StackMapSection)
     return;
 
   auto Warn = [&](Error &&E) {
     this->reportUniqueWarning("unable to read the stack map from " +
                               describe(*StackMapSection) + ": " +
                               toString(std::move(E)));
void GNUELFDumper<ELFT>::printStackSizes() {
   // For non-relocatable objects, look directly for sections whose name starts
   // with .stack_sizes and process the contents.
   if (this->Obj.getHeader().e_type == ELF::ET_REL)
     this->printRelocatableStackSizes(PrintHeader);
   else
     this->printNonRelocatableStackSizes(PrintHeader);
 }
 
+template <class ELFT> void GNUELFDumper<ELFT>::printUnwindInfo() {
+  ELFDumper<ELFT>::printUnwindInfoHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printNeededLibraries() {
+  ELFDumper<ELFT>::printNeededLibrariesHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printHashTable() {
+  ELFDumper<ELFT>::printHashTableHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printGnuHashTable() {
+  ELFDumper<ELFT>::printGnuHashTableHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printLoadName() {
+  ELFDumper<ELFT>::printLoadNameHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printArchSpecificInfo() {
+  ELFDumper<ELFT>::printArchSpecificInfoHelper(W);
+}
+
+template <class ELFT> void GNUELFDumper<ELFT>::printStackMap() const {
+  ELFDumper<ELFT>::printStackMapHelper(W);
+}
+
 template <class ELFT>
 void GNUELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
   size_t Bias = ELFT::Is64Bits ? 8 : 0;
   auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) {
     OS.PadToColumn(2);
     OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias);
     OS.PadToColumn(11 + Bias);
     OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)";

 
 template <class ELFT> void LLVMELFDumper<ELFT>::printDependentLibs() {
   ListScope L(W, "DependentLibs");
   this->printDependentLibsHelper(
       [](const Elf_Shdr &) {},
       [this](StringRef Lib, uint64_t) { W.printString(Lib); });
 }
 
+template <class ELFT> void LLVMELFDumper<ELFT>::printUnwindInfo() {
+  ELFDumper<ELFT>::printUnwindInfoHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printNeededLibraries() {
+  ELFDumper<ELFT>::printNeededLibrariesHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printHashTable() {
+  ELFDumper<ELFT>::printHashTableHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printGnuHashTable() {
+  ELFDumper<ELFT>::printGnuHashTableHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printLoadName() {
+  ELFDumper<ELFT>::printLoadNameHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printArchSpecificInfo() {
+  ELFDumper<ELFT>::printArchSpecificInfoHelper(W);
+}
+
+template <class ELFT> void LLVMELFDumper<ELFT>::printStackMap() const {
+  ELFDumper<ELFT>::printStackMapHelper(W);
+}
+
 template <class ELFT> void LLVMELFDumper<ELFT>::printStackSizes() {
   ListScope L(W, "StackSizes");
   if (this->Obj.getHeader().e_type == ELF::ET_REL)
     this->printRelocatableStackSizes([]() {});
   else
     this->printNonRelocatableStackSizes([]() {});
 }
 
template <class ELFT> void LLVMELFDumper<ELFT>::printMipsABIFlags() {
   W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
   W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
   W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
   W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
   W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
   W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
   W.printHex("Flags 2", Flags->flags2);
 }
+
+template <class ELFT> void JSONELFDumper<ELFT>::printFileHeaders() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printGroupSections() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printRelocations() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printSectionHeaders() {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printSymbols(bool PrintSymbols,
+                                       bool PrintDynamicSymbols) {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printHashSymbols() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printSectionDetails() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printDependentLibs() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printDynamicTable() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printDynamicRelocations() {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printSymtabMessage(const Elf_Shdr *Symtab,
+                                             size_t Offset,
+                                             bool NonVisibilityBitsUsed) const {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printProgramHeaders(
+    bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printHashHistograms() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printCGProfile() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printBBAddrMaps() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printAddrsig() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printNotes() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printELFLinkerOptions() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printStackSizes() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printUnwindInfo() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printNeededLibraries() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printHashTable() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printGnuHashTable() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printLoadName() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printArchSpecificInfo() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printStackMap() const {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printMipsABIFlags() {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printRelrReloc(const Elf_Relr &R) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
+                                            const RelSymbol<ELFT> &RelSym) {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
+                                      DataRegion<Elf_Word> ShndxTable,
+                                      Optional<StringRef> StrTable,
+                                      bool IsDynamic,
+                                      bool NonVisibilityBitsUsed) const {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printDynamicRelocHeader(unsigned Type, StringRef Name,
+                                                  const DynRegionInfo &Reg) {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printProgramHeaders() {
+  // TODO: Implement
+}
+
+template <class ELFT> void JSONELFDumper<ELFT>::printSectionMapping() {
+  // TODO: Implement
+}
+
+template <class ELFT>
+void JSONELFDumper<ELFT>::printStackSizeEntry(uint64_t Size,
+                                              ArrayRef<std::string> FuncNames) {
+  // TODO: Implement
+}

llvm/tools/llvm-readobj/MachODumper.cpp

 using namespace llvm;
 using namespace object;
 
 namespace {
 
 class MachODumper : public ObjDumper {
 public:
   MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer)
-      : ObjDumper(Writer, Obj->getFileName()), Obj(Obj) {}
+      : ObjDumper(&Writer, Obj->getFileName()), Obj(Obj), W(Writer) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   void printNeededLibraries() override;
private:
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
   void printSectionHeaders(const MachOObjectFile *Obj);
 
   const MachOObjectFile *Obj;
+  ScopedPrinter &W;
 };
 
 } // namespace
 
 
 namespace llvm {
 
 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
-                                             ScopedPrinter &Writer) {
-  return std::make_unique<MachODumper>(&Obj, Writer);
+                                             ScopedPrinterBase *WriterBase) {
+  ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+  return std::make_unique<MachODumper>(&Obj, *Writer);
 }
 
 } // namespace llvm
 
 const EnumEntry<uint32_t> MachOMagics[] = {
   { "Magic",      MachO::MH_MAGIC    },
   { "Cigam",      MachO::MH_CIGAM    },
   { "Magic64",    MachO::MH_MAGIC_64 },

llvm/tools/llvm-readobj/ObjDumper.h

 class XCOFFObjectFile;
 class ELFObjectFileBase;
 }
 namespace codeview {
 class GlobalTypeTableBuilder;
 class MergingTypeTableBuilder;
 } // namespace codeview
 
+class ScopedPrinterBase;
 class ScopedPrinter;
+class JSONScopedPrinter;
 
 class ObjDumper {
 public:
-  ObjDumper(ScopedPrinter &Writer, StringRef ObjName);
+  ObjDumper(ScopedPrinterBase *WriterBase, StringRef ObjName);
   virtual ~ObjDumper();
 
   virtual bool canDumpContent() { return true; }
 
   virtual void printFileHeaders() = 0;
   virtual void printSectionHeaders() = 0;
   virtual void printRelocations() = 0;
   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
public:
   void printSectionsAsHex(const object::ObjectFile &Obj,
                           ArrayRef<std::string> Sections);
 
   std::function<Error(const Twine &Msg)> WarningHandler;
   void reportUniqueWarning(Error Err) const;
   void reportUniqueWarning(const Twine &Msg) const;
 
 protected:
-  ScopedPrinter &W;
+  ScopedPrinterBase *WriterBase;
 
 private:
   virtual void printSymbols() {}
   virtual void printDynamicSymbols() {}
   virtual void printProgramHeaders() {}
   virtual void printSectionMapping() {}
 
+  void printSectionsAsString(const object::ObjectFile &Obj,
+                             ArrayRef<std::string> Sections, ScopedPrinter &W);
+  void printSectionsAsString(const object::ObjectFile &Obj,
+                             ArrayRef<std::string> Sections,
+                             JSONScopedPrinter &W);
+  void printSectionsAsHex(const object::ObjectFile &Obj,
+                          ArrayRef<std::string> Sections, ScopedPrinter &W);
+  void printSectionsAsHex(const object::ObjectFile &Obj,
+                          ArrayRef<std::string> Sections, JSONScopedPrinter &W);
+
   std::unordered_set<std::string> Warnings;
 };
 
 std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
-                                            ScopedPrinter &Writer);
+                                            ScopedPrinterBase *WriterBase);
 
 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
-                                           ScopedPrinter &Writer);
+                                           ScopedPrinterBase *WriterBase);
 
 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
-                                             ScopedPrinter &Writer);
+                                             ScopedPrinterBase *WriterBase);
 
 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
-                                            ScopedPrinter &Writer);
+                                            ScopedPrinterBase *WriterBase);
 
 std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
-                                             ScopedPrinter &Writer);
+                                             ScopedPrinterBase *WriterBase);
 
 void dumpCOFFImportFile(const object::COFFImportFile *File,
                         ScopedPrinter &Writer);
 
 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                              ArrayRef<ArrayRef<uint8_t>> IpiRecords,
                              ArrayRef<ArrayRef<uint8_t>> TpiRecords);
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/ObjDumper.cpp

 //===-- ObjDumper.cpp - Base dumper class -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements ObjDumper.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ObjDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSONScopedPrinter.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace llvm {
 
 static inline Error createError(const Twine &Msg) {
   return createStringError(object::object_error::parse_failed, Msg);
 }
 
-ObjDumper::ObjDumper(ScopedPrinter &Writer, StringRef ObjName) : W(Writer) {
+ObjDumper::ObjDumper(ScopedPrinterBase *WriterBase, StringRef ObjName)
+    : WriterBase(WriterBase) {
   // Dumper reports all non-critical errors as warnings.
   // It does not print the same warning more than once.
   WarningHandler = [=](const Twine &Msg) {
     if (Warnings.insert(Msg.str()).second)
       reportWarning(createError(Msg), ObjName);
     return Error::success();
   };
 }
void ObjDumper::printAsStringList(StringRef StringContent,
 
   while (CurrentWord <= StrEnd) {
     size_t WordSize = strnlen(reinterpret_cast<const char *>(CurrentWord),
                               StrEnd - CurrentWord);
     if (!WordSize) {
       CurrentWord++;
       continue;
     }
-    W.startLine() << format("[%6tx] ", CurrentWord - StrContent);
-    printAsPrintable(W.startLine(), CurrentWord, WordSize);
-    W.startLine() << '\n';
+    if (JSONScopedPrinter *W = dyn_cast<JSONScopedPrinter>(WriterBase)) {
+      // TODO: implement for JSON printer
+    } else if (ScopedPrinter *W = dyn_cast<ScopedPrinter>(WriterBase)) {
+      W->startLine() << format("[%6tx] ", CurrentWord - StrContent);
+      printAsPrintable(W->startLine(), CurrentWord, WordSize);
+      W->startLine() << '\n';
+    }
     CurrentWord += WordSize + 1;
   }
 }
 
 static std::vector<object::SectionRef>
 getSectionRefsByNameOrIndex(const object::ObjectFile &Obj,
                             ArrayRef<std::string> Sections) {
   std::vector<object::SectionRef> Ret;
for (std::pair<unsigned, bool> S : SecIndices)
     if (!S.second)
       reportWarning(
           createError(formatv("could not find section {0}", S.first).str()),
           Obj.getFileName());
 
   return Ret;
 }
 
 void ObjDumper::printSectionsAsString(const object::ObjectFile &Obj,
                                       ArrayRef<std::string> Sections) {
+  if (ScopedPrinter *W = dyn_cast<ScopedPrinter>(WriterBase)) {
+    printSectionsAsString(Obj, Sections, *W);
+  } else if (JSONScopedPrinter *W = dyn_cast<JSONScopedPrinter>(WriterBase)) {
+    printSectionsAsString(Obj, Sections, *W);
+  }
+}
+
+void ObjDumper::printSectionsAsHex(const object::ObjectFile &Obj,
+                                   ArrayRef<std::string> Sections) {
+  if (ScopedPrinter *W = dyn_cast<ScopedPrinter>(WriterBase)) {
+    printSectionsAsHex(Obj, Sections, *W);
+  } else if (JSONScopedPrinter *W = dyn_cast<JSONScopedPrinter>(WriterBase)) {
+    printSectionsAsHex(Obj, Sections, *W);
+  }
+}
+
+void ObjDumper::printSectionsAsString(const object::ObjectFile &Obj,
+                                      ArrayRef<std::string> Sections,
+                                      ScopedPrinter &W) {
   bool First = true;
   for (object::SectionRef Section :
        getSectionRefsByNameOrIndex(Obj, Sections)) {
     StringRef SectionName = unwrapOrError(Obj.getFileName(), Section.getName());
 
     if (!First)
       W.startLine() << '\n';
     First = false;
     W.startLine() << "String dump of section '" << SectionName << "':\n";
 
     StringRef SectionContent =
         unwrapOrError(Obj.getFileName(), Section.getContents());
     printAsStringList(SectionContent);
   }
 }
 
+void ObjDumper::printSectionsAsString(const object::ObjectFile &Obj,
+                                      ArrayRef<std::string> Sections,
+                                      JSONScopedPrinter &W) {
+  // TODO: Implement
+}
+
 void ObjDumper::printSectionsAsHex(const object::ObjectFile &Obj,
-                                   ArrayRef<std::string> Sections) {
+                                   ArrayRef<std::string> Sections,
+                                   ScopedPrinter &W) {
   bool First = true;
   for (object::SectionRef Section :
        getSectionRefsByNameOrIndex(Obj, Sections)) {
     StringRef SectionName = unwrapOrError(Obj.getFileName(), Section.getName());
 
     if (!First)
       W.startLine() << '\n';
     First = false;
for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
                               ? static_cast<char>(TmpSecPtr[i])
                               : '.');
 
       W.startLine() << '\n';
     }
   }
 }
 
+void ObjDumper::printSectionsAsHex(const object::ObjectFile &Obj,
+                                   ArrayRef<std::string> Sections,
+                                   JSONScopedPrinter &W) {
+  // TODO: Implement
+}
+
 } // namespace llvm

llvm/tools/llvm-readobj/WasmDumper.cpp

#define ENUM_ENTRY(X)                                                          \
   ENUM_ENTRY(EXPLICIT_NAME),
   ENUM_ENTRY(NO_STRIP),
 #undef ENUM_ENTRY
 };
 
 class WasmDumper : public ObjDumper {
 public:
   WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
-      : ObjDumper(Writer, Obj->getFileName()), Obj(Obj) {}
+      : ObjDumper(&Writer, Obj->getFileName()), Obj(Obj), W(Writer) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printUnwindInfo() override { llvm_unreachable("unimplemented"); }
   void printStackMap() const override { llvm_unreachable("unimplemented"); }
 
 protected:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc);
 
 private:
   void printSymbols() override;
   void printDynamicSymbols() override { llvm_unreachable("unimplemented"); }
 
   const WasmObjectFile *Obj;
+  ScopedPrinter &W;
 };
 
 void WasmDumper::printFileHeaders() {
   W.printHex("Version", Obj->getHeader().Version);
 }
 
 void WasmDumper::printRelocation(const SectionRef &Section,
                                  const RelocationRef &Reloc) {
void WasmDumper::printSymbol(const SymbolRef &Sym) {
   }
 }
 
 } // namespace
 
 namespace llvm {
 
 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
-                                            ScopedPrinter &Writer) {
-  return std::make_unique<WasmDumper>(&Obj, Writer);
+                                            ScopedPrinterBase *WriterBase) {
+  ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+  return std::make_unique<WasmDumper>(&Obj, *Writer);
 }
 
 } // namespace llvm

llvm/tools/llvm-readobj/XCOFFDumper.cpp

 using namespace object;
 
 namespace {
 
 class XCOFFDumper : public ObjDumper {
 
 public:
   XCOFFDumper(const XCOFFObjectFile &Obj, ScopedPrinter &Writer)
-      : ObjDumper(Writer, Obj.getFileName()), Obj(Obj) {}
+      : ObjDumper(&Writer, Obj.getFileName()), Obj(Obj), W(Writer) {}
 
   void printFileHeaders() override;
   void printAuxiliaryHeader() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
private:
   void printCsectAuxEnt(XCOFFCsectAuxRef AuxEntRef);
   void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
   void printSymbol(const SymbolRef &);
   template <typename Shdr, typename RelTy>
   void printRelocations(ArrayRef<Shdr> Sections);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader32 *AuxHeader);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader64 *AuxHeader);
   const XCOFFObjectFile &Obj;
+  ScopedPrinter &W;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
 
if (opts::SectionSymbols)
     report_fatal_error("Dumping symbols is unimplemented");
 
   if (opts::SectionData)
     report_fatal_error("Dumping section data is unimplemented");
 }
 
 namespace llvm {
 std::unique_ptr<ObjDumper>
-createXCOFFDumper(const object::XCOFFObjectFile &XObj, ScopedPrinter &Writer) {
-  return std::make_unique<XCOFFDumper>(XObj, Writer);
+createXCOFFDumper(const object::XCOFFObjectFile &XObj,
+                  ScopedPrinterBase *WriterBase) {
+  ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+  return std::make_unique<XCOFFDumper>(XObj, *Writer);
 }
 } // namespace llvm

llvm/tools/llvm-readobj/llvm-readobj.h

 namespace opts {
 extern bool SectionRelocations;
 extern bool SectionSymbols;
 extern bool SectionData;
 extern bool ExpandRelocs;
 extern bool RawRelr;
 extern bool CodeViewSubsectionBytes;
 extern bool Demangle;
-enum OutputStyleTy { LLVM, GNU };
+enum OutputStyleTy { LLVM, GNU, JSON };
 extern OutputStyleTy Output;
 } // namespace opts
 
 #define LLVM_READOBJ_ENUM_ENT(ns, enum) \
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
   { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
 
 #endif

llvm/tools/llvm-readobj/llvm-readobj.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/JSONScopedPrinter.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 namespace {
static void parseOptions(const opt::InputArgList &Args) {
   opts::DynamicTable = Args.hasArg(OPT_dynamic_table);
   opts::ELFLinkerOptions = Args.hasArg(OPT_elf_linker_options);
   if (Arg *A = Args.getLastArg(OPT_elf_output_style_EQ)) {
     StringRef V(A->getValue());
     if (V == "LLVM")
       opts::Output = opts::OutputStyleTy::LLVM;
     else if (V == "GNU")
       opts::Output = opts::OutputStyleTy::GNU;
+    else if (V == "JSON")
+      opts::Output = opts::OutputStyleTy::JSON;
     else
-      error("--elf-output-style value should be either 'LLVM' or 'GNU'");
+      error(
+          "--elf-output-style value should be either 'LLVM', 'GNU', or 'JSON'");
   }
   opts::GnuHashTable = Args.hasArg(OPT_gnu_hash_table);
   opts::HashSymbols = Args.hasArg(OPT_hash_symbols);
   opts::HashTable = Args.hasArg(OPT_hash_table);
   opts::HashHistogram = Args.hasArg(OPT_histogram);
   opts::NeededLibraries = Args.hasArg(OPT_needed_libs);
   opts::Notes = Args.hasArg(OPT_notes);
   opts::ProgramHeaders = Args.hasArg(OPT_program_headers);
struct ReadObjTypeTableBuilder {
   llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable;
   std::vector<OwningBinary<Binary>> Binaries;
 };
 } // namespace
 static ReadObjTypeTableBuilder CVTypes;
 
 /// Creates an format-specific object file dumper.
 static Expected<std::unique_ptr<ObjDumper>>
-createDumper(const ObjectFile &Obj, ScopedPrinter &Writer) {
+createDumper(const ObjectFile &Obj, ScopedPrinterBase *WriterBase) {
+
   if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj))
-    return createCOFFDumper(*COFFObj, Writer);
+    return createCOFFDumper(*COFFObj, WriterBase);
 
   if (const ELFObjectFileBase *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj))
-    return createELFDumper(*ELFObj, Writer);
+    return createELFDumper(*ELFObj, WriterBase);
 
   if (const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(&Obj))
-    return createMachODumper(*MachOObj, Writer);
+    return createMachODumper(*MachOObj, WriterBase);
 
   if (const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(&Obj))
-    return createWasmDumper(*WasmObj, Writer);
+    return createWasmDumper(*WasmObj, WriterBase);
 
   if (const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(&Obj))
-    return createXCOFFDumper(*XObj, Writer);
+    return createXCOFFDumper(*XObj, WriterBase);
 
   return createStringError(errc::invalid_argument,
                            "unsupported object file format");
 }
 
 /// Dumps the specified object file.
-static void dumpObject(ObjectFile &Obj, ScopedPrinter &Writer,
+static void dumpObject(ObjectFile &Obj, ScopedPrinterBase *WriterBase,
                        const Archive *A = nullptr) {
   std::string FileStr =
       A ? Twine(A->getFileName() + "(" + Obj.getFileName() + ")").str()
         : Obj.getFileName().str();
 
   std::string ContentErrString;
   if (Error ContentErr = Obj.initContent())
     ContentErrString = "unable to continue dumping, the file is corrupt: " +
                        toString(std::move(ContentErr));
 
   ObjDumper *Dumper;
-  Expected<std::unique_ptr<ObjDumper>> DumperOrErr = createDumper(Obj, Writer);
+  Expected<std::unique_ptr<ObjDumper>> DumperOrErr =
+      createDumper(Obj, WriterBase);
   if (!DumperOrErr)
     reportError(DumperOrErr.takeError(), FileStr);
   Dumper = (*DumperOrErr).get();
 
-  if (opts::Output == opts::LLVM || opts::InputFilenames.size() > 1 || A) {
-    Writer.startLine() << "\n";
-    Writer.printString("File", FileStr);
+  if (opts::Output == opts::JSON) {
+    JSONScopedPrinter *JSONWriter = cast<JSONScopedPrinter>(WriterBase);
+    JSONWriter->objectBegin();
+    JSONWriter->attributeBegin(FileStr);
+    JSONWriter->objectBegin();
+  } else if (opts::Output == opts::LLVM || opts::InputFilenames.size() > 1 ||
+             A) {
+    ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+    Writer->startLine() << "\n";
+    Writer->printString("File", FileStr);
   }
   if (opts::Output == opts::LLVM) {
-    Writer.printString("Format", Obj.getFileFormatName());
-    Writer.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
-    Writer.printString(
+    WriterBase->printString("Format", Obj.getFileFormatName());
+    WriterBase->printString("Arch", Triple::getArchTypeName(Obj.getArch()));
+    WriterBase->printString(
         "AddressSize",
         std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
     Dumper->printLoadName();
   }
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
 
if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
   }
   if (opts::PrintStackMap)
     Dumper->printStackMap();
   if (opts::PrintStackSizes)
     Dumper->printStackSizes();
+  if (opts::Output == opts::JSON) {
+    JSONScopedPrinter *JSONWriter = cast<JSONScopedPrinter>(WriterBase);
+    JSONWriter->objectEnd();
+    JSONWriter->attributeEnd();
+    JSONWriter->objectEnd();
+  }
 }
 
 /// Dumps each object file in \a Arc;
-static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) {
+static void dumpArchive(const Archive *Arc, ScopedPrinterBase *WriterBase) {
   Error Err = Error::success();
   for (auto &Child : Arc->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
     if (!ChildOrErr) {
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
         reportError(std::move(E), Arc->getFileName());
       continue;
     }
 
     Binary *Bin = ChildOrErr->get();
     if (ObjectFile *Obj = dyn_cast<ObjectFile>(Bin))
-      dumpObject(*Obj, Writer, Arc);
-    else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(Bin))
-      dumpCOFFImportFile(Imp, Writer);
-    else
+      dumpObject(*Obj, WriterBase, Arc);
+    else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(Bin)) {
+      ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+      dumpCOFFImportFile(Imp, *Writer);
+    } else {
       reportWarning(createStringError(errc::invalid_argument,
                                       Bin->getFileName() +
                                           " has an unsupported file type"),
                     Arc->getFileName());
     }
+  }
   if (Err)
     reportError(std::move(Err), Arc->getFileName());
 }
 
 /// Dumps each object file in \a MachO Universal Binary;
 static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary,
-                                     ScopedPrinter &Writer) {
+                                     ScopedPrinterBase *WriterBase) {
   for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) {
     Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile();
     if (ObjOrErr)
-      dumpObject(*ObjOrErr.get(), Writer);
+      dumpObject(*ObjOrErr.get(), WriterBase);
     else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError()))
       reportError(ObjOrErr.takeError(), UBinary->getFileName());
     else if (Expected<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive())
-      dumpArchive(&*AOrErr.get(), Writer);
+      dumpArchive(&*AOrErr.get(), WriterBase);
   }
 }
 
 /// Dumps \a WinRes, Windows Resource (.res) file;
 static void dumpWindowsResourceFile(WindowsResource *WinRes,
-                                    ScopedPrinter &Printer) {
-  WindowsRes::Dumper Dumper(WinRes, Printer);
+                                    ScopedPrinterBase *PrinterBase) {
+  ScopedPrinter *Printer = cast<ScopedPrinter>(PrinterBase);
+  WindowsRes::Dumper Dumper(WinRes, *Printer);
   if (auto Err = Dumper.printData())
     reportError(std::move(Err), WinRes->getFileName());
 }
 
-
 /// Opens \a File and dumps it.
-static void dumpInput(StringRef File, ScopedPrinter &Writer) {
+static void dumpInput(StringRef File, ScopedPrinterBase *WriterBase) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(errorCodeToError(EC), File);
 
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
   file_magic Type = identify_magic(Buffer->getBuffer());
   if (Type == file_magic::bitcode) {
     reportWarning(createStringError(errc::invalid_argument,
                                     "bitcode files are not supported"),
                   File);
     return;
   }
 
   Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(
       Buffer->getMemBufferRef(), /*Context=*/nullptr, /*InitContent=*/false);
   if (!BinaryOrErr)
     reportError(BinaryOrErr.takeError(), File);
 
   std::unique_ptr<Binary> Bin = std::move(*BinaryOrErr);
   if (Archive *Arc = dyn_cast<Archive>(Bin.get()))
-    dumpArchive(Arc, Writer);
+    dumpArchive(Arc, WriterBase);
   else if (MachOUniversalBinary *UBinary =
                dyn_cast<MachOUniversalBinary>(Bin.get()))
-    dumpMachOUniversalBinary(UBinary, Writer);
+    dumpMachOUniversalBinary(UBinary, WriterBase);
   else if (ObjectFile *Obj = dyn_cast<ObjectFile>(Bin.get()))
-    dumpObject(*Obj, Writer);
-  else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(Bin.get()))
-    dumpCOFFImportFile(Import, Writer);
-  else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(Bin.get()))
-    dumpWindowsResourceFile(WinRes, Writer);
+    dumpObject(*Obj, WriterBase);
+  else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(Bin.get())) {
+    ScopedPrinter *Writer = cast<ScopedPrinter>(WriterBase);
+    dumpCOFFImportFile(Import, *Writer);
+  } else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(Bin.get()))
+    dumpWindowsResourceFile(WinRes, WriterBase);
   else
     llvm_unreachable("unrecognized file type");
 
   CVTypes.Binaries.push_back(
       OwningBinary<Binary>(std::move(Bin), std::move(Buffer)));
 }
 
+std::unique_ptr<ScopedPrinterBase> createWriter() {
+  if (opts::Output == opts::JSON)
+    return std::make_unique<JSONScopedPrinter>(fouts());
+  else
+    return std::make_unique<ScopedPrinter>(fouts());
+}
+
 int main(int argc, char *argv[]) {
   InitLLVM X(argc, argv);
   BumpPtrAllocator A;
   StringSaver Saver(A);
   ReadobjOptTable Tbl;
   ToolName = argv[0];
   opt::InputArgList Args =
       Tbl.parseArgs(argc, argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
int main(int argc, char *argv[]) {
 
   if (opts::Headers) {
     opts::FileHeaders = true;
     opts::XCOFFAuxiliaryHeader = true;
     opts::ProgramHeaders = true;
     opts::SectionHeaders = true;
   }
 
-  ScopedPrinter Writer(fouts());
+  std::unique_ptr<ScopedPrinterBase> Writer = createWriter();
+
+  if (opts::Output == opts::JSON) {
+    JSONScopedPrinter *JSONWriter = cast<JSONScopedPrinter>(Writer.get());
+    JSONWriter->arrayBegin();
+  }
+
   for (const std::string &I : opts::InputFilenames)
-    dumpInput(I, Writer);
+    dumpInput(I, Writer.get());
 
   if (opts::CodeViewMergedTypes) {
+    ScopedPrinter *W = cast<ScopedPrinter>(Writer.get());
     if (opts::CodeViewEnableGHash)
-      dumpCodeViewMergedTypes(Writer, CVTypes.GlobalIDTable.records(),
+      dumpCodeViewMergedTypes(*W, CVTypes.GlobalIDTable.records(),
                               CVTypes.GlobalTypeTable.records());
     else
-      dumpCodeViewMergedTypes(Writer, CVTypes.IDTable.records(),
+      dumpCodeViewMergedTypes(*W, CVTypes.IDTable.records(),
                               CVTypes.TypeTable.records());
   }
+  if (opts::Output == opts::JSON) {
+    JSONScopedPrinter *JSONWriter = cast<JSONScopedPrinter>(Writer.get());
+    JSONWriter->arrayEnd();
+  }
 
   return 0;
 }