Add JSONScopedPrinter to llvm-readelf

[Jaysonyan]

Summary

This change adds JSONScopedPrinter to llvm-readelf. It includes an empty JSONELFDumper class which will be used to override any LLVMELFDumper methods which utilize startLine() which JSONScopedPrinter cannot provide.

This change is split from D114052 and builds off of D114224

Depends on D114224

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

708

It's not clear to me why we inherit from LLVMELFDumper in this patch. This probably needs a comment at the very least.

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

233–234

Probably time to turn this into a StringSwitch.

234–245

It would be great if this message included what the actual value specified was, and now's a good time to change it whilst you're here. Providing more context is useful, because it may not always be obvious what the problem is. For example, a command-line of "llvm-readobj --elf-output-syle="GNU my/input/file.o", resulting from a typo, would not always be immediately obvious where the issue is (especially if this was in a script and the input file was in a variable etc).

342–349

These two sets of if statements are actually in the wrong place, in my opinion: I think they should be behind interfaces in the ObjDumper and sub-classes, as appropriate, something like printFileSummary (which could take care of both).

I think it may be a slightly separate issue though. Here's my thinking:

1. LLVM style is controlled via the --elf-output-style option, which has different defaults for llvm-readelf and llvm-readobj.
2. The name of that option implies it has no impact for non-ELF formats, but this area of code is format-agnostic.
3. JSON output probably actually wants to print Format/Arch/AddressSize.
4. Everything else that is impacted by the --elf-output-style option is driven from the inheritance hierarchy. It seems odd that we have something that isn't.

At the very least, we could move the logic into virtual functions in ObjDumper, and then have JSON format provide its own behaviour. This would be a step in the right direction at least. What do you think?

549–551

[Jaysonyan]

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

342–349

I agree that --elf-output-style shouldn't impact non-ELF formats. Although the work of adding a JSONScopedPrinter was not ELF-specific and it may be desirable to add json support for other formats in the future. This makes me wonder if --elf-output-style is an appropriate flag to enable json through or if it'd be preferable to add a format-agnostic flag (ex: --output-format). This could lend itself well if we choose to support json output of other obj formats in the future but could be confusing how --elf-output-style and --output-format would interact with each other. I'm not sure if this is something worth considering since there are currently no plans to support other obj formats but don't want to lock us in to an inconvenient flag choice for the future.

Otherwise, conceptually it makes sense to move this work into ObjDumper methods. One issue I see is that any usage of DictScope or ListScope relies on the ctor and dtor to output the opening/closing braces. So it may be difficult to just move this logic to other methods, especially if we have to initialize multiple DictScopes/ListScopes and just returning a unique_ptr would be insufficient.

[jhenderson]

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

342–349

Yes, changing --elf-output-style to just --output-style was something I've considered a good idea for quite some time. This issue becomes more important as we add JSON support, but I think we can defer it to later on (it shouldn't block this work).

One issue I see is that any usage of DictScope or ListScope relies on the ctor and dtor to output the opening/closing braces.

I'm a little lost which constructor we're talking about here? The ObjDumper constructor or the DictScope/ListScope constructors?

[Jaysonyan]

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

342–349

Referring to the DictScope/ListScope ctor/dtor. Since the opening braces are printed in the constructor and the closing braces are printed in the destructor, moving any instantiations of ListScope/DictScope inside a printFileSummary method becomes difficult since we would still need DictScope/ListScope to get destructed at the end of the dumpObject method rather than at the end of the printFileSummary method.

[jhenderson]

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

342–349

Should the top-level DictScope be a member of the JSONELFDumper? Would that help solve this issue?

Related aside: perhaps in JSON mode, the file summary could become a separate object within the object for the file?

[Jaysonyan]

Update --elf-output-style error messaging.
Add printFileSummary method to ObjDumper.
Misc formatting.

[Jaysonyan]

Update formatting.

[Jaysonyan]

llvm/tools/llvm-readobj/ELFDumper.cpp

708

Added a comment! Let me know if you think it could provide more detail.

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

233–234

I needed to provide a default option to know when to send an error message so I added an UNKOWN entry to the OutputStyelTy enum. If this seems inappropriate I can also change to just using a switch statement.

342–349

Adding the top level DictScope solves the problem! I also added the file summary info to its own object with attribute FileSummary.

[jhenderson]

Tip: add "Depends on DXXXXXX" to the patch description (but no need for it to be in the final commit message) to get Phabricator to auto-link this patch to the predecessor patch. I believe this helps the pre-merge checks, and also provides a nice little "Stack" view in the interface.

llvm/tools/llvm-readobj/ELFDumper.cpp

708

Thanks. Missing a trailing . though.

The limited nature of this new dumper class shows that we're not far off the ideal of having just one common class, which takes a ScopedPrinter (or JSONScopedPrinter), but I don't think we'll get there with this patch.

3257–3258

