[llvm-readelf] - Do not crash when the PT_INTERP has an invalid offset.

[grimar]

Summary

We do not verify the p_offset of the PT_INTERP header and tool may
crash when a program interpreter name string goes past the end of the file.

Depends on D78805.

[MaskRay]

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

6

Isn't the test covered by ERROR-INTERP2?

llvm/tools/llvm-readobj/ELFDumper.cpp

4154

The two lines can be joined.

[grimar]

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

6

Nope. They have different error messages. In this case the offset points past the EOF. In ERROR-INTERP2 it is withing the file space.

[grimar]

Going to merge 2 tests

[grimar]

• Merged 2 test cases.

[MaskRay]

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

16

The main problem with the test is that if yaml2obj layout is updated, the p_offset fields will need an update which may be a bit tricky. Since the file size is displayed, this is probably fine.

560 = size(Ehdr) + size(Phdrs) + section contents with padding + size(Shdrs) = 64 + 56*5 + alignTo(1+0x13, 8) + 64*3 = 560

[MaskRay]

a broken offset.

an invalid offset

[jhenderson]

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

6

used in the YAML below.

16

You could improve things slightly with a bit of cleverness in FileCheck, although I don't know whether it's a good idea. I think it should work as described, possibly with a few tweaks:

Firstly, emit the wc output to a file, and concatenate the llvm-readelf program header dump to the same file. Then, use FileCheck's numeric variables to capture the size and re-use it:

# RUN: wc -c < %t.err > %t.err.out
# RUN: FileCheck %s --check-prefix=SIZE --input-file=%t.err.out
# SIZE: 560
## Optionally use echo to add some extra data here that you can check to avoid matching something else.

## Write the additional 'C', '\0, 'C' bytes to the end.
# RUN: echo -n -e "C\x00C" >> %t.err

# RUN: llvm-readelf --program-headers %t.err 2>&1 >> %t.err.out
# RUN: FileCheck %s --input-file=%t.err.out -DFILE=%t.err --check-prefix=ERROR-INTERP

# ERROR-INTERP: [[#SIZE:]]
## If you add the extra data, check it here.
# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         [[#SIZE]]
# ERROR-INTERP-NEXT:     [Requesting program interpreter: C]
# ERROR-INTERP-NEXT: INTERP         [[#SIZE+1]]
# ERROR-INTERP-NEXT:     [Requesting program interpreter: ]

and so on.

This has the benefit of only needing to change the YAML and one single check, should the layout change. You could even avoid the file concatenation etc by just capturing the variable based on the first INTERP's offset, if you want.

39

is a null

llvm/tools/llvm-readobj/ELFDumper.cpp

4132

Maybe rename to ReportBadInterp or something. ReportError is a bit confusing when it's not an error!

[grimar]

• Addressed review comments.

[grimar]

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

16

You could even avoid the file concatenation etc by just capturing the variable based on the first INTERP's offset, if you want.

This looks good I think. Thanks for suggestion!
I've updated the test.

[grimar]

• Rebase properly.

[jhenderson]

LGTM, with one remaining request.

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

17

I believe you don't want the leading 0x000 bit, and then you also won't need the %x either. I believe FileCheck will automatically recognise it as hex that way (as things stand, I think it might not, but can't remember the details). If you want ot be sure that it is hex though, you can keep the %x (and might need it in the lines below too to be sure its always hex, but I'm not sure - experimentation needed). FWIW, I don't think it being hex is a necessary check for this specific case, since we check it earlier.

[grimar]

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

17

I believe you don't want the leading 0x000 bit, and then you also won't need the %x either.

It does not work for me, this was the only way I've managed to make this work.

The following fail:

# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         [[#OFFSET:]]
# ERROR-INTERP-NEXT:     [Requesting program interpreter: C]
# ERROR-INTERP-NEXT: INTERP         [[#OFFSET + 1]]
# ERROR-INTERP-NEXT:     [Requesting program interpreter: ]

