[elfabi] Add support for reading DT_SONAME from binaries

[amontanez]

Summary

This change gives the llvm-elfabi tool the ability to read DT_SONAME from a binary ELF file into an ELFStub.

Added:

• DynamicEntries struct for storing dynamic entries that are relevant to elfabi.
• terminatedSubstr() retrieves a null-terminated substring from a StringRef.
• appendToError() appends a string to an error, allowing more specific error messages.

[amontanez]

Small code formatting fix.

[jakehehrlich]

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strsz.test

19 ↗

(On Diff #177978)

So yaml2obj actually does support dynamic symbols but I'm not sure that it supports .dynamic. grep for "DynamicSymbols" in .test and .yaml files in the code base. There should be a yaml2obj test that uses this feature. You might find proper support for .dynamic as well.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

80 ↗

(On Diff #177978)

I'd prefer to only do one loop over the dynamic entries; right now you do a seperate loop for each feature (here just .dynstr and the soname, but later other things as well). It's not a huge deal as there's a pretty small upper bound on how long these can be. A standard strategy is to traverse it once and put everything in an array indexed by the tag.

llvm/tools/llvm-elfabi/ELFObjHandler.h

56 ↗

(On Diff #177978)

All these except readELFFile should be static and in ELFObjHandler.cpp and not in the header.

[amontanez]

Changed:

• There is no longer one function to populate each ELFStub member.
• The .dynamic table is only scanned once.

[amontanez]

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strsz.test

19 ↗

(On Diff #177978)

Unfortunately, the only mention of the .dynamic section in yaml2obj is when sh_entsize of SHT_DYNAMIC is populated. If I recall correctly, using DynamicSymbols causes .dynstr to be overwritten.

[amontanez]

Small change to make functions static.

[jakehehrlich]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

68–75 ↗

(On Diff #179108)

If they're never supposed to be missing, does it make sense for them to be Optional?

111 ↗

(On Diff #179108)

nit: Don't fret over this too much but It would be nice if there were a way to ensure that when looking for the null terminator this didn't fall off the end of the string table. As is if the string table happens to be erroneous and not contain a null terminator, this will segfault.

[amontanez]

Changed:

• Mandatory DynamicEntries members are now uint64_t instead of Optional<uint64_t>, now include more checks for correctness.
• Bound checking when creating SoName string from .dynstr table.

[amontanez]

Addressed feedback in D55852: strings that overrun the bounds of a string table (due to absent null terminator or incorrect string table size) are reported as errors in terminatedSubstr().

[jakehehrlich]

LGTM. However make sure to at least CC some people outside, if not add them as reviewers on everything.

[jakehehrlich]

As discussed offline I realized I missed something.

llvm/test/tools/llvm-elfabi/binary-read-zero-dt-strtab.test

35–37 ↗

(On Diff #180171)

Also this has no size, it should cover the whole PT_DYNAMIC and the string table. There isn't a way to start the offset in zero in yaml2elf (my fault, sorry) so you'll have to start it somewhere else anyhow to make the vaddr and offset consistent anyway.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

140 ↗

(On Diff #180171)

Ah wait, never-mind, I want this to work a bit differently. We discussed this offline but for others benifit I'll mention it here. This should work for cases when the vaddr which corresponds to ElfFile->base() is not zero (e.g. the common case for ET_EXEC and the almost never but sometimes case for ET_DYN). To do this you have to loop though the program headers, find the PT_LOAD such that the vaddr of the string table is in range of the vaddr to vaddr+filesz of the program header, and then use the offset of the program header and the difference between the vaddr of the program header and the string table to calculate the correct offset from base of the elf file. That's kind of a tricky subtle issue. You can test this by creating a binary using yaml2obj and making the vaddr of the program header that contains a dynamic string table non-zero.

[amontanez]

The offset of .dynstr is now calculated using the DT_STRTAB address along with the program headers.

[jakehehrlich]

Super informative error messages!

two small things to fix before you land.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

130 ↗

(On Diff #180305)

This hole Range thing is super confusing to me. Just have Addr and Size and just demand the user supplies Size.

135 ↗

(On Diff #180305)

You can just do Addr >= Entry.p_vaddr && Addr + Size < Entry.p_vaddr + Entry.file_sz

[jhenderson]

llvm/test/tools/llvm-elfabi/binary-read-arch.test

16–19 ↗

(On Diff #180305)

I would whole-heartedly support extending yaml2obj to allow for dynamic tags to be specified in a more readable format, possibly similar to how relocations or symbols are written?

21 ↗

(On Diff #180305)

Do you actually need a .dynsym for this and the other tests?

27 ↗

(On Diff #180305)

Can you just replace this with an explicit size?

33 ↗

(On Diff #180305)

I'm not sure I understand the purpose of this comment... I think it's fairly obvious what the content is!

llvm/test/tools/llvm-elfabi/binary-read-bad-soname.test

46 ↗

(On Diff #180305)

Perhaps worth specifying the string offset in this error message?

llvm/test/tools/llvm-elfabi/binary-read-bad-vaddr.test

1 ↗

(On Diff #180305)

Which address is the "bad vaddr"? I assume it's the DT_STRTAB, in which case, I'd prefer the test to be called "binary-read-bad-dt-strtab" or similar.

16 ↗

(On Diff #180305)

You could actually just have DT_SONAME 0, and a single null byte in the .dynstr to simplify this test slightly. Same goes for other error cases.

38 ↗

(On Diff #180305)

Should this list include .dynamic too?

In general, I'm noticing some inconsistencies in the tests in what is in which segment. Could you try to unify them as much as possible, assuming that the differences aren't important?

49 ↗

(On Diff #180305)

Nit: unnecessary blank line here.

llvm/test/tools/llvm-elfabi/binary-read-soname-no-null.test

34–35 ↗

(On Diff #180305)

This is confusing. There's a '\0' on the end of the contents according to the section. Perhaps it should be removed?

llvm/test/tools/llvm-elfabi/binary-read-soname.test

34 ↗

(On Diff #180305)

To simplify things slightly, remove the "not\0bar\0" content. We only really need one thing before and one thing after the soname string.

52 ↗

(On Diff #180305)

Add a {{$}} at the end of this string, to make sure it doesn't have anything after it (this would match somelib.sofoo for example).

llvm/test/tools/llvm-elfabi/binary-read-zero-dt-strsz.test

1 ↗

(On Diff #180305)

I'm not sure we need this case, unless you want to explicitly check the validity of the .dynstr with llvm-elfabi. If it is zero-sized, the check for whether DT_SONAME is in it will achieve this.

llvm/test/tools/llvm-elfabi/binary-read-zero-dt-strtab.test

47 ↗

(On Diff #180305)

Why not? There's nothing requiring the first loadable segment to contain the elf header and program header table. A zero address is therefore possible for .dynstr.

Also, all these errors should be "address" not "offset", since that's what they refer to.

llvm/test/tools/llvm-elfabi/replace-soname-tbe.test

1 ↗

(On Diff #180305)

This would be better named "insert-soname". A separate test for what to do if there is already a SONAME is also needed.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

42 ↗

(On Diff #180305)

This and the following function don't need to be in the anonymous namespace. I also don't think the DynamicEntries struct needs to be either.

74–75 ↗

(On Diff #180305)

I'm not sure I understand what "binary" is referring to here.

79 ↗

(On Diff #180305)

I don't think you need to specify "binary" here. Theoretically, this function would work just as well if the table was created in memory rather than read from a file.

95 ↗

(On Diff #180305)

As noted in the test, this isn't true.

100 ↗

(On Diff #180305)

As noted in the test, this probably isn't a necessary check.

130 ↗

(On Diff #180305)

I feel like this has been done before in LLVM. At least llvm-objcopy (?) has something very similar. Do we need to reinvent the wheel?

@jakehehrlich - can you remember exactly where this was?

[amontanez]

Cleaned up tests and made them significantly more consistent.

[amontanez]

llvm/test/tools/llvm-elfabi/binary-read-arch.test

16–19 ↗

(On Diff #180305)

I agree, after working on theses tests for a while I think something to assist populating .dynamic is in order. Keeping the content and comments consistent becomes rather tedious. I'll get to that asap so it can precede this patch.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

135 ↗

(On Diff #180305)

I've split it this way so there's a distinction between

• an address not covered by any PT_LOAD
• an address range partially covered by a PT_LOAD

While it's not super useful for the typical binary, it's helpful for correctly designing tests.

[jhenderson]

Basically looks fine to me, with one outstanding issue, namely that I feel like the address to offset code is a reinvention of something either in llvm-objcopy or llvm-objdump somewhere, but I don't remember where unfortunately. I'd suggest checking how llvm-objdump (or possibly llvm-readobj) looks up information relating to dynamic symbols etc.

llvm/test/tools/llvm-elfabi/binary-read-replace-soname.test

46–58 ↗

(On Diff #180587)

You could probably simplify both of these to just check the SoName field. Same goes for other tests.

Also add the {{$}} here and above.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

156 ↗

(On Diff #180587)

Nit: Shouldn't this static be before the return value?

[amontanez]

Replaced addrAsOffset() with ELFFile<ELFT>::toMappedAddr(), updated tests.

[amontanez]

Small change from (const char *)*DynStrPtr to (const char *)DynStrPtr.get() for clarity.

[jhenderson]

LGTM, aside from one small comment.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

151 ↗

(On Diff #181596)

I was under the impression that C++ style casts were preferred, but I could be wrong. I also don't see a good reason to change it from what was there before (i.e. reinterpret_cast).

[amontanez]

using reinterpret_cast now. Since it looks like it might take a bit of time to land support for dynamic entries in yaml2obj, do you feel it would be fine to land this patch now and update the tests later?

[jhenderson]

I think it's fine to land this as is.

llvm/trunk/test/tools/llvm-elfabi/binary-read-add-soname.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=best.so | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_AARCH64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0008
+    AddressAlign:    8
+    Content:         "0a0000000000000001000000000000000500000000000000000000000000000000000000000000000000000000000000"
+      # DT_STRSZ      1 (0x1)
+      # DT_STRTAB     0x0
+      # DT_NULL       0x0
+    Size:            48
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0008
+    PAddr: 0x0008
+    Sections:
+      - Section: .dynamic
+
+# CHECK:      --- !tapi-tbe
+# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# CHECK-NEXT: SoName: best.so{{$}}
+# CHECK-NEXT: Arch: AArch64
+# CHECK-NEXT: Symbols: {}
+# CHECK-NEXT: ...

llvm/trunk/test/tools/llvm-elfabi/binary-read-arch.test

 # RUN: yaml2obj %s > %t
-# RUN: llvm-elfabi %t --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0008
+    AddressAlign:    8
+    Content:         "0a0000000000000001000000000000000500000000000000000000000000000000000000000000000000000000000000"
+      # DT_STRSZ      1 (0x1)
+      # DT_STRTAB     0x0
+      # DT_NULL       0x0
+    Size:            48
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0008
+    PAddr: 0x0008
+    Sections:
+      - Section: .dynamic
 
 # CHECK:      --- !tapi-tbe
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: Arch: x86_64
 # CHECK-NEXT: Symbols: {}
 # CHECK-NEXT: ...

llvm/trunk/test/tools/llvm-elfabi/binary-read-bad-soname.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0008
+    AddressAlign:    8
+    Content:         "0e000000000000000d000000000000000a0000000000000001000000000000000500000000000000000000000000000000000000000000000000000000000000"
+      # DT_SONAME     13 (0x0d)
+      # DT_STRSZ      1 (0x01)
+      # DT_STRTAB     0x0
+      # DT_NULL       0x0
+    Size:            64
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0008
+    PAddr: 0x0008
+    Sections:
+      - Section: .dynamic
+
+# CHECK: DT_SONAME string offset (0x000000000000000d) outside of dynamic string table

llvm/trunk/test/tools/llvm-elfabi/binary-read-bad-vaddr.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1008
+    AddressAlign:    8
+    Content:         "0e0000000000000000000000000000000a0000000000000001000000000000000500000000000000600200000000000000000000000000000000000000000000"
+      # DT_SONAME     0
+      # DT_STRSZ      1
+      # DT_STRTAB     0x0260 # Bad vaddr (no PT_LOAD for 0x0000 to 0x0FFF)
+      # DT_NULL       0x0
+    Size:            64
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1008
+    PAddr: 0x1008
+    Sections:
+      - Section: .dynamic
+
+# CHECK: Virtual address is not in any segment when locating .dynstr section contents

llvm/trunk/test/tools/llvm-elfabi/binary-read-no-dt-strsz.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+#                     \0 b a z\0
+    Content:         "0062617a00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0008
+    AddressAlign:    8
+    Content:         "0500000000000000000000000000000000000000000000000000000000000000"
+      # DT_STRTAB     0x0
+      # DT_NULL       0x0
+    Size:            32
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0008
+    PAddr: 0x0008
+    Sections:
+      - Section: .dynamic
+
+# CHECK: Couldn't determine dynamic string table size (no DT_STRSZ entry)

llvm/trunk/test/tools/llvm-elfabi/binary-read-no-dt-strtab.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0008
+    AddressAlign:    8
+    Content:         "0a00000000000000010000000000000000000000000000000000000000000000"
+      # DT_STRSZ      1 (0x1)
+      # DT_NULL       0x0
+    Size:            32
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0008
+    PAddr: 0x0008
+    Sections:
+      - Section: .dynamic
+
+# CHECK: Couldn't locate dynamic string table (no DT_STRTAB entry)

llvm/trunk/test/tools/llvm-elfabi/binary-read-no-dynamic.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+
+# CHECK: No .dynamic section found

llvm/trunk/test/tools/llvm-elfabi/binary-read-replace-soname.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s --check-prefix=ORIGINAL
+# RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=libbest.so | FileCheck %s --check-prefix=REPLACED
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+#                     \0 b a z\0 s o m e l i b . s o\0 f o o\0
+    Content:         "0062617a00736f6d656c69622e736f00666f6f00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1018
+    AddressAlign:    8
+    Content:         "0e0000000000000005000000000000000a0000000000000014000000000000000500000000000000001000000000000000000000000000000000000000000000"
+      # DT_SONAME     5 (0x05)
+      # DT_STRSZ      20 (0x14)
+      # DT_STRTAB     0x1000
+      # DT_NULL       0x0
+    Size:            64
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1018
+    PAddr: 0x1018
+    Sections:
+      - Section: .dynamic
+
+# ORIGINAL: SoName: somelib.so{{$}}
+
+# REPLACED: SoName: libbest.so{{$}}

llvm/trunk/test/tools/llvm-elfabi/binary-read-soname-no-null.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+#                     \0 b a z\0 s o m e l i b . s o z z z
+    Content:         "0062617a00736f6d656c69622e736f7a7a7a"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1018
+    AddressAlign:    8
+    Content:         "0e0000000000000005000000000000000a000000000000000f000000000000000500000000000000001000000000000000000000000000000000000000000000"
+      # DT_SONAME     5 (0x05)
+      # DT_STRSZ      15 (0x0F)
+      # DT_STRTAB     0x1000
+      # DT_NULL       0x0
+    Size:            64
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1018
+    PAddr: 0x1018
+    Sections:
+      - Section: .dynamic
+
+# CHECK: String overran bounds of string table (no null terminator) when reading DT_SONAME

llvm/trunk/test/tools/llvm-elfabi/binary-read-soname.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+#                     \0 b a z\0 s o m e l i b . s o\0 f o o\0
+    Content:         "0062617a00736f6d656c69622e736f00666f6f00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1018
+    AddressAlign:    8
+    Content:         "0e0000000000000005000000000000000a0000000000000014000000000000000500000000000000001000000000000000000000000000000000000000000000"
+      # DT_SONAME     5 (0x05)
+      # DT_STRSZ      20 (0x14)
+      # DT_STRTAB     0x1000
+      # DT_NULL       0x0
+    Size:            64
+    Link:            .dynstr
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 8
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1018
+    PAddr: 0x1018
+    Sections:
+      - Section: .dynamic
+
+# CHECK:      --- !tapi-tbe
+# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# CHECK-NEXT: SoName: somelib.so{{$}}
+# CHECK-NEXT: Arch: x86_64
+# CHECK-NEXT: Symbols: {}
+# CHECK-NEXT: ...

llvm/trunk/test/tools/llvm-elfabi/replace-soname-tbe.test

-# RUN: yaml2obj %s > %t
-# RUN: llvm-elfabi %t --emit-tbe=- --soname=best.so | FileCheck %s
-
-!ELF
-FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_DYN
-  Machine:         EM_AARCH64
-
-# CHECK:      --- !tapi-tbe
-# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
-# CHECK-NEXT: SoName: best.so
-# CHECK-NEXT: Arch: AArch64
-# CHECK-NEXT: Symbols: {}
-# CHECK-NEXT: ...

llvm/trunk/tools/llvm-elfabi/ELFObjHandler.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/TextAPI/ELF/ELFStub.h"
 
 using llvm::MemoryBufferRef;
 using llvm::object::ELFObjectFile;
 
 using namespace llvm;
 using namespace llvm::object;
-using namespace llvm::elfabi;
 using namespace llvm::ELF;
 
 namespace llvm {
 namespace elfabi {
 
+// Simple struct to hold relevant .dynamic entries.
+struct DynamicEntries {
+  uint64_t StrTabAddr = 0;
+  uint64_t StrSize = 0;
+  Optional<uint64_t> SONameOffset;
+};
+
+/// This function behaves similarly to StringRef::substr(), but attempts to
+/// terminate the returned StringRef at the first null terminator. If no null
+/// terminator is found, an error is returned.
+///
+/// @param Str Source string to create a substring from.
+/// @param Offset The start index of the desired substring.
+static Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
+  size_t StrEnd = Str.find('\0', Offset);
+  if (StrEnd == StringLiteral::npos) {
+    return createError(
+        "String overran bounds of string table (no null terminator)");
+  }
+
+  size_t StrLen = StrEnd - Offset;
+  return Str.substr(Offset, StrLen);
+}
+
+/// This function takes an error, and appends a string of text to the end of
+/// that error. Since "appending" to an Error isn't supported behavior of an
+/// Error, this function technically creates a new error with the combined
+/// message and consumes the old error.
+///
+/// @param Err Source error.
+/// @param After Text to append at the end of Err's error message.
+Error appendToError(Error Err, StringRef After) {
+  std::string Message;
+  raw_string_ostream Stream(Message);
+  Stream << Err;
+  Stream << " " << After;
+  consumeError(std::move(Err));
+  return createError(Stream.str().c_str());
+}
+
+/// This function populates a DynamicEntries struct using an ELFT::DynRange.
+/// After populating the struct, the members are validated with
+/// some basic sanity checks.
+///
+/// @param Dyn Target DynamicEntries struct to populate.
+/// @param DynTable Source dynamic table.
+template <class ELFT>
+static Error populateDynamic(DynamicEntries &Dyn,
+                             typename ELFT::DynRange DynTable) {
+  if (DynTable.empty())
+    return createError("No .dynamic section found");
+
+  // Search .dynamic for relevant entries.
+  bool FoundDynStr = false;
+  bool FoundDynStrSz = false;
+  for (auto &Entry : DynTable) {
+    switch (Entry.d_tag) {
+    case DT_SONAME:
+      Dyn.SONameOffset = Entry.d_un.d_val;
+      break;
+    case DT_STRTAB:
+      Dyn.StrTabAddr = Entry.d_un.d_ptr;
+      FoundDynStr = true;
+      break;
+    case DT_STRSZ:
+      Dyn.StrSize = Entry.d_un.d_val;
+      FoundDynStrSz = true;
+      break;
+    }
+  }
+
+  if (!FoundDynStr) {
+    return createError(
+        "Couldn't locate dynamic string table (no DT_STRTAB entry)");
+  }
+  if (!FoundDynStrSz) {
+    return createError(
+        "Couldn't determine dynamic string table size (no DT_STRSZ entry)");
+  }
+  if (Dyn.SONameOffset.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) {
+    return createStringError(
+        object_error::parse_failed,
+        "DT_SONAME string offset (0x%016x) outside of dynamic string table",
+        *Dyn.SONameOffset);
+  }
+
+  return Error::success();
+}
+
 /// Returns a new ELFStub with all members populated from an ELFObjectFile.
 /// @param ElfObj Source ELFObjectFile.
 template <class ELFT>
-Expected<std::unique_ptr<ELFStub>>
+static Expected<std::unique_ptr<ELFStub>>
 buildStub(const ELFObjectFile<ELFT> &ElfObj) {
+  using Elf_Dyn_Range = typename ELFT::DynRange;
+  using Elf_Phdr_Range = typename ELFT::PhdrRange;
   std::unique_ptr<ELFStub> DestStub = make_unique<ELFStub>();
   const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+  // Fetch .dynamic table.
+  Expected<Elf_Dyn_Range> DynTable = ElfFile->dynamicEntries();
+  if (!DynTable) {
+    return DynTable.takeError();
+  }
+
+  // Fetch program headers.
+  Expected<Elf_Phdr_Range> PHdrs = ElfFile->program_headers();
+  if (!PHdrs) {
+    return PHdrs.takeError();
+  }
+
+  // Collect relevant .dynamic entries.
+  DynamicEntries DynEnt;
+  if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
+    return std::move(Err);
+
+  // Convert .dynstr address to an offset.
+  Expected<const uint8_t *> DynStrPtr =
+      ElfFile->toMappedAddr(DynEnt.StrTabAddr);
+  if (!DynStrPtr)
+    return appendToError(DynStrPtr.takeError(),
+                         "when locating .dynstr section contents");
+
+  StringRef DynStr(reinterpret_cast<const char *>(DynStrPtr.get()),
+                   DynEnt.StrSize);
 
+  // Populate Arch from ELF header.
   DestStub->Arch = ElfFile->getHeader()->e_machine;
 
-  // TODO: Populate SoName from .dynamic entries and linked string table.
+  // Populate SoName from .dynamic entries and dynamic string table.
+  if (DynEnt.SONameOffset.hasValue()) {
+    Expected<StringRef> NameOrErr =
+        terminatedSubstr(DynStr, *DynEnt.SONameOffset);
+    if (!NameOrErr) {
+      return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
+    }
+    DestStub->SoName = *NameOrErr;
+  }
+
   // TODO: Populate NeededLibs from .dynamic entries and linked string table.
   // TODO: Populate Symbols from .dynsym table and linked string table.
 
   return std::move(DestStub);
 }
 
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);