[llvm-readobj] Add a flag to dump just the section-to-segment mapping.

[mattd]

Summary

The following patch introduces a new function printSectionMapping which is responsible for dumping just the section-to-segment mapping.
This patch also introduces a n option -section-mapping that outputs that mapping without the program headers.

Previously, this functionality was controlled by printProgramHeaders, and the output from -program-headers has not been changed. I am happy to change the option name, I copied the name that was displayed when outputting the mapping table.

[jhenderson]

FYI, I've added a couple more reviewers who have reviewed some of my recent changes in this area too.

How about a test case for the new switch?

llvm/tools/llvm-readobj/ELFDumper.cpp

341

Could this have a default definition, like printHashSymbols above?

471

Not that it needs to be part of this change, but it might be nice if this were to be implemented for LLVM output style at some point.

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

466–467

One thing I think we want to avoid is printing this mapping separately if --section-mapping and --program-headers are both specified.

Also, my gut feeling is that the output would be easier to read for --section-headers --section-mapping, if the section mapping appears after the section headers, but I don't feel strongly about it.

Perhaps any ordering inconsistency could be solved by moving this to immediately after printProgramHeaders?

[rupprecht]

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

466–467

+1, to both those points

Alternatively, maybe don't call printSectionMapping() from within printProgramHeaders(), but instead have opts::ProgramHeaders imply opts::SectionMapping, and make sure to call printSectionMapping() right after printProgramHeaders().

Also worth considering is if you want to handle "--program-headers --section-mapping=false" differently. Not sure it's necessary to handle that.

[mattd]

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

466–467

Alternatively, maybe don't call printSectionMapping() from within printProgramHeaders(), but instead have opts::ProgramHeaders imply opts::SectionMapping, and make sure to call printSectionMapping() right after printProgramHeaders().

I like that suggestion. Thanks for the feedback.

[mattd]