Old code used "\n" rather than '\n'. I think the former may be more common elsewhere in LLVM in general, although I'm not aware of any concrete coding standard.

Also, can't we use the existing W in the base class here, to keep the code identical to what it was before?

7349

Isn't this a behaviour change? Is it necesssary? If so, I'd defer it to a separate patch, if at all possible (or put it in a prerequisite patch), so that this patch is a pure NFC if a user doesn't specify --elf-output-style=json. I'm also slightly surprised I didn't see any test failures?

I'd suggest in this patch to call out to the base class version to do most of the work, although there's now a slight impedence to doing that in the form of the additional new line printed in one case but not the other, which I'd query.

The base class version was doing the JSON style version before, so I wonder if there's a good reason for this and the base class to diverge?

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

233–234

UNKNOWN is a reasonable addition, in my opinion.

234–244

234–244

Perhaps pull A->getValue() into a helper variable, since you use it in the error message below.

234–245

I think the text as it was was a little better, and I'd just add "but was \"foo\"" to the end.

Aside: general LLVM style for error messages is no leading capital letter.

[Jaysonyan]

Update error messaging.
Misc formatting.

llvm/tools/llvm-readobj/ELFDumper.cpp

7349

Sorry, I'm not sure if I fully understand what constitutes as a behaviour change. This method would only be run when the user has specified --elf-output-style=JSON (which is introduced in this patch) so it shouldn't impact any existing behaviour.

The base class version calls W.startLine() which isn't well supported with JSONScopedPrinter and my expectation was to override any methods in the base class which use startLine(). Beyond that, the FileScope is needed in this implementation based on our previous discussion (D114225#inline-1092086) to achieve the desired JSON output discussed in the initial patch (D111658#3072213). If we relied solely on the base class, we wouldn't get each file in their own {}.

In my opinion, it makes sense to not break this change out into its own patch because it relies on the existence of a JSONELFDumper which is introduced in this patch and this patch relies on this change so that the output is in a reasonable format (each file has it's own object).

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

7349

Sorry, I'm not sure if I fully understand what constitutes as a behaviour change. This method would only be run when the user has specified --elf-output-style=JSON (which is introduced in this patch) so it shouldn't impact any existing behaviour.

Apologies, I think I was looking at the "changes since previous action" view, so didn't notice that this was in the JSONELFDumper function.

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

242

Missed that you need a comma here.

342

I guess there's a subtle behaviour change as a result of this patch, which wouldn't hurt to be called out in the commit description, but I otherwise think is fine: if a user had exactly one non-ELF object/archive (e.g. a COFF object), and they had previously specified --elf-output-style=GNU (or run using llvm-readelf, which has that as the default), they would previously have had no file summary, but now they'd get the default summary, provided by the ObjDumper class. Similarly, if they'd had more than one input, or the objects were in an archive, they'd before have had just the File part of the summary, but now they have the full file summary.

616–618

To recap: we only need this scope for JSON, so that there is a top-level object, ensuring we always have valid JSON in the output. What's stopping us making the ListScope a member of the JSONScopedPrinter class, so that the scoping is added on construction/destruction of the Writer?

Taking it from another point of view, if you had another piece of client code using JSONScopedPrinter, would they expect the output to be a valid JSON object, without additional changes, or expect to need to provide the outer object wrapping themselves? If the former, the scoping belongs to the JSCONScopedPrinter.

[jhenderson]

Oh, you should also add one test in this patch to show that the file summary output is correct for JSON output, with a single file, multiple files, and a single archive file (possibly with only one object).

[Jaysonyan]

Add missing comma in error message.

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

342

I placed the same opts::InputFilenames.size() > 1 || A check inside GNUELFDumper::printFileSummary method so I think the behaviour is the same.

Before, if the opts::Output is LLVM both if(...) statements would trigger. Now the ObjDumper::printFileSummary performs all the work in both if statements and would be called for any Dumper that is not GNUELFDumper or JSONELFDumper which should be any case where opts::Output is LLVM.

And the GNUELFDumper::printFileSummary only prints the File part and still does the multiple inputs / archive check.

616–618

I think providing an optional ListScope/DictScope constructor could be a nice quality-of-life improvement, but I think there should still be a way to construct a JSONScopedPrinter without {}/[] already added. Since technically, "string" is still valid json so I wouldn't want to remove the option to output json that don't have an outermost []/{}.

[Jaysonyan]

Add JSON FileSummary tests.
Add pretty-print option to llvm-readelf.

[Jaysonyan]

Add pretty-print test.

[jhenderson]

Please remember to update llvm/docs/CommandGuide/llvm-readelf.rst and llvm/docs/CommandGuide/llvm-readobj.rst as appropriate for the new options.

llvm/test/tools/llvm-readobj/ELF/json-file-summary.test

1 ↗

(On Diff #391945)

I'd rename this test file-summary-json.test.

I'd also test the entire output, so that you catch the opening and closing braces (if any) as well as any formatting points. To do this, I'd add --match-full-lines, --strict-whitespace and --implicit-check-not={{.}} to the FileCheck executions. These ensure that a) there is no other output on the same line (by default, FileCheck matches substrings); b) there is no additional whitespace on the line (by default, FileCheck ignores leading and trailing whitespace, and compresses all other whitespace into single ' ' characters); c) ensures the regex pattern . doesn't match anything that isn't covered by an existing check.