D:\Work3\LLVM\llvm-project\llvm\test\tools\llvm-readobj\ELF\gnu-phdrs.test:324:2
2: error: ERROR-INTERP-NEXT: expected string not found in input
# ERROR-INTERP-NEXT: INTERP [[#OFFSET + 1]]
                     ^
<stdin>:10:2: note: scanning from here
 INTERP 0x000231 0x0000000000000000 0x0000000000000000 0x000000 0x000000 0x1
 ^
<stdin>:10:2: note: with "OFFSET + 1" equal to "1"
 INTERP 0x000231 0x0000000000000000 0x0000000000000000 0x000000 0x000000 0x1
 ^

[jhenderson]

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

17

Ah, okay, I guess the 0x is not cosnidered part of the numeric pattern and the default only reads decimal. @thopre, is that correct?

Anyway, from my experiments the leading zeroes can be included, and please specify '%x' explicitly in the definition.

22

Don't forget to update 0x232 to 0x[[#OFFSET+2]] and similar in the messages below.

[grimar]

• Addressed comments in according to latest discussion. (I am not sure I got everything right).

(It still depends on D78805.)

I am leaving on vacation until 12 of May.

[grimar]

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

17

Just in case to confirm that my understanding about "leading zeroes" was correct here,
here is a result of my experiments:

The following works:

# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         0x000[[#%x,OFFSET:0x230]]

# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         0x000[[#%x,OFFSET:0x000230]]

The following doesn't:

# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         0x[[#%x,OFFSET:0x230]]

# ERROR-INTERP:      Type           Offset
# ERROR-INTERP-NEXT: INTERP         0x[[#%x,OFFSET:230]]

So we need the "0x000[[" part, but do not need leading zeroes for OFFSET.

[grimar]

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

22

Don't forget to update 0x232 to 0x[[#OFFSET+2]] and similar in the messages below.

Now I am not sure we want it. I guess it will accept both 0x0000000000232 and just 0x232, does not seem we want it.

[jhenderson]

LGTM, with the two error message fixes. I'd appreciate @thopre's input on the numeric variable usage too, but that shouldn't block this landing.

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

17

I missed the bit where you were explicitly specifying the value to capture and didn't replicate it in my own experiments properly. I'm at a loss here. The problem is that if the layout changes to have fewer (or more) leading zeroes, it will fail due to that.

That seems to be missing the point of numeric variables. Leading zeroes should be able to be included in the match.

24

Can you not get rid of the %x in all the usages? I thought that should be derived from the definition of OFFSET if unspecified and only needed specifying if different from the original.

Also, there are still two instances of explicit "0x233" in these messages.

[jhenderson]

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

22

I think it's okay for either. I don't think it matters whether we have leading zeroes or not in the error messages, personally. Also, as we've seen above, the leading zeroes aren't matched anyway, right? ;)

[grimar]

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

22

Also, as we've seen above, the leading zeroes aren't matched anyway, right? ;)

Right. I've just confused myself.

[grimar]

Changes Planned -> Accepted, since it was accepted. Will commit shortly with requested changes.

[thopre]

In D79013#2014703, @jhenderson wrote:

LGTM, with the two error message fixes. I'd appreciate @thopre's input on the numeric variable usage too, but that shouldn't block this landing.

%x and %X deliberately don't match the 0x0* prefix to allow:

• matching plain hex number without 0x prefix
• testing the actual number of leading zeros in case a tool use leading zero to align numbers for instance

It might be useful to introduce a precision syntax a la printf to specify how many leading zeros are allowed, as well as a --canonicalize-numvar-leading-zero or better named option which would allow matching as many leading zeros. Leading zeros are allowed in immediates though since that has no impact on what is matched, hence why #FOO+0x00018 is allowed.

Let me know if you need further clarification.

[grimar]

Was committed as 0d54612164519c874eecf5a1be68597b96410628, phab did not close it for some reason. And does not allow me to close it normally.

[grimar]

• Close it normally.