• Moved the call to printSectionMapping after printSectionHeaders`
• Specifying --program-headers will still print the section mapping; however, the calls to printSectionMapping has been removed from the body of printProgramHeaders

[rupprecht]

This still needs a few tests, such as:

1. llvm-readelf -section-mapping prints the section mapping (and no program headers)
2. llvm-readelf -section-mapping -program-headers produces the same output as llvm-readelf -program-headers
3. llvm-readelf -section-mapping -program-headers (or equivalently llvm-readelf -program-headers) prints the section to segment mapping exactly once (RUN: llvm-readelf ... | grep "Section to Segment mapping:" | count 1)

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

483

This can still show up twice, i.e.

$ llvm-readelf --section-mapping --program-headers llvm-readelf
# ... section to segment mapping ...
# ... program headers ...
# ... section to segment mapping ...

I was thinking something like this would work:

if (opts::ProgramHeaders)
  Dumper->printProgramHeaders();
if (opts::ProgramHeaders || opts::SectionMapping)
  Dumper->printSectionMapping();

Or equivalently,

// In args parsing section above
if (opts::ProgramHeaders)
  opts::SectionMapping = true; // Maybe also check --section-mapping=false wasn't explicitly specified
...
// Here
if (opts::ProgramHeaders)
  Dumper->printProgramHeaders();
if (opts::SectionMapping)
  Dumper->printSectionMapping();

[mattd]

Thanks for the feedback, and my apologies for not originally providing as thorough of
testing as I should have.

This updated patch introduces the -section-mapping flag which can safely
operate (e.g., no duplicate mappings displayed) with -program-headers.

I've modified the tests to ELF64 in llvm/test/tools/llvm-readobj/gnu-phdrs.test
such that they are specialized on both the program headers and the section mapping.
This allows us to reuse some of the existing test output. I realize that the order of the prefixes is not
respected when using FileCheck's -check-prefixes; however, the
initial ELF test does recognize order as it only has one FileCheck prefix.

Added tests:
1 Check that llvm-readobj -program-headers generates the same output as
llvm-readelf -program-headers. Similar, -section-mapping -program-headers also
produces the same output as -program-headers

2 Check that -section-mapping and -program-headers observes the correct
order (display the headers followed by the section mapping).

3 Check that specifying -section-mapping only produces the mapping.

4 Check that specifying -section-mapping=false -program-headers only
produces the headers.

5 Check that only a single copy of the mapping table is produced when
combining -section-mapping and -program-headers options.

[grimar]

This looks good to me.
(I had a few NFC comments about GNUStyle<ELFT>::printSectionMapping implementation but then realized you only moved that code.)

[jhenderson]

It occurred to me that if we were to implement section mapping for other output styles, e.g. LLVM, or formats (I don't know if that concept applies to COFF/MachO/Wasm etc mind you!), then we probably don't want to print the section mapping when program-headers is specified, except in GNU output style. This implies that the decision on whether to print the section mapping should be down to the dumper layer, not the command-line handling layer. This is very similar to the situation with --symbols/--dyn-symbols for GNU output style, and I suspect the solution should be essentially the same as rL351960.

llvm/test/tools/llvm-readobj/gnu-phdrs.test

17–18

I'm not sure you need this test case, as it is identical to the previous one essentially. llvm-readobj --elf-output-style=GNU and llvm-readelf are essentially identical (ignoring certain unrelated switch interpretations and aliases).

19–20

What is this check giving us that's different to the one on line 13?

26

Using grep in lit has been deprecated, I believe. Use FileCheck CHECK-NOT patterns.

You can do the checking that the program headers are not present at the same time as the section mapping test, by using careful placement of the NOT patterns. NOT patterns fail if the output appears between the two positive checks either side of the NOT (or the start/end of file if there are none before/after it). Example that would fail if "Program Headers:" appears before or after the section mapping:

CHECK-NOT: Program Headers:
CHECK: Mapping
CHECK-NOT: Program Headers:

You can even use check-prefixes to share check patterns in a mix-and-match kind of way to avoid duplicating common things. All the names get added to one big bucket. When FileCheck scans the file for patterns it uses any with a matching prefix, in sequence, regardless of which prefix (i.e. the order of prefixes in the option is irrelevant).

For example, for the following case, using FileCheck --check-prefixes=NO-PHDRS,CHECK would be the equivalent of the above test case, whilst FileCheck --check-prefixes=PHDRS,CHECK or FileCheck --check-prefixes=CHECK,PHDRS would match the program headers followed by the mapping. I think you could even use FileCheck --check-prefixes=NO-PHDRS,CHECK,PHDRS to show that the Program Headers appear followed by the mapping, but that no more program headers appear after the mapping (I'm not quite sure whether the first NO-PHDRS-NOT would have any effect in this case though).

NO-PHDRS-NOT: Program Headers:
PHDRS: Program Headers:
CHECK: Mapping
NO-PHDRS-NOT: Program Headers:

[grimar]

llvm/test/tools/llvm-readobj/gnu-phdrs.test

26

Using grep in lit has been deprecated, I believe. Use FileCheck CHECK-NOT patterns.

Oh, I wanted to write the same comment at first but found that grep is also used in LLVM. I did not realize it is deprecated, supposed we just use both ways.

[jhenderson]

llvm/test/tools/llvm-readobj/gnu-phdrs.test

26

I found the reference in the testing documentation:

The recommended way to examine output to figure out if the test passes is using the FileCheck tool. [The usage of grep in RUN lines is deprecated - please do not send or commit patches that use it.]

[mattd]

llvm/test/tools/llvm-readobj/gnu-phdrs.test

17–18

I understand the differences between the two tools, I just wanted to test the output. It agree it does feel a bit redundant.

19–20

Since ELF32 is a single prefix, the order of the output, the headers immediately followed by the mapping, is checked. I want to check the case where both options -section-mapping -program-headers is presented, to ensure that the headers are still displayed before the mapping.

26

When FileCheck scans the file for patterns it uses any with a matching prefix, in sequence, regardless of which prefix (i.e. the order of prefixes in the option is irrelevant).

Yep, that's what I meant in my patch description when I mentioned that the order of the prefixes is not respected. I tested that by just swapping the order of the arguments to the --check-prefixes=PHDRS,MAPPINGS and --check-prefixes=MAPPINGS,PHDRS.

Using grep in lit has been deprecated, I believe. Use FileCheck CHECK-NOT patterns.

Thanks for pointing the grep deprecation out! Honestly, when I was updating this patch, I just grepped around the source code looking for instances of "RUN.*grep" to see if my run-line looked correct. Since I found similar implementations, I ran with it. I'll update to CHECK-NOT Grepping for "grep" is rather satisfying.

[mattd]

• Removed a test
• Replaced the uses of grep in the tests with CHECK-NOT and CHECK-COUNT

[mattd]

In D57365#1376848, @jhenderson wrote:

It occurred to me that if we were to implement section mapping for other output styles, e.g. LLVM, or formats (I don't know if that concept applies to COFF/MachO/Wasm etc mind you!), then we probably don't want to print the section mapping when program-headers is specified, except in GNU output style. This implies that the decision on whether to print the section mapping should be down to the dumper layer, not the command-line handling layer. This is very similar to the situation with --symbols/--dyn-symbols for GNU output style, and I suspect the solution should be essentially the same as rL351960.

I agree, I'll look at making this change in this patch. Thanks for the suggestion.

[mattd]

• I took a hint and decided to more the decision to print the section mapping with the program headers down into the dumper classes. This is similar to how the printSymbols and printDynamicSymbols are handled.

• I decided to pass the cl::boolOrDefault value down to the dumpers. As the GNU dumper will use this to dump the section mapping in the default or 'true' case. Where as the LLVM dumper will only dump the section mapping if the flag is 'true.' However, the LLVM section mapping dump is not yet implemented. That functionality should be added in a separate patch.

[jhenderson]

llvm/test/tools/llvm-readobj/gnu-phdrs.test

21–24

You can combine these two into a single test, by using --implicit-check-not which I'd forgotten about until now. Just do the following:

RUN: llvm-readelf -section-mapping %p/Inputs/phdrs-elf.exe-x86_64 \
RUN:   --implicit-check-not="Program Headers:" | FileCheck %s -check-prefix ELF64-MAPPING

27–30

Same as above, but with --implicit-check-not="Section to Segment mapping".

94–95

I didn't know about CHECK-COUNT before, but my reading of the documentation is that this doesn't prevent further matches after this. You'll need a CHECK-NOT pattern after it (in which case, you don't need the COUNT).

llvm/tools/llvm-readobj/ELFDumper.cpp

158

Do you need this? I think it's dead code.

344

Can you remove this?

379

This could be private.

473

This could be private, or even not exist.

3271–3272

Nit: looks like you manually wrapped this comment rather than let clang-format do, and the first line ends unnecessarily early.

4453–4454

Given we don't currently support section mapping in LLVM style, does it make sense to have this here?

[mattd]

• Update two tests to use FileChecks --implicit-check-not
• Remove some cruft that, I think, was in an earlier version of this patch.
• Update the CHECK-COUNT test to simply perform a CHECK followed by a CHECK-NOT.

llvm/test/tools/llvm-readobj/gnu-phdrs.test

21–24

Ah,interesting, I was unfamiliar with this option! Thanks for the tip.

llvm/tools/llvm-readobj/ELFDumper.cpp

4453–4454

We don't need it, I anticipate we will eventually provide a definition to LLVMStyle<ELFT>::printSectionMapping. To me, the function feels incomplete if we take a parameter and do nothing with it. Additionally, I fear the annoyance of compiler warning messages about unused formal parameters.... if anyone is building this with -Wunused-parameter.

[jhenderson]

Aside from the unnecessary pure virtual base class method for printSectionMapping, I think this is good to go. I'd like @rupprecht or @grimar to take another look though.

llvm/tools/llvm-readobj/ELFDumper.cpp

344

Ping? I don't think you need this in the base class interface - it doesn't need to exist as the section mapping printing is a detail of the program header printing, so it probably should be removed.

4453–4454

You can always comment out the name, but I'm okay leaving it in.

[grimar]

I have only a 2 minor nits. Maybe @rupprecht has more to add.

llvm/test/tools/llvm-readobj/gnu-phdrs.test

16

nit: I suggest to follow the style of the previous line. I.e. place all arguments on the first line and FileCheck on the second.
(it is just a bit easier to read things when they are consistent):

RUN: llvm-readobj -program-headers %p/Inputs/phdrs-elf.exe-x86_64 --elf-output-style=GNU \
RUN:   | FileCheck %s -check-prefixes ELF64-PHDRS,ELF64-MAPPING

llvm/tools/llvm-readobj/ELFDumper.cpp

489

I would group override methods together.

[rupprecht]

No additional concerns from me

[mattd]

llvm/tools/llvm-readobj/ELFDumper.cpp

344

My bad, that should not have been in the current patch. I had marked it done, I'll make sure it doesn't show up when I land this, thanks.

llvm/test/tools/llvm-readobj/gnu-phdrs.test

 #Source :
 #__thread int a = 1;
 #__thread int b;
 #
 #int main () {
 #  b = 2;
 #  throw (a + b) ;
 #  return 0;
 #}
 # compiled as clang++ source.cpp
 # and  clang++ -m32 source.cpp
 
 RUN: llvm-readobj -program-headers %p/Inputs/phdrs-elf.exe-i386 --elf-output-style=GNU \
 RUN:   | FileCheck %s -check-prefix ELF32
 RUN: llvm-readobj -program-headers %p/Inputs/phdrs-elf.exe-x86_64 \
-RUN:  --elf-output-style=GNU | FileCheck %s -check-prefix ELF64
+RUN:   --elf-output-style=GNU | FileCheck %s -check-prefixes ELF64-PHDRS,ELF64-MAPPING
+RUN: llvm-readelf -program-headers %p/Inputs/phdrs-elf.exe-x86_64 \
+RUN:   | FileCheck %s -check-prefixes ELF64-PHDRS,ELF64-MAPPING
+
+# Check that -section-mapping produces a mapping and not the program headers.
+RUN: llvm-readelf -section-mapping %p/Inputs/phdrs-elf.exe-x86_64 \
+RUN:   | FileCheck %s -check-prefix ELF64-MAPPING -implicit-check-not="Program Headers:"
+
+# Check that -section-mapping=false -program-headers produces just program headers.
+RUN: llvm-readelf -section-mapping=false -program-headers %p/Inputs/phdrs-elf.exe-x86_64 \
+RUN:   | FileCheck %s -check-prefix ELF64-PHDRS -implicit-check-not="Section to Segment mapping:"
+
+# Check that only one copy of the section/segment mapping table is produced.
+RUN: llvm-readelf -section-mapping -program-headers %p/Inputs/phdrs-elf.exe-x86_64 \
+RUN:   | FileCheck %s -check-prefix ELF64-ONEMAPPING
 
 ELF32: Elf file type is EXEC (Executable file)
 ELF32-NEXT: Entry point 0x8048460
 ELF32-NEXT: There are 10 program headers, starting at offset 52
 
 ELF32: Program Headers:
 ELF32-NEXT:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
 ELF32-NEXT:   PHDR           0x000034 0x08048034 0x08048034 0x00140 0x00140 R E 0x4

 ELF32-NEXT:    03     .tdata .ctors .dtors .jcr .dynamic .got .got.plt .data .bss
 ELF32-NEXT:    04     .dynamic
 ELF32-NEXT:    05     .note.ABI-tag .note.gnu.build-id
 ELF32-NEXT:    06     .tdata .tbss
 ELF32-NEXT:    07     .eh_frame_hdr
 ELF32-NEXT:    08
 ELF32-NEXT:    09     .tdata .ctors .dtors .jcr .dynamic .got
 
-ELF64: Elf file type is EXEC (Executable file)
-ELF64-NEXT: Entry point 0x400610
-ELF64-NEXT: There are 10 program headers, starting at offset 64
-
-ELF64: Program Headers:
-ELF64-NEXT:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-ELF64-NEXT:   PHDR           0x000040 0x0000000000400040 0x0000000000400040 0x000230 0x000230 R E 0x8
-ELF64-NEXT:   INTERP         0x000270 0x0000000000400270 0x0000000000400270 0x00001c 0x00001c R   0x1
-ELF64-NEXT:       [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
-ELF64-NEXT:   LOAD           0x000000 0x0000000000400000 0x0000000000400000 0x000924 0x000924 R E 0x200000
-ELF64-NEXT:   LOAD           0x000db4 0x0000000000600db4 0x0000000000600db4 0x000274 0x0002a4 RW  0x200000
-ELF64-NEXT:   DYNAMIC        0x000dd0 0x0000000000600dd0 0x0000000000600dd0 0x000210 0x000210 RW  0x8
-ELF64-NEXT:   NOTE           0x00028c 0x000000000040028c 0x000000000040028c 0x000044 0x000044 R   0x4
-ELF64-NEXT:   TLS            0x000db4 0x0000000000600db4 0x0000000000600db4 0x000004 0x000008 R   0x4
-ELF64-NEXT:   GNU_EH_FRAME   0x00083c 0x000000000040083c 0x000000000040083c 0x00002c 0x00002c R   0x4
-ELF64-NEXT:   GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x8
-ELF64-NEXT:   GNU_RELRO      0x000db4 0x0000000000600db4 0x0000000000600db4 0x00024c 0x00024c R   0x1
-
-ELF64:  Section to Segment mapping:
-ELF64-NEXT:   Segment Sections...
-ELF64-NEXT:    00
-ELF64-NEXT:    01     .interp
-ELF64-NEXT:    02     .interp .note.ABI-tag .note.gnu.build-id .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
-ELF64-NEXT:    03     .tdata .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss
-ELF64-NEXT:    04     .dynamic
-ELF64-NEXT:    05     .note.ABI-tag .note.gnu.build-id
-ELF64-NEXT:    06     .tdata .tbss
-ELF64-NEXT:    07     .eh_frame_hdr
-ELF64-NEXT:    08
-ELF64-NEXT:    09     .tdata .init_array .fini_array .jcr .dynamic .got
+ELF64-PHDRS: Elf file type is EXEC (Executable file)
+ELF64-PHDRS-NEXT: Entry point 0x400610
+ELF64-PHDRS-NEXT: There are 10 program headers, starting at offset 64
+
+ELF64-PHDRS: Program Headers:
+ELF64-PHDRS-NEXT:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+ELF64-PHDRS-NEXT:   PHDR           0x000040 0x0000000000400040 0x0000000000400040 0x000230 0x000230 R E 0x8
+ELF64-PHDRS-NEXT:   INTERP         0x000270 0x0000000000400270 0x0000000000400270 0x00001c 0x00001c R   0x1
+ELF64-PHDRS-NEXT:       [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
+ELF64-PHDRS-NEXT:   LOAD           0x000000 0x0000000000400000 0x0000000000400000 0x000924 0x000924 R E 0x200000
+ELF64-PHDRS-NEXT:   LOAD           0x000db4 0x0000000000600db4 0x0000000000600db4 0x000274 0x0002a4 RW  0x200000
+ELF64-PHDRS-NEXT:   DYNAMIC        0x000dd0 0x0000000000600dd0 0x0000000000600dd0 0x000210 0x000210 RW  0x8
+ELF64-PHDRS-NEXT:   NOTE           0x00028c 0x000000000040028c 0x000000000040028c 0x000044 0x000044 R   0x4
+ELF64-PHDRS-NEXT:   TLS            0x000db4 0x0000000000600db4 0x0000000000600db4 0x000004 0x000008 R   0x4
+ELF64-PHDRS-NEXT:   GNU_EH_FRAME   0x00083c 0x000000000040083c 0x000000000040083c 0x00002c 0x00002c R   0x4
+ELF64-PHDRS-NEXT:   GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x8
+ELF64-PHDRS-NEXT:   GNU_RELRO      0x000db4 0x0000000000600db4 0x0000000000600db4 0x00024c 0x00024c R   0x1
+
+ELF64-MAPPING:  Section to Segment mapping:
+ELF64-MAPPING-NEXT:   Segment Sections...
+ELF64-MAPPING-NEXT:    00
+ELF64-MAPPING-NEXT:    01     .interp
+ELF64-MAPPING-NEXT:    02     .interp .note.ABI-tag .note.gnu.build-id .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
+ELF64-MAPPING-NEXT:    03     .tdata .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss
+ELF64-MAPPING-NEXT:    04     .dynamic
+ELF64-MAPPING-NEXT:    05     .note.ABI-tag .note.gnu.build-id
+ELF64-MAPPING-NEXT:    06     .tdata .tbss
+ELF64-MAPPING-NEXT:    07     .eh_frame_hdr
+ELF64-MAPPING-NEXT:    08
+ELF64-MAPPING-NEXT:    09     .tdata .init_array .fini_array .jcr .dynamic .got
+
+ELF64-ONEMAPPING: Section to Segment mapping:
+ELF64-ONEMAPPING-NOT: Section to Segment mapping:

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   void printRelocations() override;
   void printDynamicRelocations() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printHashSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
-  void printProgramHeaders() override;
+  void printProgramHeaders(bool PrintProgramHeaders,
+                           cl::boolOrDefault PrintSectionMapping) override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
   void printGroupSections() override;
 
   void printAttributes() override;
   void printMipsPLTGOT() override;
   void printMipsABIFlags() override;
virtual void printSymbols(const ELFFile<ELFT> *Obj, bool PrintSymbols,
                             bool PrintDynamicSymbols) = 0;
   virtual void printHashSymbols(const ELFFile<ELFT> *Obj) {}
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *Obj, StringRef Name,
                                   size_t Offset) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
                            bool IsDynamic) = 0;
-  virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0;
+  virtual void printProgramHeaders(const ELFFile<ELFT> *Obj,
+                                   bool PrintProgramHeaders,
+                                   cl::boolOrDefault PrintSectionMapping) = 0;
+  virtual void printSectionMapping(const ELFFile<ELFT> *Obj) = 0;
   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
   virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0;
   virtual void printAddrsig(const ELFFile<ELFT> *Obj) = 0;
   virtual void printNotes(const ELFFile<ELFT> *Obj) = 0;
   virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
   const ELFDumper<ELFT> *dumper() const { return Dumper; }
public:
   void printRelocations(const ELFO *Obj) override;
   void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj, bool PrintSymbols,
                     bool PrintDynamicSymbols) override;
   void printHashSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printSymtabMessage(const ELFO *Obj, StringRef Name,
                           size_t Offset) override;
-  void printProgramHeaders(const ELFO *Obj) override;
+  void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders,
+                           cl::boolOrDefault PrintSectionMapping) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    StringRef StrTable, bool IsDynamic) override;
   std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
                                   const Elf_Sym *FirstSym);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
   bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
+  void printProgramHeaders(const ELFO *Obj);
+  void printSectionMapping(const ELFO *Obj) override;
 };
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
 
   LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
       : DumpStyle<ELFT>(Dumper), W(W) {}
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
   void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj, bool PrintSymbols,
                     bool PrintDynamicSymbols) override;
   void printDynamicRelocations(const ELFO *Obj) override;
-  void printProgramHeaders(const ELFO *Obj) override;
+  void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders,
+                           cl::boolOrDefault PrintSectionMapping) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
   void printSymbols(const ELFO *Obj);
   void printDynamicSymbols(const ELFO *Obj);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    StringRef StrTable, bool IsDynamic) override;
+  void printProgramHeaders(const ELFO *Obj);
+  void printSectionMapping(const ELFO *Obj) override {}
 
   ScopedPrinter &W;
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
void ELFDumper<ELFT>::printSectionHeaders() {
   ELFDumperStyle->printSectionHeaders(ObjF->getELFFile());
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printRelocations() {
   ELFDumperStyle->printRelocations(ObjF->getELFFile());
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
-  ELFDumperStyle->printProgramHeaders(ObjF->getELFFile());
+template <class ELFT>
+void ELFDumper<ELFT>::printProgramHeaders(
+    bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) {
+  ELFDumperStyle->printProgramHeaders(ObjF->getELFFile(), PrintProgramHeaders,
+                                      PrintSectionMapping);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
   ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile());
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printSymbols(bool PrintSymbols,
bool GNUStyle<ELFT>::checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
   return ((Sec.sh_type == ELF::SHT_NOBITS) ||
           (Sec.sh_offset > Phdr.p_offset &&
            Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz)) &&
          (!(Sec.sh_flags & ELF::SHF_ALLOC) ||
           (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz));
 }
 
 template <class ELFT>
+void GNUStyle<ELFT>::printProgramHeaders(
+    const ELFO *Obj, bool PrintProgramHeaders,
+    cl::boolOrDefault PrintSectionMapping) {
+  if (PrintProgramHeaders)
+    printProgramHeaders(Obj);
+
+  // Display the section mapping along with the program headers, unless
+  // -section-mapping is explicitly set to false.
+  if (PrintSectionMapping != cl::BOU_FALSE)
+    printSectionMapping(Obj);
+}
+
+template <class ELFT>
 void GNUStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   const Elf_Ehdr *Header = Obj->getHeader();
   Field Fields[8] = {2,         17,        26,        37 + Bias,
                      48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias};
   OS << "\nElf file type is "
      << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n"
      << "Entry point " << format_hex(Header->e_entry, 3) << "\n"
for (const auto &Phdr : unwrapOrError(Obj->program_headers())) {
     for (auto Field : Fields)
       printField(Field);
     if (Phdr.p_type == ELF::PT_INTERP) {
       OS << "\n      [Requesting program interpreter: ";
       OS << reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset << "]";
     }
     OS << "\n";
   }
+}
+
+template <class ELFT>
+void GNUStyle<ELFT>::printSectionMapping(const ELFO *Obj) {
   OS << "\n Section to Segment mapping:\n  Segment Sections...\n";
   int Phnum = 0;
   for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
     std::string Sections;
     OS << format("   %2.2d     ", Phnum++);
     for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
       // Check if each section is in a segment and then print mapping.
       // readelf additionally makes sure it does not print zero sized sections
if (opts::ExpandRelocs) {
     raw_ostream &OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
        << (!SymbolName.empty() ? SymbolName : "-") << " "
        << W.hex(Rel.r_addend) << "\n";
   }
 }
 
 template <class ELFT>
+void LLVMStyle<ELFT>::printProgramHeaders(
+    const ELFO *Obj, bool PrintProgramHeaders,
+    cl::boolOrDefault PrintSectionMapping) {
+  if (PrintProgramHeaders)
+    printProgramHeaders(Obj);
+  if (PrintSectionMapping == cl::BOU_TRUE)
+    printSectionMapping(Obj);
+}
+
+template <class ELFT>
 void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
   ListScope L(W, "ProgramHeaders");
 
   for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
     DictScope P(W, "ProgramHeader");
     W.printHex("Type",
                getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
                Phdr.p_type);

llvm/tools/llvm-readobj/ObjDumper.h

 //===-- ObjDumper.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_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 
 #include <memory>
 #include <system_error>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
 }
 namespace codeview {
 class MergingTypeTableBuilder;
public:
   virtual void printSectionHeaders() = 0;
   virtual void printRelocations() = 0;
   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
     if (PrintSymbols)
       printSymbols();
     if (PrintDynamicSymbols)
       printDynamicSymbols();
   }
+  virtual void printProgramHeaders(bool PrintProgramHeaders,
+                                   cl::boolOrDefault PrintSectionMapping) {
+    if (PrintProgramHeaders)
+      printProgramHeaders();
+    if (PrintSectionMapping == cl::BOU_TRUE)
+      printSectionMapping();
+  }
+
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
-  virtual void printProgramHeaders() { }
   virtual void printSectionAsHex(StringRef SectionName) {}
   virtual void printHashTable() { }
   virtual void printGnuHashTable() { }
   virtual void printHashSymbols() {}
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistogram() {}
public:
 
   void printSectionAsString(const object::ObjectFile *Obj, StringRef SecName);
   void printSectionAsHex(const object::ObjectFile *Obj, StringRef SecName);
 
 protected:
   ScopedPrinter &W;
 
 private:
-  virtual void printSymbols() {};
-  virtual void printDynamicSymbols() {};
+  virtual void printSymbols() {}
+  virtual void printDynamicSymbols() {}
+  virtual void printProgramHeaders() {}
+  virtual void printSectionMapping() {}
 };
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,
                                  std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 ScopedPrinter &Writer,

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

namespace opts {
   cl::opt<bool> SectionSymbols("section-symbols",
     cl::desc("Display symbols for each section shown."));
 
   // -section-data
   // Also -sd in llvm-readobj mode.
   cl::opt<bool> SectionData("section-data",
     cl::desc("Display section data for each section shown."));
 
+  // -section-mapping
+  cl::opt<cl::boolOrDefault>
+      SectionMapping("section-mapping",
+                     cl::desc("Display the section to segment mapping."));
+
   // -relocations, -relocs, -r
   cl::opt<bool> Relocations("relocations",
     cl::desc("Display the relocation entries in the file"));
   cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
                              cl::aliasopt(Relocations), cl::NotHidden);
   cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
                            cl::aliasopt(Relocations));
 
Writer.printString("Arch", Triple::getArchTypeName(
                                    (llvm::Triple::ArchType)Obj->getArch()));
     Writer.printString("AddressSize",
                        formatv("{0}bit", 8 * Obj->getBytesInAddress()));
     Dumper->printLoadName();
   }
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
   if (opts::SectionHeaders)
     Dumper->printSectionHeaders();
   if (opts::Relocations)
     Dumper->printRelocations();
   if (opts::DynRelocs)
     Dumper->printDynamicRelocations();
   if (opts::Symbols || opts::DynamicSymbols)
     Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols);
   if (opts::HashSymbols)
     Dumper->printHashSymbols();
   if (opts::UnwindInfo)
     Dumper->printUnwindInfo();
   if (opts::DynamicTable)
     Dumper->printDynamicTable();
   if (opts::NeededLibraries)
     Dumper->printNeededLibraries();
-  if (opts::ProgramHeaders)
-    Dumper->printProgramHeaders();
+  if (opts::ProgramHeaders || opts::SectionMapping == cl::BOU_TRUE)
+    Dumper->printProgramHeaders(opts::ProgramHeaders, opts::SectionMapping);
   if (!opts::StringDump.empty())
     llvm::for_each(opts::StringDump, [&Dumper, Obj](StringRef SectionName) {
       Dumper->printSectionAsString(Obj, SectionName);
     });
   if (!opts::HexDump.empty())
     llvm::for_each(opts::HexDump, [&Dumper, Obj](StringRef SectionName) {
       Dumper->printSectionAsHex(Obj, SectionName);
     });