4 ↗

(On Diff #391945)

I'd avoid reusing the same output filename, as it makes things a little easier to debug sometimes when there's a test problem. Probably name the files %t.single, %t.multiple and %t.archive.

5 ↗

(On Diff #391945)

These RUN lines are getting quite long. I'd break them up as in the suggested edit. You can use the \ to continue a RUN statement onto the next line, so this might be useful too to allow the FileCheck command to run across multiple lines, when you add the extra options.

llvm/test/tools/llvm-readobj/ELF/pretty-print.test

4

5–6

Same comments as above re. FileCheck additional options, output file name, and breaking up over multiple lines. Also applies below.

llvm/tools/llvm-readobj/Opts.td

31

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

342

No, I don't think the behaviour is the same. Non-ELF objects (e.g. COFF/XCOFF etc) won't use the *ELFDumper classes, regardless of the --elf-output-style option's value. This is unchanged from before. The difference is that the opts::Output value now doesn't have a direct impact on the output (which is good), and only picks the dumper class to use for ELF objects. This means non-ELF objects will always have the default file summary behaviour.

I think this is a good behaviour change (GNU output style should have no effect for non-ELF objects), but it needs highlighting, as said already.

616–618

Yes, I see your point, and agree with you. Are you suggesting deferring to a separate patch, or as part of the original JSONScopedPrinter patch? I suggest the latter, because it will directly improve the code here, in my opinion.

[Jaysonyan]

Use JSONScopedPrinter ctor to initialize outer-most [].

[Jaysonyan]

Update docs.
Clean up tests.

[Jaysonyan]

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

342

Sorry, don't mean to drag this on but I wanted to ensure we're on the same page.

opts::Output by default is initialized to LLVM so if --elf-output-style is not specified, then opts::Output will be LLVM. So I believe that even beforehand non-ELF objects would still have file summary information. Looking at a readobj tests with COFF here it looks like it's printing file summary info despite not being an ELF object.

616–618

Updated the JSONScopedPrinter patch to add this and use that change here.

[jhenderson]

llvm/docs/CommandGuide/llvm-readelf.rst

77

This line might need reflowing, to keep to a standard width (80 presumably).

78

JSON is an acronym, so should always be all-caps.

133

I'd suggest ", ... JSON output will be formatted in a more readable format." instead of the "will ..." part of the sentence.

llvm/docs/CommandGuide/llvm-readobj.rst

189

213

Use the same description as the other doc.

llvm/test/tools/llvm-readobj/ELF/file-summary-json.test

5

I'm being dumb: you only need one yaml2obj invocation for all test inputs. Delete the others, and rename the file %t or %t.o or similar.

7–8

Add some indentation to make it clear these are continuation lines. Same elsewhere.

57

llvm-ar r doesn't delete the existing archive or its contents, which can lead to unexpected results, if the test were aborted/updated in the future. Delete the archive file before recreating it here. Same below.

llvm/test/tools/llvm-readobj/ELF/pretty-print.test

7

-D is usually a single-dash option; --check-prefix usually has two dashes.

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

342

Default and --elf-output-style=LLVM behaviours are unchanged. I'm not talking about those. I'm talking about the following command-line:

$ llvm-readobj coff.obj --elf-output-style=GNU

Before this had no file summary. Now it does. I think it is okay if it does, but I think this should be called out in the commit description.

[Jaysonyan]

Update docs formatting.
Update file-summary and pretty print tests.

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

342

Ok I see now, sorry for taking so long to understand. Will definitely call out this change in the commit description.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/file-summary-json.test

4–5

No need to rm an object file. That's only necessary for archive files (yaml2obj overwrites the existing file, whereas llvm-ar appends to it).

65–67

You should be able to be more precise, rather than skipping a chunk of the name. I think the relevant lit macro is %basename_t or something to that effect. You could pass that into an additional argument e.g. -DMEMBER.

[Jaysonyan]

Fix up file-summary test.

[Jaysonyan]

Just as a heads up, Dec 10th is the last day of my internship so unfortunately after that I won't be able to work on this change as actively as before. If there is still feedback to address a member of my team may be able to pick this up from where I left off. And thank you for taking the time to review all of my code changes these past months!

llvm/test/tools/llvm-readobj/ELF/file-summary-json.test

65–67

I was able to remove the {{.*}} by matching the structure of llvm-readobj/archive.test.

[jhenderson]

Looks good!

In D114225#3184814, @Jaysonyan wrote:

Just as a heads up, Dec 10th is the last day of my internship so unfortunately after that I won't be able to work on this change as actively as before. If there is still feedback to address a member of my team may be able to pick this up from where I left off. And thank you for taking the time to review all of my code changes these past months!

No problem. I think this is now in a good state to land the first sequence of patches. Hopefully you can get that done today.

[thakis]

The test fails on Windows: http://45.33.8.238/win/50629/step_11.txt

Please take a look and revert for now if it takes a while to fix.

[Jaysonyan]

In D114225#3186242, @thakis wrote:

The test fails on Windows: http://45.33.8.238/win/50629/step_11.txt

Please take a look and revert for now if it takes a while to fix.

Thank you for the heads up, I'm taking a look now, hopefully I'll have a fix soon and if not I'll revert these changes.

[jhenderson]

In D114225#3186298, @Jaysonyan wrote:

In D114225#3186242, @thakis wrote:

The test fails on Windows: http://45.33.8.238/win/50629/step_11.txt

Please take a look and revert for now if it takes a while to fix.

Thank you for the heads up, I'm taking a look now, hopefully I'll have a fix soon and if not I'll revert these changes.

An alternative test fix (and arguably a better one), would be to cd into the %t.dir directory after creating it, and then running all operations relative to the cwd, rather than the absolute paths %t translates into. You might want to consider making that change.

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

 .. option:: --no-demangle
 
  Do not display demangled symbol names in the output. On by default.
 
 .. option:: --notes, -n
 
  Display all notes.
 
+.. option:: --pretty-print
+
+ When used with :option:`--elf-output-style`, JSON output will be formatted in
+ a more readable format.
+
 .. option:: --program-headers, --segments, -l
 
  Display the program headers.
 
 .. option:: --raw-relr
 
  Do not decode relocations in RELR relocation sections when displaying them.
 

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 (the default) is an expanded and
+ structured format. ``GNU`` 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.
 
 .. option:: --hash-symbols
 
  Display the expanded hash table with dynamic symbol data.
 
 .. option:: --hash-table
 
  Display the hash table for dynamic symbols.
 
 .. option:: --notes, -n
 
  Display all notes.
 
+.. option:: --pretty-print
+
+ When used with :option:`--elf-output-style`, JSON output will be formatted in
+ a more readable format.
+
 .. option:: --program-headers, --segments, -l
 
  Display the program headers.
 
 .. option:: --raw-relr
 
  Do not decode relocations in RELR relocation sections when displaying them.
 

llvm/test/tools/llvm-readobj/ELF/file-summary-json.test

+## Test how we output JSON file summaries.
+
+# RUN: rm -rf %t.dir
+# RUN: mkdir -p %t.dir
+# RUN: yaml2obj %s -o %t.dir/obj
+
+## Test outputting file summary for a single file.
+# RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.dir/obj | \
+# RUN:   FileCheck %s --check-prefix=SINGLE \
+# RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}
+
+#      SINGLE:[
+# SINGLE-NEXT:  {
+# SINGLE-NEXT:    "{{.*}}/obj": {
+# SINGLE-NEXT:      "FileSummary": {
+# SINGLE-NEXT:        "File": "{{.*}}/obj",
+# SINGLE-NEXT:        "Format": "elf64-x86-64",
+# SINGLE-NEXT:        "Arch": "x86_64",
+# SINGLE-NEXT:        "AddressSize": "64bit",
+# SINGLE-NEXT:        "LoadName": "<Not found>"
+# SINGLE-NEXT:      }
+# SINGLE-NEXT:    }
+# SINGLE-NEXT:  }
+# SINGLE-NEXT:]
+
+## Test outputting file summary for multiple files.
+# RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.dir/obj %t.dir/obj | \
+# RUN:   FileCheck %s --check-prefix=MULTI \
+# RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}
+
+#      MULTI:[
+# MULTI-NEXT:  {
+# MULTI-NEXT:    "{{.*}}/obj": {
+# MULTI-NEXT:      "FileSummary": {
+# MULTI-NEXT:        "File": "{{.*}}/obj",
+# MULTI-NEXT:        "Format": "elf64-x86-64",
+# MULTI-NEXT:        "Arch": "x86_64",
+# MULTI-NEXT:        "AddressSize": "64bit",
+# MULTI-NEXT:        "LoadName": "<Not found>"
+# MULTI-NEXT:      }
+# MULTI-NEXT:    }
+# MULTI-NEXT:  },
+# MULTI-NEXT:  {
+# MULTI-NEXT:    "{{.*}}/obj": {
+# MULTI-NEXT:      "FileSummary": {
+# MULTI-NEXT:        "File": "{{.*}}/obj",
+# MULTI-NEXT:        "Format": "elf64-x86-64",
+# MULTI-NEXT:        "Arch": "x86_64",
+# MULTI-NEXT:        "AddressSize": "64bit",
+# MULTI-NEXT:        "LoadName": "<Not found>"
+# MULTI-NEXT:      }
+# MULTI-NEXT:    }
+# MULTI-NEXT:  }
+# MULTI-NEXT:]
+
+## Test outputting file summary for an archive with a single file.
+# RUN: rm -f %t.archive-single
+# RUN: llvm-ar rc %t.archive-single %t.dir/obj
+# RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.archive-single | \
+# RUN:   FileCheck %s --check-prefix=ARCH-SINGLE \
+# RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}
+
+#      ARCH-SINGLE:[
+# ARCH-SINGLE-NEXT:  {
+# ARCH-SINGLE-NEXT:    "{{.*}}.archive-single(obj)": {
+# ARCH-SINGLE-NEXT:      "FileSummary": {
+# ARCH-SINGLE-NEXT:        "File": "{{.*}}.archive-single(obj)",
+# ARCH-SINGLE-NEXT:        "Format": "elf64-x86-64",
+# ARCH-SINGLE-NEXT:        "Arch": "x86_64",
+# ARCH-SINGLE-NEXT:        "AddressSize": "64bit",
+# ARCH-SINGLE-NEXT:        "LoadName": "<Not found>"
+# ARCH-SINGLE-NEXT:      }
+# ARCH-SINGLE-NEXT:    }
+# ARCH-SINGLE-NEXT:  }
+# ARCH-SINGLE-NEXT:]
+
+## Test outputting file summary for an archive with multiple files.
+# RUN: rm -f %t.archive-multiple
+# RUN: llvm-ar rc %t.archive-multiple %t.dir/obj %t.dir/obj
+# RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.archive-multiple | \
+# RUN:   FileCheck %s --check-prefix=ARCH-MULTI \
+# RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}
+
+#      ARCH-MULTI:[
+# ARCH-MULTI-NEXT:  {
+# ARCH-MULTI-NEXT:    "{{.*}}.archive-multiple(obj)": {
+# ARCH-MULTI-NEXT:      "FileSummary": {
+# ARCH-MULTI-NEXT:        "File": "{{.*}}.archive-multiple(obj)",
+# ARCH-MULTI-NEXT:        "Format": "elf64-x86-64",
+# ARCH-MULTI-NEXT:        "Arch": "x86_64",
+# ARCH-MULTI-NEXT:        "AddressSize": "64bit",
+# ARCH-MULTI-NEXT:        "LoadName": "<Not found>"
+# ARCH-MULTI-NEXT:      }
+# ARCH-MULTI-NEXT:    }
+# ARCH-MULTI-NEXT:  },
+# ARCH-MULTI-NEXT:  {
+# ARCH-MULTI-NEXT:    "{{.*}}.archive-multiple(obj)": {
+# ARCH-MULTI-NEXT:      "FileSummary": {
+# ARCH-MULTI-NEXT:        "File": "{{.*}}.archive-multiple(obj)",
+# ARCH-MULTI-NEXT:        "Format": "elf64-x86-64",
+# ARCH-MULTI-NEXT:        "Arch": "x86_64",
+# ARCH-MULTI-NEXT:        "AddressSize": "64bit",
+# ARCH-MULTI-NEXT:        "LoadName": "<Not found>"
+# ARCH-MULTI-NEXT:      }
+# ARCH-MULTI-NEXT:    }
+# ARCH-MULTI-NEXT:  }
+# ARCH-MULTI-NEXT:]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64

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', but was 'unknown'

llvm/test/tools/llvm-readobj/ELF/pretty-print.test

+## Test the JSON pretty-print flag.
+#
+# RUN: yaml2obj %s -o %t.pretty
+
+## Test JSON with pretty-print off.
+# RUN: llvm-readobj --elf-output-style=JSON %t.pretty | \
+# RUN:   FileCheck %s --check-prefix=NO-PRETTY \
+# RUN:     --strict-whitespace --implicit-check-not={{.}}
+
+#      NO-PRETTY:[
+# NO-PRETTY-SAME:{
+# NO-PRETTY-SAME:"{{.*}}.pretty":{
+# NO-PRETTY-SAME:"FileSummary":{
+# NO-PRETTY-SAME:"File":"{{.*}}.pretty",
+# NO-PRETTY-SAME:"Format":"elf64-x86-64",
+# NO-PRETTY-SAME:"Arch":"x86_64",
+# NO-PRETTY-SAME:"AddressSize":"64bit",
+# NO-PRETTY-SAME:"LoadName":"<Not found>"
+# NO-PRETTY-SAME:}
+# NO-PRETTY-SAME:}
+# NO-PRETTY-SAME:}
+# NO-PRETTY-SAME:]
+
+## Test JSON with pretty-print on.
+# RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.pretty | \
+# RUN:   FileCheck %s --check-prefix=PRETTY \
+# RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}
+
+#      PRETTY:[
+# PRETTY-NEXT:  {
+# PRETTY-NEXT:    "{{.*}}.pretty": {
+# PRETTY-NEXT:      "FileSummary": {
+# PRETTY-NEXT:        "File": "{{.*}}.pretty",
+# PRETTY-NEXT:        "Format": "elf64-x86-64",
+# PRETTY-NEXT:        "Arch": "x86_64",
+# PRETTY-NEXT:        "AddressSize": "64bit",
+# PRETTY-NEXT:        "LoadName": "<Not found>"
+# PRETTY-NEXT:      }
+# PRETTY-NEXT:    }
+# PRETTY-NEXT:  }
+# PRETTY-NEXT:]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocationResolver.h"
 #include "llvm/Object/StackMapParser.h"
 #include "llvm/Support/AMDGPUMetadata.h"
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())) {
     assert(&this->W.getOStream() == &llvm::fouts());
   }
 