llvm/test/tools/llvm-readobj/ELF/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-readelf -l %p/Inputs/phdrs-elf.exe-i386 \
-RUN:   | FileCheck %s -check-prefix ELF32
-RUN: llvm-readelf -l %p/Inputs/phdrs-elf.exe-x86_64 \
-RUN:   | 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:   INTERP         0x000174 0x08048174 0x08048174 0x00013 0x00013 R   0x1
-ELF32-NEXT:       [Requesting program interpreter: /lib/ld-linux.so.2]
-ELF32-NEXT:   LOAD           0x000000 0x08048000 0x08048000 0x006d0 0x006d0 R E 0x1000
-ELF32-NEXT:   LOAD           0x000ef0 0x08049ef0 0x08049ef0 0x00128 0x00140 RW  0x1000
-ELF32-NEXT:   DYNAMIC        0x000f08 0x08049f08 0x08049f08 0x000e8 0x000e8 RW  0x4
-ELF32-NEXT:   NOTE           0x000188 0x08048188 0x08048188 0x00044 0x00044 R   0x4
-ELF32-NEXT:   TLS            0x000ef0 0x08049ef0 0x08049ef0 0x00004 0x00008 R   0x4
-ELF32-NEXT:   GNU_EH_FRAME   0x000640 0x08048640 0x08048640 0x0001c 0x0001c R   0x4
-ELF32-NEXT:   GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x4
-ELF32-NEXT:   GNU_RELRO      0x000ef0 0x08049ef0 0x08049ef0 0x00110 0x00110 R   0x1
-
-ELF32:  Section to Segment mapping:
-ELF32-NEXT:   Segment Sections...
-ELF32-NEXT:    00
-ELF32-NEXT:    01     .interp
-ELF32-NEXT:    02     .interp .note.ABI-tag .note.gnu.build-id .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
-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
-ELF32-NEXT:    None   .comment .shstrtab .symtab .strtab
-
-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-MAPPING-NEXT:    None   .comment .shstrtab .symtab .strtab
+## Check how llvm-readelf dumps program headers and prints sections to segments mapping.
 
