llvm-readobj: add experimental support for SHT_RELR sections.

[rahulchaudhry]

Summary

This change adds experimental support for SHT_RELR sections, proposed
here: https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg

Definitions for the new ELF section type and dynamic array tags, as well
as the encoding used in the new section are all under discussion and are
subject to change. Use with caution!

[rahulchaudhry]

I'm still working on adding some unit tests, but I thought I'd send this in for now in case there is any high level feedback on the overall approach.

[rahulchaudhry]

Added tests, ready for review.

[rahulchaudhry]

tools/llvm-readobj/ELFDumper.cpp

2637 ↗

(On Diff #150580)

Fields[1-4] are empty for SHT_RELR section, but they were already assigned a width above.
Doing it this way results in trailing spaces on every line. Does it matter?

3304 ↗

(On Diff #150580)

Same as above, this results in trailing spaces on every line.

[jakehehrlich]

I'll have more comments tomorrow. I'm still grokking my way though llvm-readobj as I've never looked at that code before.

I have a general question about GNUStyle though. Why should GNUStyle with Relr be so different from GNUStyle for Rel(a)? Shouldn't (ideally) relr be transparently usable without a difference in how it is printed out to the user? e.g. relr should print out something indistinguishable from if the linker had used rela/rel relocation instead.

If r_info can't be sensibly set then I think the only real option is to have it be output differently for both IMO. We shouldn't be outputting a relocation type that's incorrect. I'm not sure it makes sense to decode things quite this way when you don't have an operating system or architecture specific solution (as was the case with android). I think LLD defines some common relocation types across architectures but that isn't super useful here. I wouldn't mind that being duplicated here (maybe pcc disagrees though).

include/llvm/BinaryFormat/ELF.h

1077 ↗

(On Diff #150580)

I think in the spec you propose Elf32_Relr and Elf64_Relr as typedefs instead of structs. I think this file (and the higher level ELFType file as well) should match the spec in that regard.

lib/Object/ELF.cpp

229 ↗

(On Diff #150580)

Is there a more sensible info we can set this to? It would have to be processor specific which might be super annoying. If there isn't a reasonable way to set the relocation type then I think it should be dropped llvm-readobj output in the llvm case.

232 ↗

(On Diff #150580)

can this be made constexpr? or at least static const?

234 ↗

(On Diff #150580)

nit: I think I'd prefer this use Elf_Addr since it represents an offset for a dynamic relocation (e.g. and address)

247 ↗

(On Diff #150580)

nit I think I'd prefer this use Elf_Addr for the same reason.

test/tools/llvm-readobj/elf-relr-relocs.test

6 ↗

(On Diff #150580)

R_X86_64_NONE is not a valid relocation type. See my r_info comment above about this issue.

[mcgrathr]

In response to Jake's comments about GNUStyle:

First and foremost the mandate for GNUStyle is to closely approximate the output format of binutils readelf for the same data. There is not yet a binutils implementation of SHT_RELR support submitted upstream, so you'll need to coordinate with the folks implementing that support and harmonize the GNUStyle output format with whatever they and the binutils maintainers settle on.

I don't think it's at all desireable to make SHT_RELR output transparently resemble SHT_RELA/SHT_REL output, at least not as the only output format. The first purpose of readelf is to show the contents of the ELF file as they are, so it can be used to debug low-level encoding/decoding. So I definitely want at least the option of an output format that just shows the values in a nice presentation rather than pretending they're something else.

I think there's an argument to be made that readelf -r should always use the existing format since there are scripts that decode and such. So having readelf -r display an SHT_RELR section as if it were an SHT_REL(A) section where every reloc has type R_*_RELATIVE and all other fields (except r_offset) zero might make sense. i.e., that would produce up to 64 lines for each SHT_RELR entry. But there should certainly be a format (preferably other than just -x.dyn.relr for generic hex dump) that shows the exact contents without expansion, even if the -r switch doesn't elicit that output.

include/llvm/BinaryFormat/ELF.h

1077 ↗

(On Diff #150580)

This header is C++, not C. So there's no difference there.

[jakehehrlich]

include/llvm/BinaryFormat/ELF.h

1077 ↗

(On Diff #150580)

That's not my point. The spec proposal I'm working off of reads

typedef Elf32_Word   Elf32_Relr; 
typedef Elf64_Xword  Elf64_Relr;

This file should match (not precisely, it can use using instead of typedef if it wants) in that it should not have to go though an r_data field. Alternatively the spec can be updated to make this a struct.

[rahulchaudhry]

Apologies for the delay in updating this patch.

There are several changes since the previous version:

• By default, '.relr.dyn' contents are printed as-is.
• Pass '-decode-relr' flag to decode the contents and print individual relocations.
• Relative relocation type is printed correctly.
• Elf32_Relr and Elf64_Relr are defined using typedef, matching the proposal.

[rahulchaudhry]

lib/Object/ELF.cpp

229 ↗

(On Diff #150580)

The type is set appropriately now (2 lines below).

234 ↗

(On Diff #150580)

Defined a 'Word' type locally, and using it for Base/Entry/Offset now.
Elf_Addr is a packed version of this uint type for endianness conversion.
At least Entry can't be Elf_Addr, since we need to do bit-shifts on it (operator >>= is undefined for packed types).
And if Entry is Word, then it makes sense to keep Base/Offset as Word as well, otherwise we end up with several unnecessary conversions below when doing arithmetic and assignments.

test/tools/llvm-readobj/elf-relr-relocs.test

6 ↗

(On Diff #150580)

When raw contents of '.relr.dyn' section are dumped, I'm printing a dummy 'R_RELR_RELATIVE' relocation type.
With -decode-relr, the correct relative relocation type is printed.

[jakehehrlich]

I think I'm more or less happy with the llvm-readobj part of this.

For yaml2obj I think it would be ideal to support a new relocation type that reads in a list of addresses, sets SHF_ALLOC, and computes the section contents from the addresses. Alternatively I'd be ok with allowing for individual entries to manually added. I'm just not a huge fan of forcing yaml2obj users to put a big hex blob in the middle of their test.

include/llvm/Object/ELFTypes.h

66 ↗

(On Diff #151579)

This should also be a typedef the way Addr is below.

455 ↗

(On Diff #151579)

You shouldn't use r_data in ELFTypes either. It should also be a typedef, just for 'packed' instead.

lib/Object/ELF.cpp

234 ↗

(On Diff #150580)

Ah gotcha...hmm. I think that's an acceptable reason. If you run into anything like this in LLD and Rui or someone gives a better recommendation, please come back and change this. Otherwise consider this done.

test/tools/llvm-readobj/elf-relr-relocs.test

12 ↗

(On Diff #151579)

I think you can drop the R_RELR_RELATIVE and the addend in this case.

tools/llvm-readobj/ELFDumper.cpp

3418 ↗

(On Diff #151579)

As mentioned above, I think in this case you don't have to print out the relocation type and addend. You might just inline something here that prints out the relr entry instead.

4106 ↗

(On Diff #151579)

Same thing here.

4326 ↗

(On Diff #151579)

same thing here.

[rahulchaudhry]

Relr is now defined directly as packed<uint>.
struct Elf_Relr_Impl is no longer necessary.

[jakehehrlich]

I really feel that non-decoded entries shouldn't have an addend or faked relocation type. It's really confusing to look at those and see relocations. I think non-decoded entries should just print the relr entry.

[rahulchaudhry]

test/tools/llvm-readobj/elf-relr-relocs.test

12 ↗

(On Diff #151579)

See below.

tools/llvm-readobj/ELFDumper.cpp

3418 ↗

(On Diff #151579)

The addend gets skipped in GNUStyle::printDynamicRelocation (it's only printed for RELA).
This GNUStyle dump is purely speculative, as there is no implementation for this in GNU binutils yet.
We'll need to come back and adjust the format here anyway once gnu-readelf supports printing SHT_RELR sections.

Also, see below.

4106 ↗

(On Diff #151579)

See below.

4326 ↗

(On Diff #151579)

I'd argue that both type and addend should be printed here for consistency.

• The case for addend is easy. LLVMStyle prints it for all relocations, even SHT_REL, which don't have addends. The case for SHT_RELR is similar. A 0x0 is printed as addend in both cases.

• For printing a type (even a dummy one, like R_RELR_RELATIVE), the rationale is wrt. two readobj flags: '-dyn-relocations' and '-expand-relocs'.
  
  -dyn-relocations prints all dynamic relocations in a single Dynamic Relocations { } block. It does not separate them by sections as -relocations does. It would be disorienting to have some relocations from .rela.dyn in the block (with full type/symbol/addend info), followed by a bunch of hex numbers (with no type or description), followed by some more relocations from .rela.plt section (with full type/symbol/addend info).
  
  LLVMStyle::printDynamicRelocation also handles -expand-relocs flag and prints each entry on multiple lines. This is another reason to use this function to print relocations here instead of inlining a special case.

[jakehehrlich]

So in considering the case you pointed out about -dyn-relocations I discovered that the current behavior for -relocations is to not print out dynamic relocations at all. This is hidden by the fact that dynamic relocations tend to be duplicated with non-dynamic relocations by default. So we should only print these out on -dyn-relocations unless they're duplicated. As part of my proposal to a solution to this I'm proposing an additional flag so that the raw form that Roland requested can be printed out. This way debugging of the underlying format is possible but for most purposes the decoded form can be used.

tools/llvm-readobj/ELFDumper.cpp

3418 ↗

(On Diff #151579)

Ok sounds good. I'm aware we'll need to come back. I just want to make a best faith effort first.

4326 ↗

(On Diff #151579)

My claim is that these are not actually relocation entries. Each entire corresponds to potentially many relocations and some correspond to none! More over the data seems like an address even though it isn't. I fully agree that in the decode case we should print the full information with the addend. My point is just that the information you're adding dosn't make sense as a relocation. I hadn't considered the behavior of -dyn-relcoations though. You're 100% right that we shouldn't print out raw hex addresses with no other information in that case. That clearly presents an issue with the specific change I requested here.

What do you think about this proposal:

1. When dynamic relocations are printed out, you decode the relocations so that they make sense.
2. Add an extra switch -dyn-relr for printing out the list of hex entries in all SHT_RELR sections.
3. If -dyn-relr and -decode-relr are both set then decode those relocations and print them out as you've been doing.

This should resolve the dynamic relocation issue and resolve my concern. The matra here is then "you should cal print*Relocation when you can but you should only call it if you're actually using a real relocation.

[rahulchaudhry]

tools/llvm-readobj/ELFDumper.cpp

4326 ↗

(On Diff #151579)

I'm not sure I fully understand the proposal. Here's what I think you're asking for:

1. When printing -dyn-relocations, always decode the relr relocations. SGTM.

2. With -relocations, print only the SHT_RELR hex entries by default. They're in a separate ".relr.dyn {}" block (for LLVMStyle) or under separate "Relocation section '.relr.dyn'" table (for GNUStyle), so there's no confusion. SGTM.

3. With -relocations -decode-relr, decode the SHT_RELR section and print relocation entries in the corresponding .relr.dyn block or table. SGTM.

Please let me know if I'm missing something.

a. I don't see why an extra flag -dyn-relr is needed. What would it be useful for? Simple -relocations without -decode-relr works fine for testing lld output etc.
b. What happens with -relocations -expand-relocs (without -decode-relr)? What is the expanded form for SHT_RELR hex entries? Is it ok to ignore -expand-relocs for the .relr.dyn block?

[jakehehrlich]

tools/llvm-readobj/ELFDumper.cpp

4326 ↗

(On Diff #151579)

Answer to a: I don't think -relocations is the flag that should trigger printing these things but both formats are needed.

Answer to b: Not important because there should be no interaction with -relocations.

Stated in the more clear format you used:

1. Perfect. Exactly what I think should happen.

2. -relocations shouldn't cause SHT_RELR to print at all. It's orthogonal. This is to be consistent with the fact that -relocations doesn't print out dynamic relocations.

3. if -dyn-relr is set, print out the SHT_RELR sections using just hex entries.

4. if -dyn-relr and -decode-relr are both set, print out the ".relr.dyn {}" format but with decoded relocation entries.

[rahulchaudhry]

tools/llvm-readobj/ELFDumper.cpp

4326 ↗

(On Diff #151579)

Regarding 2: -relocations does print SHT_RELA sections for executables and shared objects. That's dynamic relocations, in much the same way as those in SHT_RELR.

Let's say a PIE binary has 10,000 relocations in SHT_RELA, 9,900 of which are relative relocations.
llvm-readobj -relocations will print all 10,000 relocations. So far so good.

Now let's say we re-link that binary with -pack-dyn-relocs=relr.
llvm-readobj -relocations will print only the remaining 100 relocations in SHT_RELA, and completely omit the rest, that are now encoded in SHT_RELR.
This is confusing, to say the least. It makes -relocations output pretty incomplete and useless for binaries containing SHT_RELR sections.

I think -relocations should print the entries in SHT_RELR as well. Whether it prints the encoded hex strings or the decoded relocations by default is up for discussion, and I'm fine either way, but completely skipping SHT_RELR in -relocations output does not sound like a good idea to me. When someone passes -relocations, they want to list the relocations. Printing only 1% of the relocations and requiring another flag to see the remaining 99% does not look like a reasonable interface.

[jakehehrlich]

tools/llvm-readobj/ELFDumper.cpp

4326 ↗

(On Diff #151579)

Ah sorry, I assumed the wrong cause of some behavior I was seeing. Try this:

1. link your executable
2. full strip your executable using llvm-objcopy --strip-sections (the binaries I had on hand to play with this happened to be full stripped)
3. run llvm-readobj -relocations. You'll see that no relocations are printed out
4. run llvm-readobj -dyn-relocations. You'll see that all expected relocations are output.

I assumed that -relocations checked weather a section was allocated or not before printing. Instead -relocations prints relocations for sections (allocated or not) where as -dyn-relocations looks for PT_DYNAMIC (not for allocated sections) and that explains the difference. (we should probably add a test case for -dyn-relocation).

So you're right. We should print out on -relocations. I believe it should always be decoded in that case but I'm ok with it printing out raw hex entries with no fake relocation type or addend. There should also be a way of getting the raw hex entries regardless. An additional -dyn-relr flag (you can pick a different name if you'd like) should accomplish that. Also it's not clear a specific -decode-relr flag is needed after that as 90% of the time you'll just want to see what the relocations are and when debugging SHT_RELR related issues you might want to look at the raw entries.

I'd accept the functionality you have now with the additional constraint that relocations are always decoded for -dyn-relocations. I'd prefer if the same were true for -relocations and a separate flag allowed printing out the raw entries.

[rahulchaudhry]

Decoding relr relocations is the default now for both -relocations and -dyn-relocations.
A new flag -raw-relr affects -relocations, turns off decoding and display raw SHT_RELR contents instead.

[rahulchaudhry]

tools/llvm-readobj/ELFDumper.cpp

4326 ↗

(On Diff #151579)

I've changed the default for both -relocations and -dyn-relocations to decode and print relative relocations in SHT_RELR section.
Added a new flag '-raw-relr' to disable this decoding (only for -relocations).
With '-raw-relr', just the raw hex entries are printed. There is no fake relocation type or addend.
Removed the '-decode-relr' flag, since that behavior is default now.
I think this addresses all of your concerns.
ptal.

[jakehehrlich]

LGTM, sorry for the back and forth!

[rahulchaudhry]

LGTM, sorry for the back and forth!

Thanks for the review.
Specifically, thanks for insisting that printRelocation() should only be called for real relocations, and not for printing RELR entries with a fake relocation name. I think we ended up with both cleaner code and cleaner output as a result.

If everything looks good, can you land this as well. I don't have commit access.

[jakehehrlich]

Sure thing.

llvm/trunk/include/llvm/BinaryFormat/DynamicTags.def

 DYNAMIC_TAG_MARKER(ENCODING, 32) // Values from here to DT_LOOS follow the rules
                                  // for the interpretation of the d_un union.
 
 DYNAMIC_TAG(PREINIT_ARRAY, 32)   // Pointer to array of preinit functions.
 DYNAMIC_TAG(PREINIT_ARRAYSZ, 33) // Size of the DT_PREINIT_ARRAY array.
 
 DYNAMIC_TAG(SYMTAB_SHNDX, 34) // Address of the SHT_SYMTAB_SHNDX section.
 
+// Experimental support for SHT_RELR sections. For details, see proposal
+// at https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
+DYNAMIC_TAG(RELRSZ, 35)  // Size of Relr relocation table.
+DYNAMIC_TAG(RELR, 36)    // Address of relocation table (Relr entries).
+DYNAMIC_TAG(RELRENT, 37) // Size of a Relr relocation entry.
+
 DYNAMIC_TAG_MARKER(LOOS, 0x60000000)   // Start of environment specific tags.
 DYNAMIC_TAG_MARKER(HIOS, 0x6FFFFFFF)   // End of environment specific tags.
 DYNAMIC_TAG_MARKER(LOPROC, 0x70000000) // Start of processor specific tags.
 DYNAMIC_TAG_MARKER(HIPROC, 0x7FFFFFFF) // End of processor specific tags.
 
 // Android packed relocation section tags.
 // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#31
 DYNAMIC_TAG(ANDROID_REL, 0x6000000F)
 DYNAMIC_TAG(ANDROID_RELSZ, 0x60000010)
 DYNAMIC_TAG(ANDROID_RELA, 0x60000011)
 DYNAMIC_TAG(ANDROID_RELASZ, 0x60000012)
 
+// Android's experimental support for SHT_RELR sections.
+// https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#253
+DYNAMIC_TAG(ANDROID_RELR, 0x6FFFE000)      // Address of relocation table (Relr entries).
+DYNAMIC_TAG(ANDROID_RELRSZ, 0x6FFFE001)    // Size of Relr relocation table.
+DYNAMIC_TAG(ANDROID_RELRENT, 0x6FFFE003)   // Size of a Relr relocation entry.
+
 DYNAMIC_TAG(GNU_HASH, 0x6FFFFEF5)    // Reference to the GNU hash table.
 DYNAMIC_TAG(TLSDESC_PLT, 0x6FFFFEF6) // Location of PLT entry for TLS
                                      // descriptor resolver calls.
 DYNAMIC_TAG(TLSDESC_GOT, 0x6FFFFEF7) // Location of GOT entry used by TLS
                                      // descriptor resolver PLT entry.
 DYNAMIC_TAG(RELACOUNT, 0x6FFFFFF9)   // ELF32_Rela count.
 DYNAMIC_TAG(RELCOUNT, 0x6FFFFFFA)    // ELF32_Rel count.
 

llvm/trunk/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHT_REL = 9,                          // Relocation entries; no explicit addends.
   SHT_SHLIB = 10,                       // Reserved.
   SHT_DYNSYM = 11,                      // Symbol table.
   SHT_INIT_ARRAY = 14,                  // Pointers to initialization functions.
   SHT_FINI_ARRAY = 15,                  // Pointers to termination functions.
   SHT_PREINIT_ARRAY = 16,               // Pointers to pre-init functions.
   SHT_GROUP = 17,                       // Section group.
   SHT_SYMTAB_SHNDX = 18,                // Indices for SHN_XINDEX entries.
+  // Experimental support for SHT_RELR sections. For details, see proposal
+  // at https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
+  SHT_RELR = 19,                        // Relocation entries; only offsets.
   SHT_LOOS = 0x60000000,                // Lowest operating system-specific type.
   // Android packed relocation section types.
   // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#37
   SHT_ANDROID_REL = 0x60000001,
   SHT_ANDROID_RELA = 0x60000002,
   SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
   SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile.
+  // Android's experimental support for SHT_RELR sections.
+  // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
+  SHT_ANDROID_RELR = 0x6fffff00,        // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5,      // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,            // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,          // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,         // GNU version references.
   SHT_GNU_versym = 0x6fffffff,          // GNU symbol versions table.
   SHT_HIOS = 0x6fffffff,                // Highest operating system-specific type.
   SHT_LOPROC = 0x70000000,              // Lowest processor arch-specific type.
   // Fixme: All this is duplicated in MCSectionELF. Why??
struct Elf32_Rela {
   unsigned char getType() const { return (unsigned char)(r_info & 0x0ff); }
   void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
   void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
   void setSymbolAndType(Elf32_Word s, unsigned char t) {
     r_info = (s << 8) + t;
   }
 };
 
+// Relocation entry without explicit addend or info (relative relocations only).
+typedef Elf32_Word Elf32_Relr; // offset/bitmap for relative relocations
+
 // Relocation entry, without explicit addend.
 struct Elf64_Rel {
   Elf64_Addr r_offset; // Location (file byte offset, or program virtual addr).
   Elf64_Xword r_info;  // Symbol table index and type of relocation to apply.
 
   // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
   // and ELF64_R_INFO macros defined in the ELF specification:
   Elf64_Word getSymbol() const { return (r_info >> 32); }
struct Elf64_Rela {
   Elf64_Word getType() const { return (Elf64_Word)(r_info & 0xffffffffL); }
   void setSymbol(Elf64_Word s) { setSymbolAndType(s, getType()); }
   void setType(Elf64_Word t) { setSymbolAndType(getSymbol(), t); }
   void setSymbolAndType(Elf64_Word s, Elf64_Word t) {
     r_info = ((Elf64_Xword)s << 32) + (t & 0xffffffffL);
   }
 };
 
+// Relocation entry without explicit addend or info (relative relocations only).
+typedef Elf64_Xword Elf64_Relr; // offset/bitmap for relative relocations
+
 // Program header for ELF32.
 struct Elf32_Phdr {
   Elf32_Word p_type;   // Type of segment
   Elf32_Off p_offset;  // File offset where segment is located, in bytes
   Elf32_Addr p_vaddr;  // Virtual address of beginning of segment
   Elf32_Addr p_paddr;  // Physical address of beginning of segment (OS-specific)
   Elf32_Word p_filesz; // Num. of bytes in file image of segment (may be zero)
   Elf32_Word p_memsz;  // Num. of bytes in mem image of segment (may be zero)

llvm/trunk/include/llvm/Object/ELF.h

 #include <cstdint>
 #include <limits>
 #include <utility>
 
 namespace llvm {
 namespace object {
 
 StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type);
+uint32_t getELFRelrRelocationType(uint32_t Machine);
 StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type);
 
 // Subclasses of ELFFile may need this for template instantiation
 inline std::pair<unsigned char, unsigned char>
 getElfArchType(StringRef Object) {
   if (Object.size() < ELF::EI_NIDENT)
     return std::make_pair((uint8_t)ELF::ELFCLASSNONE,
                           (uint8_t)ELF::ELFDATANONE);
public:
   using uintX_t = typename ELFT::uint;
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Dyn = typename ELFT::Dyn;
   using Elf_Phdr = typename ELFT::Phdr;
   using Elf_Rel = typename ELFT::Rel;
   using Elf_Rela = typename ELFT::Rela;
+  using Elf_Relr = typename ELFT::Relr;
   using Elf_Verdef = typename ELFT::Verdef;
   using Elf_Verdaux = typename ELFT::Verdaux;
   using Elf_Verneed = typename ELFT::Verneed;
   using Elf_Vernaux = typename ELFT::Vernaux;
   using Elf_Versym = typename ELFT::Versym;
   using Elf_Hash = typename ELFT::Hash;
   using Elf_GnuHash = typename ELFT::GnuHash;
   using Elf_Nhdr = typename ELFT::Nhdr;
   using Elf_Note = typename ELFT::Note;
   using Elf_Note_Iterator = typename ELFT::NoteIterator;
   using Elf_Dyn_Range = typename ELFT::DynRange;
   using Elf_Shdr_Range = typename ELFT::ShdrRange;
   using Elf_Sym_Range = typename ELFT::SymRange;
   using Elf_Rel_Range = typename ELFT::RelRange;
   using Elf_Rela_Range = typename ELFT::RelaRange;
+  using Elf_Relr_Range = typename ELFT::RelrRange;
   using Elf_Phdr_Range = typename ELFT::PhdrRange;
 
   const uint8_t *base() const {
     return reinterpret_cast<const uint8_t *>(Buf.data());
   }
 
   size_t getBufSize() const { return Buf.size(); }
 
public:
 
   Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section) const;
   Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section,
                                              Elf_Shdr_Range Sections) const;
 
   StringRef getRelocationTypeName(uint32_t Type) const;
   void getRelocationTypeName(uint32_t Type,
                              SmallVectorImpl<char> &Result) const;
+  uint32_t getRelrRelocationType() const;
 
   /// Get the symbol for a given relocation.
   Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
                                                 const Elf_Shdr *SymTab) const;
 
   static Expected<ELFFile> create(StringRef Object);
 
   bool isMipsELF64() const {
public:
   Expected<Elf_Rela_Range> relas(const Elf_Shdr *Sec) const {
     return getSectionContentsAsArray<Elf_Rela>(Sec);
   }
 
   Expected<Elf_Rel_Range> rels(const Elf_Shdr *Sec) const {
     return getSectionContentsAsArray<Elf_Rel>(Sec);
   }
 
+  Expected<Elf_Relr_Range> relrs(const Elf_Shdr *Sec) const {
+    return getSectionContentsAsArray<Elf_Relr>(Sec);
+  }
+
+  Expected<std::vector<Elf_Rela>> decode_relrs(Elf_Relr_Range relrs) const;
+
   Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr *Sec) const;
 
   /// Iterate over program header table.
   Expected<Elf_Phdr_Range> program_headers() const {
     if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr))
       return createError("invalid e_phentsize");
     if (getHeader()->e_phoff +
             (getHeader()->e_phnum * getHeader()->e_phentsize) >
if (!isMipsELF64()) {
 
     Name = getRelocationTypeName(Type3);
     Result.append(1, '/');
     Result.append(Name.begin(), Name.end());
   }
 }
 
 template <class ELFT>
+uint32_t ELFFile<ELFT>::getRelrRelocationType() const {
+  return getELFRelrRelocationType(getHeader()->e_machine);
+}
+
+template <class ELFT>
 Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel *Rel,
                                    const Elf_Shdr *SymTab) const {
   uint32_t Index = Rel->getSymbol(isMips64EL());
   if (Index == 0)
     return nullptr;
   return getEntry<Elf_Sym>(SymTab, Index);
 }

llvm/trunk/include/llvm/Object/ELFTypes.h

public:
   using uint = typename std::conditional<Is64, uint64_t, uint32_t>::type;
   using Ehdr = Elf_Ehdr_Impl<ELFType<E, Is64>>;
   using Shdr = Elf_Shdr_Impl<ELFType<E, Is64>>;
   using Sym = Elf_Sym_Impl<ELFType<E, Is64>>;
   using Dyn = Elf_Dyn_Impl<ELFType<E, Is64>>;
   using Phdr = Elf_Phdr_Impl<ELFType<E, Is64>>;
   using Rel = Elf_Rel_Impl<ELFType<E, Is64>, false>;
   using Rela = Elf_Rel_Impl<ELFType<E, Is64>, true>;
+  using Relr = packed<uint>;
   using Verdef = Elf_Verdef_Impl<ELFType<E, Is64>>;
   using Verdaux = Elf_Verdaux_Impl<ELFType<E, Is64>>;
   using Verneed = Elf_Verneed_Impl<ELFType<E, Is64>>;
   using Vernaux = Elf_Vernaux_Impl<ELFType<E, Is64>>;
   using Versym = Elf_Versym_Impl<ELFType<E, Is64>>;
   using Hash = Elf_Hash_Impl<ELFType<E, Is64>>;
   using GnuHash = Elf_GnuHash_Impl<ELFType<E, Is64>>;
   using Chdr = Elf_Chdr_Impl<ELFType<E, Is64>>;
   using Nhdr = Elf_Nhdr_Impl<ELFType<E, Is64>>;
   using Note = Elf_Note_Impl<ELFType<E, Is64>>;
   using NoteIterator = Elf_Note_Iterator_Impl<ELFType<E, Is64>>;
   using CGProfile = Elf_CGProfile_Impl<ELFType<E, Is64>>;
   using DynRange = ArrayRef<Dyn>;
   using ShdrRange = ArrayRef<Shdr>;
   using SymRange = ArrayRef<Sym>;
   using RelRange = ArrayRef<Rel>;
   using RelaRange = ArrayRef<Rela>;
+  using RelrRange = ArrayRef<Relr>;
   using PhdrRange = ArrayRef<Phdr>;
 
   using Half = packed<uint16_t>;
   using Word = packed<uint32_t>;
   using Sword = packed<int32_t>;
   using Xword = packed<uint64_t>;
   using Sxword = packed<int64_t>;
   using Addr = packed<uint>;

llvm/trunk/lib/Object/ELF.cpp

#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
   default:
     break;
   }
   return "Unknown";
 }
 
 #undef ELF_RELOC
 
+uint32_t llvm::object::getELFRelrRelocationType(uint32_t Machine) {
+  switch (Machine) {
+  case ELF::EM_X86_64:
+    return ELF::R_X86_64_RELATIVE;
+  case ELF::EM_386:
+  case ELF::EM_IAMCU:
+    return ELF::R_386_RELATIVE;
+  case ELF::EM_MIPS:
+    break;
+  case ELF::EM_AARCH64:
+    return ELF::R_AARCH64_RELATIVE;
+  case ELF::EM_ARM:
+    return ELF::R_ARM_RELATIVE;
+  case ELF::EM_ARC_COMPACT:
+  case ELF::EM_ARC_COMPACT2:
+    return ELF::R_ARC_RELATIVE;
+  case ELF::EM_AVR:
+    break;
+  case ELF::EM_HEXAGON:
+    return ELF::R_HEX_RELATIVE;
+  case ELF::EM_LANAI:
+    break;
+  case ELF::EM_PPC:
+    break;
+  case ELF::EM_PPC64:
+    return ELF::R_PPC64_RELATIVE;
+  case ELF::EM_RISCV:
+    return ELF::R_RISCV_RELATIVE;
+  case ELF::EM_S390:
+    return ELF::R_390_RELATIVE;
+  case ELF::EM_SPARC:
+  case ELF::EM_SPARC32PLUS:
+  case ELF::EM_SPARCV9:
+    return ELF::R_SPARC_RELATIVE;
+  case ELF::EM_WEBASSEMBLY:
+    break;
+  case ELF::EM_AMDGPU:
+    break;
+  case ELF::EM_BPF:
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+
 StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
   switch (Machine) {
   case ELF::EM_ARM:
     switch (Type) {
       STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX);
       STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
       STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
       STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
switch (Type) {
     STRINGIFY_ENUM_CASE(ELF, SHT_REL);
     STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
     STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
     STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
     STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
     STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
+    STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
     STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
     STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
+    STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
   default:
     return "Unknown";
   }
 }
 
 template <class ELFT>
 Expected<std::vector<typename ELFT::Rela>>
+ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
+  // This function decodes the contents of an SHT_RELR packed relocation
+  // section.
+  //
+  // Proposal for adding SHT_RELR sections to generic-abi is here:
+  //   https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
+  //
+  // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
+  // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
+  //
+  // i.e. start with an address, followed by any number of bitmaps. The address
+  // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
+  // relocations each, at subsequent offsets following the last address entry.
+  //
+  // The bitmap entries must have 1 in the least significant bit. The assumption
+  // here is that an address cannot have 1 in lsb. Odd addresses are not
+  // supported.
+  //
+  // Excluding the least significant bit in the bitmap, each non-zero bit in
+  // the bitmap represents a relocation to be applied to a corresponding machine
+  // word that follows the base address word. The second least significant bit
+  // represents the machine word immediately following the initial address, and
+  // each bit that follows represents the next word, in linear order. As such,
+  // a single bitmap can encode up to 31 relocations in a 32-bit object, and
+  // 63 relocations in a 64-bit object.
+  //
+  // This encoding has a couple of interesting properties:
+  // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
+  //    even means address, odd means bitmap.
+  // 2. Just a simple list of addresses is a valid encoding.
+
+  Elf_Rela Rela;
+  Rela.r_info = 0;
+  Rela.r_addend = 0;
+  Rela.setType(getRelrRelocationType(), false);
+  std::vector<Elf_Rela> Relocs;
+
+  // Word type: uint32_t for Elf32, and uint64_t for Elf64.
+  typedef typename ELFT::uint Word;
+
+  // Word size in number of bytes.
+  const size_t WordSize = sizeof(Word);
+
+  // Number of bits used for the relocation offsets bitmap.
+  // These many relative relocations can be encoded in a single entry.
+  const size_t NBits = 8*WordSize - 1;
+
+  Word Base = 0;
+  for (const Elf_Relr &R : relrs) {
+    Word Entry = R;
+    if ((Entry&1) == 0) {
+      // Even entry: encodes the offset for next relocation.
+      Rela.r_offset = Entry;
+      Relocs.push_back(Rela);
+      // Set base offset for subsequent bitmap entries.
+      Base = Entry + WordSize;
+      continue;
+    }
+
+    // Odd entry: encodes bitmap for relocations starting at base.
+    Word Offset = Base;
+    while (Entry != 0) {
+      Entry >>= 1;
+      if ((Entry&1) != 0) {
+        Rela.r_offset = Offset;
+        Relocs.push_back(Rela);
+      }
+      Offset += WordSize;
+    }
+
+    // Advance base offset by NBits words.
+    Base += NBits * WordSize;
+  }
+
+  return Relocs;
+}
+
+template <class ELFT>
+Expected<std::vector<typename ELFT::Rela>>
 ELFFile<ELFT>::android_relas(const Elf_Shdr *Sec) const {
   // This function reads relocations in Android's packed relocation format,
   // which is based on SLEB128 and delta encoding.
   Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
   if (!ContentsOrErr)
     return ContentsOrErr.takeError();
   const uint8_t *Cur = ContentsOrErr->begin();
   const uint8_t *End = ContentsOrErr->end();

llvm/trunk/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(SHT_REL);
   ECase(SHT_SHLIB);
   ECase(SHT_DYNSYM);
   ECase(SHT_INIT_ARRAY);
   ECase(SHT_FINI_ARRAY);
   ECase(SHT_PREINIT_ARRAY);
   ECase(SHT_GROUP);
   ECase(SHT_SYMTAB_SHNDX);
+  ECase(SHT_RELR);
   ECase(SHT_LOOS);
   ECase(SHT_ANDROID_REL);
   ECase(SHT_ANDROID_RELA);
+  ECase(SHT_ANDROID_RELR);
   ECase(SHT_LLVM_ODRTAB);
   ECase(SHT_LLVM_LINKER_OPTIONS);
   ECase(SHT_LLVM_CALL_GRAPH_PROFILE);
   ECase(SHT_GNU_ATTRIBUTES);
   ECase(SHT_GNU_HASH);
   ECase(SHT_GNU_verdef);
   ECase(SHT_GNU_verneed);
   ECase(SHT_GNU_versym);

llvm/trunk/test/tools/llvm-readobj/Inputs/elf-relr-relocs1.s

+.quad 0x0000000000010d60  // Initial offset
+.quad 0x0000000000000103  // Continuation bitmap
+.quad 0x0000000000020000  // New offset
+.quad 0x00000000000f0501  // Continuation bitmap
+.quad 0x000a700550400009  // Continuation bitmap

llvm/trunk/test/tools/llvm-readobj/Inputs/elf-relr-relocs2.s

+.long 0x00010d60  // Initial offset
+.long 0x00000103  // Continuation bitmap
+.long 0x00020000  // New offset
+.long 0x000f0501  // Continuation bitmap
+.long 0x50400009  // Continuation bitmap

llvm/trunk/test/tools/llvm-readobj/elf-relr-relocs.test

+# The binary blobs in this file were created like this:
+# llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu Inputs/elf-relr-relocs1.s -o - | obj2yaml | grep Content:
+
+# RUN: yaml2obj -docnum 1 %s \
+# RUN:   | llvm-readobj -elf-output-style=LLVM -relocations -raw-relr - \
+# RUN:   | FileCheck --check-prefix=RAW-LLVM1 %s
+# RAW-LLVM1:      Section (1) .relr.dyn {
+# RAW-LLVM1-NEXT:   0x10D60
+# RAW-LLVM1-NEXT:   0x103
+# RAW-LLVM1-NEXT:   0x20000
+# RAW-LLVM1-NEXT:   0xF0501
+# RAW-LLVM1-NEXT:   0xA700550400009
+# RAW-LLVM1-NEXT: }
+
+# RUN: yaml2obj -docnum 1 %s \
+# RUN:   | llvm-readobj -elf-output-style=LLVM -relocations - \
+# RUN:   | FileCheck --check-prefix=LLVM1 %s
+# LLVM1:      Section (1) .relr.dyn {
+# LLVM1-NEXT:   0x10D60 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x10D68 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x10DA0 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20000 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20040 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20050 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20080 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20088 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20090 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20098 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20210 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x202A8 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x202D8 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x202E8 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x202F8 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20308 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20358 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20360 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20368 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20380 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT:   0x20390 R_X86_64_RELATIVE - 0x0
+# LLVM1-NEXT: }
+
+# RUN: yaml2obj -docnum 1 %s \
+# RUN:   | llvm-readobj -elf-output-style=GNU -relocations -raw-relr - \
+# RUN:   | FileCheck --check-prefix=RAW-GNU1 %s
+# RAW-GNU1:      Relocation section '.relr.dyn' at offset 0x180 contains 5 entries:
+# RAW-GNU1:      0000000000010d60
+# RAW-GNU1-NEXT: 0000000000000103
+# RAW-GNU1-NEXT: 0000000000020000
+# RAW-GNU1-NEXT: 00000000000f0501
+# RAW-GNU1-NEXT: 000a700550400009
+
+# RUN: yaml2obj -docnum 1 %s \
+# RUN:   | llvm-readobj -elf-output-style=GNU -relocations - \
+# RUN:   | FileCheck --check-prefix=GNU1 %s
+# GNU1:      Relocation section '.relr.dyn' at offset 0x180 contains 21 entries:
+# GNU1:      0000000000010d60  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000010d68  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000010da0  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020000  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020040  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020050  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020080  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020088  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020090  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020098  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020210  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 00000000000202a8  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 00000000000202d8  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 00000000000202e8  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 00000000000202f8  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020308  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020358  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020360  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020368  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020380  0000000000000008 R_X86_64_RELATIVE
+# GNU1-NEXT: 0000000000020390  0000000000000008 R_X86_64_RELATIVE
+
+# elf-relr-relocs1.s
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+  Entry:           0x0000000000001000
+Sections:
+  - Name:            .relr.dyn
+    Type:            SHT_RELR
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x00000000000001C8
+    Link:            .symtab
+    AddressAlign:    0x0000000000000001
+    Content:         600D0100000000000301000000000000000002000000000001050F00000000000900405005700A00
+...
+
+# RUN: yaml2obj -docnum 2 %s \
+# RUN:   | llvm-readobj -elf-output-style=LLVM -relocations -raw-relr - \
+# RUN:   | FileCheck --check-prefix=RAW-LLVM2 %s
+# RAW-LLVM2:      Section (1) .relr.dyn {
+# RAW-LLVM2-NEXT:   0x10D60
+# RAW-LLVM2-NEXT:   0x103
+# RAW-LLVM2-NEXT:   0x20000
+# RAW-LLVM2-NEXT:   0xF0501
+# RAW-LLVM2-NEXT:   0x50400009
+# RAW-LLVM2-NEXT: }
+
+# RUN: yaml2obj -docnum 2 %s \
+# RUN:   | llvm-readobj -elf-output-style=LLVM -relocations - \
+# RUN:   | FileCheck --check-prefix=LLVM2 %s
+# LLVM2:      Section (1) .relr.dyn {
+# LLVM2-NEXT:   0x10D60 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x10D64 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x10D80 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20000 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20020 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20028 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20040 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20044 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20048 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x2004C R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x20088 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x200D4 R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x200EC R_386_RELATIVE - 0x0
+# LLVM2-NEXT:   0x200F4 R_386_RELATIVE - 0x0
+# LLVM2-NEXT: }
+
+# RUN: yaml2obj -docnum 2 %s \
+# RUN:   | llvm-readobj -elf-output-style=GNU -relocations -raw-relr - \
+# RUN:   | FileCheck --check-prefix=RAW-GNU2 %s
+# RAW-GNU2:      Relocation section '.relr.dyn' at offset 0xfc contains 5 entries:
+# RAW-GNU2:      00010d60
+# RAW-GNU2-NEXT: 00000103
+# RAW-GNU2-NEXT: 00020000
+# RAW-GNU2-NEXT: 000f0501
+# RAW-GNU2-NEXT: 50400009
+
+# RUN: yaml2obj -docnum 2 %s \
+# RUN:   | llvm-readobj -elf-output-style=GNU -relocations - \
+# RUN:   | FileCheck --check-prefix=GNU2 %s
+# GNU2:      Relocation section '.relr.dyn' at offset 0xfc contains 14 entries:
+# GNU2:      00010d60  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00010d64  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00010d80  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020000  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020020  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020028  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020040  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020044  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020048  00000008 R_386_RELATIVE
+# GNU2-NEXT: 0002004c  00000008 R_386_RELATIVE
+# GNU2-NEXT: 00020088  00000008 R_386_RELATIVE
+# GNU2-NEXT: 000200d4  00000008 R_386_RELATIVE
+# GNU2-NEXT: 000200ec  00000008 R_386_RELATIVE
+# GNU2-NEXT: 000200f4  00000008 R_386_RELATIVE
+
+# elf-relr-relocs2.s
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_386
+  Entry:           0x00001000
+Sections:
+  - Name:            .relr.dyn
+    Type:            SHT_RELR
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x000001C8
+    Link:            .symtab
+    AddressAlign:    0x00000001
+    Content:         600D0100030100000000020001050F0009004050
+...

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

#define TYPEDEF_ELF_TYPES(ELFT)                                                \
   using ELFO = ELFFile<ELFT>;                                                  \
   using Elf_Addr = typename ELFT::Addr;                                        \
   using Elf_Shdr = typename ELFT::Shdr;                                        \
   using Elf_Sym = typename ELFT::Sym;                                          \
   using Elf_Dyn = typename ELFT::Dyn;                                          \
   using Elf_Dyn_Range = typename ELFT::DynRange;                               \
   using Elf_Rel = typename ELFT::Rel;                                          \
   using Elf_Rela = typename ELFT::Rela;                                        \
+  using Elf_Relr = typename ELFT::Relr;                                        \
   using Elf_Rel_Range = typename ELFT::RelRange;                               \
   using Elf_Rela_Range = typename ELFT::RelaRange;                             \
+  using Elf_Relr_Range = typename ELFT::RelrRange;                             \
   using Elf_Phdr = typename ELFT::Phdr;                                        \
   using Elf_Half = typename ELFT::Half;                                        \
   using Elf_Ehdr = typename ELFT::Ehdr;                                        \
   using Elf_Word = typename ELFT::Word;                                        \
   using Elf_Hash = typename ELFT::Hash;                                        \
   using Elf_GnuHash = typename ELFT::GnuHash;                                  \
   using Elf_Note  = typename ELFT::Note;                                       \
   using Elf_Sym_Range = typename ELFT::SymRange;                               \
StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
                              bool &IsDefault) const;
   void LoadVersionMap() const;
   void LoadVersionNeeds(const Elf_Shdr *ec) const;
   void LoadVersionDefs(const Elf_Shdr *sec) const;
 
   const ELFO *Obj;
   DynRegionInfo DynRelRegion;
   DynRegionInfo DynRelaRegion;
+  DynRegionInfo DynRelrRegion;
   DynRegionInfo DynPLTRelRegion;
   DynRegionInfo DynSymRegion;
   DynRegionInfo DynamicTable;
   StringRef DynamicStringTable;
   StringRef SOName;
   const Elf_Hash *HashTable = nullptr;
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
public:
   }
 
   Elf_Sym_Range dynamic_symbols() const {
     return DynSymRegion.getAsArrayRef<Elf_Sym>();
   }
 
   Elf_Rel_Range dyn_rels() const;
   Elf_Rela_Range dyn_relas() const;
+  Elf_Relr_Range dyn_relrs() const;
   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
                                 bool IsDynamic) const;
   void getSectionNameIndex(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
                            StringRef &SectionName,
                            unsigned &SectionIndex) const;
   StringRef getStaticSymbolName(uint32_t Index) const;
 
   void printSymbolsHelper(bool IsDynamic) const;
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
   const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; }
   ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
   StringRef getDynamicStringTable() const { return DynamicStringTable; }
   const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
   const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
+  const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; }
   const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
   const Elf_Hash *getHashTable() const { return HashTable; }
   const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; }
 };
 
 template <class ELFT>
 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
   StringRef StrTable, SymtabName;
formatted_raw_ostream &printField(struct Field F) {
     if (F.Column != 0)
       OS.PadToColumn(F.Column);
     OS << F.Str;
     OS.flush();
     return OS;
   }
   void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym,
                          StringRef StrTable, uint32_t Bucket);
+  void printRelocHeader(unsigned SType);
   void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                        const Elf_Rela &R, bool IsRela);
   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);
case ELF::DT_REL:
       DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
       break;
     case ELF::DT_RELSZ:
       DynRelRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELENT:
       DynRelRegion.EntSize = Dyn.getVal();
       break;
+    case ELF::DT_RELR:
+    case ELF::DT_ANDROID_RELR:
+      DynRelrRegion.Addr = toMappedAddr(Dyn.getPtr());
+      break;
+    case ELF::DT_RELRSZ:
+    case ELF::DT_ANDROID_RELRSZ:
+      DynRelrRegion.Size = Dyn.getVal();
+      break;
+    case ELF::DT_RELRENT:
+    case ELF::DT_ANDROID_RELRENT:
+      DynRelrRegion.EntSize = Dyn.getVal();
+      break;
     case ELF::DT_PLTREL:
       if (Dyn.getVal() == DT_REL)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
       else if (Dyn.getVal() == DT_RELA)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
       else
         reportError(Twine("unknown DT_PLTREL value of ") +
                     Twine((uint64_t)Dyn.getVal()));
typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const {
   return DynRelRegion.getAsArrayRef<Elf_Rel>();
 }
 
 template <typename ELFT>
 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
   return DynRelaRegion.getAsArrayRef<Elf_Rela>();
 }
 
+template <typename ELFT>
+typename ELFDumper<ELFT>::Elf_Relr_Range ELFDumper<ELFT>::dyn_relrs() const {
+  return DynRelrRegion.getAsArrayRef<Elf_Relr>();
+}
+
 template<class ELFT>
 void ELFDumper<ELFT>::printFileHeaders() {
   ELFDumperStyle->printFileHeaders(Obj);
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printSections() {
   ELFDumperStyle->printSections(Obj);
if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                                      const Elf_Rela &R, bool IsRela) {
   std::string Offset, Info, Addend, Value;
   SmallString<32> RelocName;
-  StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
   StringRef TargetName;
   const Elf_Sym *Sym = nullptr;
   unsigned Width = ELFT::Is64Bits ? 16 : 8;
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
 
   // First two fields are bit width dependent. The rest of them are after are
   // fixed width.
   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
   Sym = unwrapOrError(Obj->getRelocationSymbol(&R, SymTab));
   if (Sym && Sym->getType() == ELF::STT_SECTION) {
     const Elf_Shdr *Sec = unwrapOrError(
         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
     TargetName = unwrapOrError(Obj->getSectionName(Sec));
   } else if (Sym) {
+    StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
     TargetName = unwrapOrError(Sym->getName(StrTable));
   }
 
   if (Sym && IsRela) {
     if (R.r_addend < 0)
       Addend = " - ";
     else
       Addend = " + ";
void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
   Fields[3].Str = Value;
   Fields[4].Str = TargetName;
   for (auto &field : Fields)
     printField(field);
   OS << Addend;
   OS << "\n";
 }
 
-static inline void printRelocHeader(raw_ostream &OS, bool Is64, bool IsRela) {
-  if (Is64)
-    OS << "    Offset             Info             Type"
+template <class ELFT> void GNUStyle<ELFT>::printRelocHeader(unsigned SType) {
+  bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA;
+  bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR;
+  if (ELFT::Is64Bits)
+    OS << "    ";
+  else
+    OS << " ";
+  if (IsRelr && opts::RawRelr)
+    OS << "Data  ";
+  else
+    OS << "Offset";
+  if (ELFT::Is64Bits)
+    OS << "             Info             Type"
        << "               Symbol's Value  Symbol's Name";
   else
-    OS << " Offset     Info    Type                Sym. Value  "
-       << "Symbol's Name";
+    OS << "     Info    Type                Sym. Value  Symbol's Name";
   if (IsRela)
-    OS << (IsRela ? " + Addend" : "");
+    OS << " + Addend";
   OS << "\n";
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) {
   bool HasRelocSections = false;
   for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
-    if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA &&
+    if (Sec.sh_type != ELF::SHT_REL &&
+        Sec.sh_type != ELF::SHT_RELA &&
+        Sec.sh_type != ELF::SHT_RELR &&
         Sec.sh_type != ELF::SHT_ANDROID_REL &&
-        Sec.sh_type != ELF::SHT_ANDROID_RELA)
+        Sec.sh_type != ELF::SHT_ANDROID_RELA &&
+        Sec.sh_type != ELF::SHT_ANDROID_RELR)
       continue;
     HasRelocSections = true;
     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
     unsigned Entries = Sec.getEntityCount();
     std::vector<Elf_Rela> AndroidRelas;
     if (Sec.sh_type == ELF::SHT_ANDROID_REL ||
         Sec.sh_type == ELF::SHT_ANDROID_RELA) {
       // Android's packed relocation section needs to be unpacked first
       // to get the actual number of entries.
       AndroidRelas = unwrapOrError(Obj->android_relas(&Sec));
       Entries = AndroidRelas.size();
     }
+    std::vector<Elf_Rela> RelrRelas;
+    if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR ||
+                           Sec.sh_type == ELF::SHT_ANDROID_RELR)) {
+      // .relr.dyn relative relocation section needs to be unpacked first
+      // to get the actual number of entries.
+      Elf_Relr_Range Relrs = unwrapOrError(Obj->relrs(&Sec));
+      RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
+      Entries = RelrRelas.size();
+    }
     uintX_t Offset = Sec.sh_offset;
     OS << "\nRelocation section '" << Name << "' at offset 0x"
        << to_hexString(Offset, false) << " contains " << Entries
        << " entries:\n";
-    printRelocHeader(OS, ELFT::Is64Bits,
-                     Sec.sh_type == ELF::SHT_RELA ||
-                         Sec.sh_type == ELF::SHT_ANDROID_RELA);
+    printRelocHeader(Sec.sh_type);
     const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec.sh_link));
     switch (Sec.sh_type) {
     case ELF::SHT_REL:
       for (const auto &R : unwrapOrError(Obj->rels(&Sec))) {
         Elf_Rela Rela;
         Rela.r_offset = R.r_offset;
         Rela.r_info = R.r_info;
         Rela.r_addend = 0;
         printRelocation(Obj, SymTab, Rela, false);
       }
       break;
     case ELF::SHT_RELA:
       for (const auto &R : unwrapOrError(Obj->relas(&Sec)))
         printRelocation(Obj, SymTab, R, true);
       break;
+    case ELF::SHT_RELR:
+    case ELF::SHT_ANDROID_RELR:
+      if (opts::RawRelr)
+        for (const auto &R : unwrapOrError(Obj->relrs(&Sec)))
+          OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8))
+             << "\n";
+      else
+        for (const auto &R : RelrRelas)
+          printRelocation(Obj, SymTab, R, false);
+      break;
     case ELF::SHT_ANDROID_REL:
     case ELF::SHT_ANDROID_RELA:
       for (const auto &R : AndroidRelas)
         printRelocation(Obj, SymTab, R, Sec.sh_type == ELF::SHT_ANDROID_RELA);
       break;
     }
   }
   if (!HasRelocSections)
std::string getSectionTypeString(unsigned Arch, unsigned Type) {
   case SHT_FINI_ARRAY:
     return "FINI_ARRAY";
   case SHT_PREINIT_ARRAY:
     return "PREINIT_ARRAY";
   case SHT_GROUP:
     return "GROUP";
   case SHT_SYMTAB_SHNDX:
     return "SYMTAB SECTION INDICES";
+  case SHT_RELR:
+  case SHT_ANDROID_RELR:
+    return "RELR";
   case SHT_LLVM_ODRTAB:
     return "LLVM_ODRTAB";
   case SHT_LLVM_LINKER_OPTIONS:
     return "LLVM_LINKER_OPTIONS";
   case SHT_LLVM_CALL_GRAPH_PROFILE:
     return "LLVM_CALL_GRAPH_PROFILE";
   // FIXME: Parse processor specific GNU attributes
   case SHT_GNU_ATTRIBUTES:
void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R,
   OS << Addend;
   OS << "\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
+  const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
   if (DynRelaRegion.Size > 0) {
     OS << "\n'RELA' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) -
                          Obj->base(),
                      1) << " contains " << DynRelaRegion.Size << " bytes:\n";
-    printRelocHeader(OS, ELFT::Is64Bits, true);
+    printRelocHeader(ELF::SHT_RELA);
     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
       printDynamicRelocation(Obj, Rela, true);
   }
   if (DynRelRegion.Size > 0) {
     OS << "\n'REL' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) -
                          Obj->base(),
                      1) << " contains " << DynRelRegion.Size << " bytes:\n";
-    printRelocHeader(OS, ELFT::Is64Bits, false);
+    printRelocHeader(ELF::SHT_REL);
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
       Elf_Rela Rela;
       Rela.r_offset = Rel.r_offset;
       Rela.r_info = Rel.r_info;
       Rela.r_addend = 0;
       printDynamicRelocation(Obj, Rela, false);
     }
   }
+  if (DynRelrRegion.Size > 0) {
+    OS << "\n'RELR' relocation section at offset "
+       << format_hex(reinterpret_cast<const uint8_t *>(DynRelrRegion.Addr) -
+                         Obj->base(),
+                     1) << " contains " << DynRelrRegion.Size << " bytes:\n";
+    printRelocHeader(ELF::SHT_REL);
+    Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
+    std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
+    for (const Elf_Rela &Rela : RelrRelas) {
+      printDynamicRelocation(Obj, Rela, false);
+    }
+  }
   if (DynPLTRelRegion.Size) {
     OS << "\n'PLT' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) -
                          Obj->base(),
                      1) << " contains " << DynPLTRelRegion.Size << " bytes:\n";
   }
   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
-    printRelocHeader(OS, ELFT::Is64Bits, true);
+    printRelocHeader(ELF::SHT_RELA);
     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
       printDynamicRelocation(Obj, Rela, true);
   } else {
-    printRelocHeader(OS, ELFT::Is64Bits, false);
+    printRelocHeader(ELF::SHT_REL);
     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
       Elf_Rela Rela;
       Rela.r_offset = Rel.r_offset;
       Rela.r_info = Rel.r_info;
       Rela.r_addend = 0;
       printDynamicRelocation(Obj, Rela, false);
     }
   }

 
 template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) {
   ListScope D(W, "Relocations");
 
   int SectionNumber = -1;
   for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
     ++SectionNumber;
 
-    if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA &&
+    if (Sec.sh_type != ELF::SHT_REL &&
+        Sec.sh_type != ELF::SHT_RELA &&
+        Sec.sh_type != ELF::SHT_RELR &&
         Sec.sh_type != ELF::SHT_ANDROID_REL &&
-        Sec.sh_type != ELF::SHT_ANDROID_RELA)
+        Sec.sh_type != ELF::SHT_ANDROID_RELA &&
+        Sec.sh_type != ELF::SHT_ANDROID_RELR)
       continue;
 
     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
 
     W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
     W.indent();
 
     printRelocations(&Sec, Obj);
for (const Elf_Rel &R : unwrapOrError(Obj->rels(Sec))) {
       Rela.r_addend = 0;
       printRelocation(Obj, Rela, SymTab);
     }
     break;
   case ELF::SHT_RELA:
     for (const Elf_Rela &R : unwrapOrError(Obj->relas(Sec)))
       printRelocation(Obj, R, SymTab);
     break;
+  case ELF::SHT_RELR:
+  case ELF::SHT_ANDROID_RELR: {
+    Elf_Relr_Range Relrs = unwrapOrError(Obj->relrs(Sec));
+    if (opts::RawRelr) {
+      for (const Elf_Relr &R : Relrs)
+        W.startLine() << W.hex(R) << "\n";
+    } else {
+      std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
+      for (const Elf_Rela &R : RelrRelas)
+        printRelocation(Obj, R, SymTab);
+    }
+    break;
+  }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     for (const Elf_Rela &R : unwrapOrError(Obj->android_relas(Sec)))
       printRelocation(Obj, R, SymTab);
     break;
   }
 }
 
void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
   ListScope Group(W, "DynamicSymbols");
   this->dumper()->printSymbolsHelper(true);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
+  const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
   if (DynRelRegion.Size && DynRelaRegion.Size)
     report_fatal_error("There are both REL and RELA dynamic relocations");
   W.startLine() << "Dynamic Relocations {\n";
   W.indent();
   if (DynRelaRegion.Size > 0)
     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
       printDynamicRelocation(Obj, Rela);
   else
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
       Elf_Rela Rela;
       Rela.r_offset = Rel.r_offset;
       Rela.r_info = Rel.r_info;
       Rela.r_addend = 0;
       printDynamicRelocation(Obj, Rela);
     }
+  if (DynRelrRegion.Size > 0) {
+    Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
+    std::vector<Elf_Rela> RelrRelas = unwrapOrError(Obj->decode_relrs(Relrs));
+    for (const Elf_Rela &Rela : RelrRelas)
+      printDynamicRelocation(Obj, Rela);
+  }
   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
       printDynamicRelocation(Obj, Rela);
   else
     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
       Elf_Rela Rela;
       Rela.r_offset = Rel.r_offset;
       Rela.r_info = Rel.r_info;

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

namespace opts {
   extern llvm::cl::opt<bool> SectionRelocations;
   extern llvm::cl::opt<bool> SectionSymbols;
   extern llvm::cl::opt<bool> SectionData;
   extern llvm::cl::opt<bool> Relocations;
   extern llvm::cl::opt<bool> Symbols;
   extern llvm::cl::opt<bool> DynamicSymbols;
   extern llvm::cl::opt<bool> UnwindInfo;
   extern llvm::cl::opt<bool> ExpandRelocs;
+  extern llvm::cl::opt<bool> RawRelr;
   extern llvm::cl::opt<bool> CodeView;
   extern llvm::cl::opt<bool> CodeViewSubsectionBytes;
   extern llvm::cl::opt<bool> ARMAttributes;
   extern llvm::cl::opt<bool> MipsPLTGOT;
   enum OutputStyleTy { LLVM, GNU };
   extern llvm::cl::opt<OutputStyleTy> Output;
 } // namespace opts
 
 #define LLVM_READOBJ_ENUM_ENT(ns, enum) \
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
   { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
 
 #endif

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

namespace opts {
   // -gnu-hash-table
   cl::opt<bool> GnuHashTable("gnu-hash-table",
     cl::desc("Display ELF .gnu.hash section"));
 
   // -expand-relocs
   cl::opt<bool> ExpandRelocs("expand-relocs",
     cl::desc("Expand each shown relocation to multiple lines"));
 
+  // -raw-relr
+  cl::opt<bool> RawRelr("raw-relr",
+    cl::desc("Do not decode relocations in SHT_RELR section, display raw contents"));
+
   // -codeview
   cl::opt<bool> CodeView("codeview",
                          cl::desc("Display CodeView debug information"));
 
   // -codeview-merged-types
   cl::opt<bool>
       CodeViewMergedTypes("codeview-merged-types",
                           cl::desc("Display the merged CodeView type stream"));

llvm/trunk/tools/yaml2obj/yaml2elf.cpp

 template <class ELFT>
 class ELFState {
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
+  typedef typename ELFT::Relr Elf_Relr;
 
   enum class SymtabType { Static, Dynamic };
 
   /// The future ".strtab" section.
   StringTableBuilder DotStrtab{StringTableBuilder::ELF};
 
   /// The future ".shstrtab" section.
   StringTableBuilder DotShStrtab{StringTableBuilder::ELF};
ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                     ContiguousBlobAccumulator &CBA) {
   assert(Section.Size >= Section.Content.binary_size() &&
          "Section size and section content are inconsistent");
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   Section.Content.writeAsBinary(OS);
   for (auto i = Section.Content.binary_size(); i < Section.Size; ++i)
     OS.write(0);
+  if (Section.Type == llvm::ELF::SHT_RELR)
+    SHeader.sh_entsize = sizeof(Elf_Relr);
+  else
     SHeader.sh_entsize = 0;
   SHeader.sh_size = Section.Size;
 }
 
 static bool isMips64EL(const ELFYAML::Object &Doc) {
   return Doc.Header.Machine == ELFYAML::ELF_EM(llvm::ELF::EM_MIPS) &&
          Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
          Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
 }