+  void printFileSummary(StringRef FileStr, ObjectFile &Obj,
+                        ArrayRef<std::string> InputFilenames,
+                        const Archive *A) override;
   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;
private:
   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;
 
+protected:
   ScopedPrinter &W;
 };
 
+// JSONELFDumper shares most of the same implementation as LLVMELFDumper except
+// it uses a JSONScopedPrinter.
+template <typename ELFT> class JSONELFDumper : public LLVMELFDumper<ELFT> {
+public:
+  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
+
+  JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
+      : LLVMELFDumper<ELFT>(ObjF, Writer) {}
+
+  void printFileSummary(StringRef FileStr, ObjectFile &Obj,
+                        ArrayRef<std::string> InputFilenames,
+                        const Archive *A) override;
+
+private:
+  std::unique_ptr<DictScope> FileScope;
+};
+
 } // end anonymous namespace
 
 namespace llvm {
 
 template <class ELFT>
 static std::unique_ptr<ObjDumper>
 createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) {
   if (opts::Output == opts::GNU)
     return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer);
+  else if (opts::Output == opts::JSON)
+    return std::make_unique<JSONELFDumper<ELFT>>(Obj, Writer);
   return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer);
 }
 
 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
                                            ScopedPrinter &Writer) {
   // Little-endian 32-bit
   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj))
     return createELFDumper(*ELFObj, Writer);