-ELF64-ONEMAPPING: Section to Segment mapping:
-ELF64-ONEMAPPING-NOT: Section to Segment mapping:
+## Check that -l, --program-headers and --segments are the same option.
+# RUN: yaml2obj --docnum=1 -DBITS=32 -DMACHINE=EM_386 %s -o %t32.elf
+# RUN: llvm-readelf -l %t32.elf 2>&1 > %t.readelf-l.txt
+# RUN: llvm-readelf --program-headers %t32.elf 2>&1 > %t.readelf-pheaders.txt
+# RUN: cmp %t.readelf-l.txt %t.readelf-pheaders.txt
+# RUN: llvm-readelf --segments %t32.elf 2>&1 > %t.readelf-segments.txt
+# RUN: cmp %t.readelf-l.txt %t.readelf-segments.txt
+
+## Check we are able to print program headers of different types.
+# RUN: llvm-readelf -l %t32.elf | \
+# RUN:   FileCheck %s --check-prefixes=ELF32,MAPPING --strict-whitespace --match-full-lines
+
+# RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_X86_64 %s -o %t64.elf
+# RUN: llvm-readelf -l %t64.elf | \
+# RUN:   FileCheck %s --check-prefixes=ELF64,MAPPING --strict-whitespace --match-full-lines
+
+#       ELF32:There are 23 program headers, starting at offset 52
+# ELF32-EMPTY:
+# ELF32-NEXT:Program Headers:
+# ELF32-NEXT:  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# ELF32-NEXT:  PHDR           0x000314 0x00001000 0x00001000 0x00003 0x00003  W  0x1
+# ELF32-NEXT:  PHDR           0x000317 0x00002000 0x00002000 0x00007 0x00007   E 0x1
+# ELF32-NEXT:  NULL           0x000317 0x00002000 0x00002000 0x00007 0x00007   E 0x1
+# ELF32-NEXT:  DYNAMIC        0x000314 0x00001000 0x00001000 0x00003 0x00003 RWE 0x1
+# ELF32-NEXT:  INTERP         0x00031e 0x00003000 0x00003000 0x00004 0x00004 RW  0x1
+# ELF32-NEXT:      [Requesting program interpreter: ABC]
+# ELF32-NEXT:  NOTE           0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  SHLIB          0x000314 0x00001000 0x00001000 0x00001 0x00001     0x1
+# ELF32-NEXT:  TLS            0x000322 0x00004000 0x00004000 0x00001 0x00001     0x1
+# ELF32-NEXT:  <unknown>: 0x60000000 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  GNU_EH_FRAME   0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  SUNW_UNWIND    0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  GNU_STACK      0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  GNU_RELRO      0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  GNU_PROPERTY   0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x65a3dbe6 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x65a3dbe7 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x65a41be6 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x6fffffff 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x70000000 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x70000001 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x70000002 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x70000003 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-NEXT:  <unknown>: 0x7fffffff 0x000314 0x00001000 0x00001000 0x00003 0x00003     0x1
+# ELF32-EMPTY:
+
+#       ELF64:There are 23 program headers, starting at offset 64
+# ELF64-EMPTY:
+# ELF64-NEXT:Program Headers:
+# ELF64-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# ELF64-NEXT:  PHDR           0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003  W  0x1
+# ELF64-NEXT:  PHDR           0x00054b 0x0000000000002000 0x0000000000002000 0x000007 0x000007   E 0x1
+# ELF64-NEXT:  NULL           0x00054b 0x0000000000002000 0x0000000000002000 0x000007 0x000007   E 0x1
+# ELF64-NEXT:  DYNAMIC        0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 RWE 0x1
+# ELF64-NEXT:  INTERP         0x000552 0x0000000000003000 0x0000000000003000 0x000004 0x000004 RW  0x1
+# ELF64-NEXT:      [Requesting program interpreter: ABC]
+# ELF64-NEXT:  NOTE           0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  SHLIB          0x000548 0x0000000000001000 0x0000000000001000 0x000001 0x000001     0x1
+# ELF64-NEXT:  TLS            0x000556 0x0000000000004000 0x0000000000004000 0x000001 0x000001     0x1
+# ELF64-NEXT:  <unknown>: 0x60000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  GNU_EH_FRAME   0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  SUNW_UNWIND    0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  GNU_STACK      0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  GNU_RELRO      0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  GNU_PROPERTY   0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x65a3dbe6 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x65a3dbe7 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x65a41be6 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x6fffffff 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x70000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x70000001 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x70000002 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x70000003 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-NEXT:  <unknown>: 0x7fffffff 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003     0x1
+# ELF64-EMPTY:
+
+#      MAPPING: Section to Segment mapping:
+# MAPPING-NEXT:  Segment Sections...
+# MAPPING-NEXT:   00     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   01     .bar.begin .bar.end {{$}}
+# MAPPING-NEXT:   02     .bar.begin .bar.end {{$}}
+# MAPPING-NEXT:   03     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   04     .interp {{$}}
+# MAPPING-NEXT:   05     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   06     .foo.begin {{$}}
+# MAPPING-NEXT:   07     .tls {{$}}
+# MAPPING-NEXT:   08     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   09     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   10     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   11     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   12     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   13     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   14     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   15     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   16     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   17     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   18     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   19     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   20     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   21     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   22     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   None   .unused .strtab .shstrtab {{$}}
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS[[BITS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: [[MACHINE]]
+  Entry:   0x12345678
+Sections:
+  - Name:    .foo.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x1000
+    Size:    0x1
+  - Name:    .foo.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x2
+  - Name:    .bar.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x2000
+    Size:    0x3
+  - Name:    .bar.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x4
+  - Name:    .interp
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x3000
+    Content: "41424300" ## "ABC"
+  - Name:    .tls
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_TLS ]
+    Address: 0x4000
+    Size:    0x1
+  - Name:    .unused
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_TLS ]
+    Address: 0x5000
+    Size:    0x1
+ProgramHeaders:
+## Case 1: an arbitrary segment with sections.
+  - Type:  PT_PHDR
+    Flags: [ PF_W ]
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 2: another segment with different sections.
+  - Type:  PT_PHDR
+    Flags: [ PF_X ]
+    VAddr: 0x2000
+    Sections:
+      - Section: .bar.begin
+      - Section: .bar.end
+## Case 3: the PT_NULL segment.
+  - Type:  PT_NULL
+    Flags: [ PF_X ]
+    VAddr: 0x2000
+    Sections:
+      - Section: .bar.begin
+      - Section: .bar.end
+## Case 4: the PT_DYNAMIC segment.
+  - Type:  PT_DYNAMIC
+    Flags: [ PF_R, PF_W, PF_X ]
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 5: the PT_INTERP segment.
+  - Type:  PT_INTERP
+    Flags: [ PF_R, PF_W ]
+    VAddr: 0x3000
+    Sections:
+      - Section: .interp
+## Case 6: the PT_NOTE segment.
+  - Type: PT_NOTE
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 7: the PT_SHLIB segment.
+  - Type: PT_SHLIB
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+## Case 8: the PT_TLS segment.
+  - Type: PT_TLS
+    VAddr: 0x4000
+    Sections:
+      - Section: .tls
+## Case 9: the PT_LOOS segment.
+  - Type:  0x60000000 ## PT_LOOS
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 10: the PT_GNU_EH_FRAME segment.
+  - Type: PT_GNU_EH_FRAME
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 11: the PT_SUNW_UNWIND segment.
+  - Type: 0x6464e550 ## PT_SUNW_UNWIND
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 12: the PT_GNU_STACK segment.
+  - Type: PT_GNU_STACK
+    Sections:
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 13: the PT_GNU_RELRO segment.
+  - Type: PT_GNU_RELRO
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 14: the PT_GNU_PROPERTY segment.
+  - Type: PT_GNU_PROPERTY
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 15: the PT_OPENBSD_RANDOMIZE segment.
+  - Type: 0x65a3dbe6 ## PT_OPENBSD_RANDOMIZE
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 16: the PT_OPENBSD_WXNEEDED segment.
+  - Type: 0x65a3dbe7 ## PT_OPENBSD_WXNEEDED
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 17: the PT_OPENBSD_BOOTDATA segment.
+  - Type: 0x65a41be6 ## PT_OPENBSD_BOOTDATA
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 18: the PT_HIOS segment.
+  - Type: 0x6fffffff ## PT_HIOS
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 19: the PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO segment.
+  - Type: 0x70000000 ## PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 20: the PT_ARM_EXIDX/PT_MIPS_RTPROC segment.
+  - Type: 0x70000001 ## PT_ARM_EXIDX, PT_MIPS_RTPROC
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 20: the PT_MIPS_OPTIONS segment.
+  - Type: 0x70000002 ## PT_MIPS_OPTIONS
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 21: the PT_MIPS_ABIFLAGS segment.
+  - Type: 0x70000003 ## PT_MIPS_ABIFLAGS
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 22: the PT_HIPROC segment.
+  - Type: 0x7fffffff ## PT_HIPROC
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+
+## Check how we dump ARM specific program headers.
+# RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_ARM %s -o %tarm.elf
+# RUN: llvm-readelf --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM
+
+# ARM:      <unknown>: 0x70000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+# ARM-NEXT:            EXIDX      0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+# ARM-NEXT: <unknown>: 0x70000002 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+
+## Check how we dump MIPS specific program headers.
+# RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_MIPS %s -o %tmips.elf
+# RUN: llvm-readelf --program-headers %tmips.elf | FileCheck %s --check-prefix=MIPS
+
+# MIPS:      REGINFO  0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+# MIPS-NEXT: RTPROC   0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+# MIPS-NEXT: OPTIONS  0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+# MIPS-NEXT: ABIFLAGS 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
+
+## Check we report a warning when a program interpreter name is non-null-terminated or when
+## PT_INTERP has an offset that goes past the end of the file.
+# RUN: yaml2obj --docnum=2 %s -o %t.err
+
+## Show the size of the output produced. It is used in the YAML below.
+# RUN: wc -c < %t.err | FileCheck %s --check-prefix=SIZE
+# SIZE: 560
+
+## Write the additional 'C', '\0, 'C' bytes to the end.
+# RUN: echo -n -e "C\x00C" >> %t.err
+
+# RUN: llvm-readelf --program-headers %t.err 2>&1 | \
+# RUN:   FileCheck %s -DFILE=%t.err --check-prefix=ERROR-INTERP
+
+# ERROR-INTERP:      Type           Offset
+# ERROR-INTERP-NEXT: INTERP         0x000[[#%x,OFFSET:0x000230]]
+# ERROR-INTERP-NEXT:     [Requesting program interpreter: C]
+# ERROR-INTERP-NEXT: INTERP         0x000[[#OFFSET + 1]]
+# ERROR-INTERP-NEXT:     [Requesting program interpreter: ]
+# ERROR-INTERP-NEXT: INTERP         0x000[[#OFFSET + 2]]
+# ERROR-INTERP-NEXT: warning: '[[FILE]]': unable to read program interpreter name at offset 0x232: it is not null-terminated
+# ERROR-INTERP-NEXT: INTERP         0x000[[#OFFSET + 3]]
+# ERROR-INTERP-NEXT: warning: '[[FILE]]': unable to read program interpreter name at offset 0x233: it goes past the end of the file (0x233)
+# ERROR-INTERP-NEXT: INTERP         0xaabbccddeeff1122
+# ERROR-INTERP-NEXT: warning: '[[FILE]]': unable to read program interpreter name at offset 0xaabbccddeeff1122: it goes past the end of the file (0x233)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+ProgramHeaders:
+## Case 1: the offset points to the first additional byte.
+  - Type:   PT_INTERP
+    Offset: 560
+## Case 1: the offset points to the second additional byte,
+##         which is a null byte.
+  - Type:   PT_INTERP
+    Offset: 561
+## Case 3: the offset points to the third additional
+##         byte, which is the last byte in the file.
+  - Type:   PT_INTERP
+    Offset: 562
+## Case 4: the offset goes 1 byte past the end of the file.
+  - Type:   PT_INTERP
+    Offset: 563
+## Case 5: an arbitrary large offset that goes past the end of the file.
+  - Type:   PT_INTERP
+    Offset: 0xAABBCCDDEEFF1122

llvm/test/tools/llvm-readobj/ELF/gnu-section-mapping-no-shdrs.test

-RUN: llvm-objcopy --strip-sections %p/Inputs/phdrs-elf.exe-x86_64 %t.o
-RUN: llvm-readelf --section-mapping %t.o | FileCheck %s
-CHECK:      Section to Segment mapping:
-CHECK-NEXT:   Segment Sections...
-CHECK-NEXT:    00 {{$}}
-CHECK-NEXT:    01 {{$}}
-CHECK-NEXT:    02 {{$}}
-CHECK-NEXT:    03 {{$}}
-CHECK-NEXT:    04 {{$}}
-CHECK-NEXT:    05 {{$}}
-CHECK-NEXT:    06 {{$}}
-CHECK-NEXT:    07 {{$}}
-CHECK-NEXT:    08 {{$}}
-CHECK-NEXT:    09 {{$}}
-CHECK-NOT: {{.}}

llvm/test/tools/llvm-readobj/ELF/gnu-section-mapping.test

+## Check how llvm-readelf prints sections to segments mapping.
+
+## Check that --section-mapping produces a sections to segments
+## mapping and not anything else.
+# RUN: yaml2obj %s -o %t64.elf
+# RUN: llvm-readelf --section-mapping %t64.elf \
+# RUN:   | FileCheck %s --check-prefix=MAPPING --strict-whitespace --match-full-lines --implicit-check-not={{.}}
+
+#      MAPPING: Section to Segment mapping:
+# MAPPING-NEXT:  Segment Sections...
+# MAPPING-NEXT:   00     .foo.begin .foo.end {{$}}
+# MAPPING-NEXT:   01     .bar.begin .bar.end {{$}}
+# MAPPING-NEXT:   None   .strtab .shstrtab {{$}}
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+  Entry:   0x12345678
+Sections:
+  - Name:    .foo.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x1000
+    Size:    0x1
+  - Name:    .foo.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x2
+  - Name:    .bar.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x2000
+    Size:    0x3
+  - Name:    .bar.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x4
+ProgramHeaders:
+## Case 1: an arbitrary segment with sections.
+  - Type:  PT_PHDR
+    Flags: [ PF_W ]
+    VAddr: 0x1000
+    Sections:
+      - Section: .foo.begin
+      - Section: .foo.end
+## Case 2: another segment with different sections.
+  - Type:  PT_PHDR
+    Flags: [ PF_X ]
+    VAddr: 0x2000
+    Sections:
+      - Section: .bar.begin
+      - Section: .bar.end
+
+## Check that --section-mapping=false --program-headers produces just program headers.
+# RUN: llvm-readelf --section-mapping=false --program-headers %t64.elf \
+# RUN:   | FileCheck %s --check-prefix=SEC-MAPPING-FALSE --implicit-check-not="Section to Segment mapping:"
+
+# SEC-MAPPING-FALSE: Program Headers:
+
+## Check that only one copy of the section/segment mapping table is produced
+## when both --section-mapping and --program-headers are used.
+# RUN: llvm-readelf --section-mapping --program-headers %t64.elf \
+# RUN:   | FileCheck %s --check-prefix=MAPPING --implicit-check-not="Section to Segment mapping:"
+
+## Check the output when an object has no section headers.
+## RUN: llvm-objcopy --strip-sections %t64.elf %tno-shdrs.o
+## RUN: llvm-readelf --section-mapping %tno-shdrs.o | FileCheck %s --check-prefix=NO-SECHDRS
+
+# NO-SECHDRS:      Section to Segment mapping:
+# NO-SECHDRS-NEXT:  Segment Sections...
+# NO-SECHDRS-NEXT:   00 {{$}}
+# NO-SECHDRS-NEXT:   01 {{$}}
+# NO-SECHDRS-NOT: {{.}}