static const EnumEntry<unsigned> *getObjectFileEnumEntry(unsigned Type) {
   auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) {
     return E.Value == Type;
   });
   if (It != makeArrayRef(ElfObjectFileType).end())
     return It;
   return nullptr;
 }
 
+template <class ELFT>
+void GNUELFDumper<ELFT>::printFileSummary(StringRef FileStr, ObjectFile &Obj,
+                                          ArrayRef<std::string> InputFilenames,
+                                          const Archive *A) {
+  if (InputFilenames.size() > 1 || A) {
+    this->W.startLine() << "\n";
+    this->W.printString("File", FileStr);
+  }
+}
+
 template <class ELFT> void GNUELFDumper<ELFT>::printFileHeaders() {
   const Elf_Ehdr &e = this->Obj.getHeader();
   OS << "ELF Header:\n";
   OS << "  Magic:  ";
   std::string Str;
   for (int i = 0; i < ELF::EI_NIDENT; i++)
     OS << format(" %02x", static_cast<int>(e.e_ident[i]));
   OS << "\n";
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>::printFileSummary(StringRef FileStr, ObjectFile &Obj,
+                                           ArrayRef<std::string> InputFilenames,
+                                           const Archive *A) {
+  FileScope = std::make_unique<DictScope>(this->W, FileStr);
+  DictScope D(this->W, "FileSummary");
+  this->W.printString("File", FileStr);
+  this->W.printString("Format", Obj.getFileFormatName());
+  this->W.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
+  this->W.printString(
+      "AddressSize",
+      std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
+  this->printLoadName();
+}

llvm/tools/llvm-readobj/ObjDumper.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 
 #include <unordered_set>
 
 namespace llvm {
 namespace object {
+class Archive;
 class COFFImportFile;
 class ObjectFile;
 class XCOFFObjectFile;
 class ELFObjectFileBase;
 }
 namespace codeview {
 class GlobalTypeTableBuilder;
 class MergingTypeTableBuilder;
 } // namespace codeview
 
 class ScopedPrinter;
 
 class ObjDumper {
 public:
   ObjDumper(ScopedPrinter &Writer, StringRef ObjName);
   virtual ~ObjDumper();
 
   virtual bool canDumpContent() { return true; }
 
+  virtual void printFileSummary(StringRef FileStr, object::ObjectFile &Obj,
+                                ArrayRef<std::string> InputFilenames,
+                                const object::Archive *A);
   virtual void printFileHeaders() = 0;
   virtual void printSectionHeaders() = 0;
   virtual void printRelocations() = 0;
   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
     if (PrintSymbols)
       printSymbols();
     if (PrintDynamicSymbols)
       printDynamicSymbols();

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/Archive.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace llvm {
while (CurrentWord <= StrEnd) {
     }
     W.startLine() << format("[%6tx] ", CurrentWord - StrContent);
     printAsPrintable(W.startLine(), CurrentWord, WordSize);
     W.startLine() << '\n';
     CurrentWord += WordSize + 1;
   }
 }
 
+void ObjDumper::printFileSummary(StringRef FileStr, object::ObjectFile &Obj,
+                                 ArrayRef<std::string> InputFilenames,
+                                 const object::Archive *A) {
+  W.startLine() << "\n";
+  W.printString("File", FileStr);
+  W.printString("Format", Obj.getFileFormatName());
+  W.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
+  W.printString("AddressSize",
+                std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
+  this->printLoadName();
+}
+
 static std::vector<object::SectionRef>
 getSectionRefsByNameOrIndex(const object::ObjectFile &Obj,
                             ArrayRef<std::string> Sections) {
   std::vector<object::SectionRef> Ret;
   std::map<std::string, bool> SecNames;
   std::map<unsigned, bool> SecIndices;
   unsigned SecIndex;
   for (StringRef Section : Sections) {

llvm/tools/llvm-readobj/Opts.td

 defm demangle : BB<"demangle", "Demangle symbol names", "Do not demangle symbol names (default)">;
 def dependent_libraries : FF<"dependent-libraries", "Display the dependent libraries section">;
 def dyn_relocations : FF<"dyn-relocations", "Display the dynamic relocation entries in the file">;
 def dyn_syms : FF<"dyn-syms", "Display the dynamic symbol table">;
 def expand_relocs : FF<"expand-relocs", "Expand each shown relocation to multiple lines">;
 def file_header : FF<"file-header", "Display file header">;
 def headers : FF<"headers", "Equivalent to setting: --file-header, --program-headers, --section-headers">;
 defm hex_dump : Eq<"hex-dump", "Display the specified section(s) as hexadecimal bytes">, MetaVarName<"<name or index>">;
+def pretty_print : FF<"pretty-print", "Pretty print JSON output">;
 def relocs : FF<"relocs", "Display the relocation entries in the file">;
 def section_data : FF<"section-data", "Display section data for each section shown. This option has no effect for GNU style output">;
 def section_details : FF<"section-details", "Display the section details">;
 def section_headers : FF<"section-headers", "Display section headers">;
 def section_mapping : FF<"section-mapping", "Display the section to segment mapping">;
 def section_mapping_EQ_false : FF<"section-mapping=false", "Don't display the section to segment mapping">, Flags<[HelpHidden]>;
 def section_relocations : FF<"section-relocations", "Display relocations for each section shown. This option has no effect for GNU style output">;
 def section_symbols : FF<"section-symbols", "Display symbols for each section shown. This option has no effect for GNU style output">;
 def stack_sizes : FF<"stack-sizes", "Display contents of all stack sizes sections. This option has no effect for GNU style output">;
 def stackmap : FF<"stackmap", "Display contents of stackmap section">;
 defm string_dump : Eq<"string-dump", "Display the specified section(s) as a list of strings">, MetaVarName<"<name or index>">;
 def string_table : FF<"string-table", "Display the string table (only for XCOFF now)">;
 def symbols : FF<"symbols", "Display the symbol table. Also display the dynamic symbol table when using GNU output style for ELF">;
 def unwind : FF<"unwind", "Display unwind information">;
 
 // ELF specific options.
 def grp_elf : OptionGroup<"kind">, HelpText<"OPTIONS (ELF specific)">;
 def dynamic_table : FF<"dynamic-table", "Display the dynamic section table">, Group<grp_elf>;
 def elf_linker_options : FF<"elf-linker-options", "Display the .linker-options section">, Group<grp_elf>;
-defm elf_output_style : Eq<"elf-output-style", "Specify ELF dump style: LLVM or GNU">, Group<grp_elf>;
+defm elf_output_style : Eq<"elf-output-style", "Specify ELF dump style: LLVM, GNU, JSON">, Group<grp_elf>;
 def histogram : FF<"histogram", "Display bucket list histogram for hash sections">, Group<grp_elf>;
 def section_groups : FF<"section-groups", "Display section groups">, Group<grp_elf>;
 def gnu_hash_table : FF<"gnu-hash-table", "Display the GNU hash table for dynamic symbols">, Group<grp_elf>;
 def hash_symbols : FF<"hash-symbols", "Display the dynamic symbols derived from the hash section">, Group<grp_elf>;
 def hash_table : FF<"hash-table", "Display .hash section">, Group<grp_elf>;
 def needed_libs : FF<"needed-libs", "Display the needed libraries">, Group<grp_elf>;
 def notes : FF<"notes", "Display notes">, Group<grp_elf>;
 def program_headers : FF<"program-headers", "Display program headers">, Group<grp_elf>;

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, UNKNOWN };
 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

 static bool CGProfile;
 bool Demangle;
 static bool DependentLibraries;
 static bool DynRelocs;
 static bool DynamicSymbols;
 static bool FileHeaders;
 static bool Headers;
 static std::vector<std::string> HexDump;
+static bool PrettyPrint;
 static bool PrintStackMap;
 static bool PrintStackSizes;
 static bool Relocations;
 bool SectionData;
 static bool SectionDetails;
 static bool SectionHeaders;
 bool SectionRelocations;
 bool SectionSymbols;
static void parseOptions(const opt::InputArgList &Args) {
   opts::StringDump = Args.getAllArgValues(OPT_string_dump_EQ);
   opts::StringTable = Args.hasArg(OPT_string_table);
   opts::Symbols = Args.hasArg(OPT_symbols);
   opts::UnwindInfo = Args.hasArg(OPT_unwind);
 
   // ELF specific options.
   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
-      error("--elf-output-style value should be either 'LLVM' or 'GNU'");
+    std::string OutputStyleChoice = A->getValue();
+    opts::Output = StringSwitch<opts::OutputStyleTy>(OutputStyleChoice)
+                       .Case("LLVM", opts::OutputStyleTy::LLVM)
+                       .Case("GNU", opts::OutputStyleTy::GNU)
+                       .Case("JSON", opts::OutputStyleTy::JSON)
+                       .Default(opts::OutputStyleTy::UNKNOWN);
+    if (opts::Output == opts::OutputStyleTy::UNKNOWN) {
+      error("--elf-output-style value should be either 'LLVM', 'GNU', or "
+            "'JSON', but was '" +
+            OutputStyleChoice + "'");
+    }
   }
   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::PrettyPrint = Args.hasArg(OPT_pretty_print);
   opts::ProgramHeaders = Args.hasArg(OPT_program_headers);
   opts::RawRelr = Args.hasArg(OPT_raw_relr);
   opts::SectionGroups = Args.hasArg(OPT_section_groups);
   opts::VersionInfo = Args.hasArg(OPT_version_info);
 
   // Mach-O specific options.
   opts::MachODataInCode = Args.hasArg(OPT_macho_data_in_code);
   opts::MachODysymtab = Args.hasArg(OPT_macho_dysymtab);
ContentErrString = "unable to continue dumping, the file is corrupt: " +
                        toString(std::move(ContentErr));
 
   ObjDumper *Dumper;
   Expected<std::unique_ptr<ObjDumper>> DumperOrErr = createDumper(Obj, Writer);
   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::LLVM) {
-    Writer.printString("Format", Obj.getFileFormatName());
-    Writer.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
-    Writer.printString(
-        "AddressSize",
-        std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
-    Dumper->printLoadName();
-  }
+  Dumper->printFileSummary(FileStr, Obj, opts::InputFilenames, A);
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
 
   if (Obj.isXCOFF() && opts::XCOFFAuxiliaryHeader)
     Dumper->printAuxiliaryHeader();
 
   // This is only used for ELF currently. In some cases, when an object is
   // corrupt (e.g. truncated), we can't dump anything except the file header.
   if (!ContentErrString.empty())
     reportError(createError(ContentErrString), FileStr);
 
   if (opts::SectionDetails || opts::SectionHeaders) {
     if (opts::Output == opts::GNU && opts::SectionDetails)
       Dumper->printSectionDetails();
else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(Bin.get()))
     dumpWindowsResourceFile(WinRes, Writer);
   else
     llvm_unreachable("unrecognized file type");
 
   CVTypes.Binaries.push_back(
       OwningBinary<Binary>(std::move(Bin), std::move(Buffer)));
 }
 
+std::unique_ptr<ScopedPrinter> createWriter() {
+  if (opts::Output == opts::JSON)
+    return std::make_unique<JSONScopedPrinter>(
+        fouts(), opts::PrettyPrint ? 2 : 0, std::make_unique<ListScope>());
+  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<ScopedPrinter> Writer = createWriter();
+
   for (const std::string &I : opts::InputFilenames)
-    dumpInput(I, Writer);
+    dumpInput(I, *Writer.get());
 
   if (opts::CodeViewMergedTypes) {
     if (opts::CodeViewEnableGHash)
-      dumpCodeViewMergedTypes(Writer, CVTypes.GlobalIDTable.records(),
+      dumpCodeViewMergedTypes(*Writer.get(), CVTypes.GlobalIDTable.records(),
                               CVTypes.GlobalTypeTable.records());
     else
-      dumpCodeViewMergedTypes(Writer, CVTypes.IDTable.records(),
+      dumpCodeViewMergedTypes(*Writer.get(), CVTypes.IDTable.records(),
                               CVTypes.TypeTable.records());
   }
 
   return 0;
 }