llvm/tools/llvm-readobj/ELFDumper.cpp

for (const auto &Phdr :
     Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width));
     Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth));
     Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth));
     Fields[6].Str = printPhdrFlags(Phdr.p_flags);
     Fields[7].Str = to_string(format_hex(Phdr.p_align, 1));
     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";
+      auto ReportBadInterp = [&](const Twine &Msg) {
+        reportWarning(
+            createError("unable to read program interpreter name at offset 0x" +
+                        Twine::utohexstr(Phdr.p_offset) + ": " + Msg),
+            this->FileName);
+      };
+
+      if (Phdr.p_offset >= Obj->getBufSize()) {
+        ReportBadInterp("it goes past the end of the file (0x" +
+                        Twine::utohexstr(Obj->getBufSize()) + ")");
+        continue;
+      }
+
+      const char *Data =
+          reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset;
+      size_t MaxSize = Obj->getBufSize() - Phdr.p_offset;
+      size_t Len = strnlen(Data, MaxSize);
+      if (Len == MaxSize) {
+        ReportBadInterp("it is not null-terminated");
+        continue;
+      }
+
+      OS << "      [Requesting program interpreter: ";
+      OS << StringRef(Data, Len) << "]";
     }
     OS << "\n";
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSectionMapping(const ELFO *Obj) {
   OS << "\n Section to Segment mapping:\n  Segment Sections...\n";