[yaml2obj/obj2yaml] - Add support for SHT_RELR sections.

[grimar]

Summary

The encoded sequence of Elf*_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(31)
relocations each, at subsequent offsets following the last address entry.

More information is here:
https://github.com/llvm-mirror/llvm/blob/master/lib/Object/ELF.cpp#L272

This patch adds a support for these sections.

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1106

I wonder if we should call this field just "Values"?

[grimar]

Going to improve test cases and add a forgotten obj2yaml test.

[grimar]

• Rename OffsetsAndBitmaps to Entries.
• Improved, added tests.

[MaskRay]

llvm/include/llvm/ObjectYAML/ELFYAML.h

444

Why not RelrSection? Introducing a new term RelocationOffsets may be more confusing.

llvm/lib/ObjectYAML/ELFYAML.cpp

1106

I prefer Entries. 1) We already use Entries for some other sections. 2) Entries is the term used in the ELF spec proposal.

SHT_RELR: The section holds relative relocation entries without explicit
          addends or info, such as type Elf32_Relr for the 32-bit class of
          object files or type Elf64_Relr for the 64-bit class of object
          files. An object file may have multiple relocation sections. See
          ``Relocation'' below for details.

llvm/test/tools/obj2yaml/relr-section.yaml

20 ↗

(On Diff #235323)

To make examples more plausible: use even numbers. Odd numbers not preceded by an even number are invalid.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

2

This is a test to test -> Test

36

It seems the comments can be deleted.

The indentation of the continuation line is strange.

llvm/tools/obj2yaml/elf2yaml.cpp

750

Why can the error be swallowed?

[grimar]

• Addressed review comments.

llvm/include/llvm/ObjectYAML/ELFYAML.h

444

I've renamed to RelrSection. I guess we might want to rename RelocationSection to RelSection too for consistency.

llvm/lib/ObjectYAML/ELFYAML.cpp

1106

Yeah. I initially called this field "OffsetsAndBitmaps", suggested "Values", but then renamed to "Entries" because of the same reasons you mention.

llvm/test/tools/obj2yaml/relr-section.yaml

20 ↗

(On Diff #235323)

Odd numbers not preceded by an even number are invalid.

Sure, but in obj2yaml we do not need to care about such things. Moreover, we probably want to check
exactly this cases, because one of the tasks of obj2yaml is to produce the output from any given object.
Object can be valid or can be not. We only want to show that we use "Entries" when data size % 64(32) == 0.

The same applies for yaml2obj probably.

llvm/tools/obj2yaml/elf2yaml.cpp

750

If we can't read the content as array of ELF_Relr, we fall back to read it as an array of uint8_ts.
We do not need to trigger any errors, because while we are able to dump it at least with use of "Content",
we are fine. If we can't do that, the appropriate error will be reported below.

I could just read the whole content as array from the begining and then write checks, like "if (Size % sizeof(uintX_t) != 0)",
and then read values manually, but I supposed the code looks a bit simpler in this way.

[MaskRay]

This is new code.. Perhaps give @jhenderson a chance to review if you are not in a hurry.

llvm/lib/ObjectYAML/ELFEmitter.cpp

839

the parentheses around uint64_t can be deleted.

846

Hex64 is a small, trivially copyable type. Consider dropping const &.

llvm/tools/obj2yaml/elf2yaml.cpp

747

Nit: when there is a choice between push_back and emplace_back with the same arguments, push_back may be more readable, because push_back expresses the intent more specifically.

For example, for std::vector<std::vector<int>> a, it accepts a.emplace_back(10) but not a.push_back(10). push_back makes the reader think less.

[grimar]

• Addressed review comments.

llvm/tools/obj2yaml/elf2yaml.cpp

747

I can't use push_back here:

Error	C2664	'void std::vector<llvm::yaml::Hex64,std::allocator<_Ty>>::push_back(_Ty &&)':
cannot convert argument 1 from 'llvm::support::detail::packed_endian_specific_integral<uint64_t,llvm::support::little,1,1>'
to 'const _Ty &'	obj2yaml	D:\Work3\LLVM\llvm-project\llvm\tools\obj2yaml\elf2yaml.cpp	745

It happens because Entries is a std::vector<llvm::yaml::Hex64>.
I need to insert Elf_Relr, which is packed<uint>.
emplace_back is needed to use Hex64's constructor: Hex64(const uint64_t v)

[jhenderson]

llvm/include/llvm/ObjectYAML/ELFYAML.h

444

RelocationSection refers to both SHT_REL and SHT_RELA sections, right? Renaming to RelSection implies it's just for the former, to me.

llvm/lib/ObjectYAML/ELFEmitter.cpp

113

Maybe you should just use typedef for consistency with the code above. I actually would find this harder to read as is if I read the whole block at once.

llvm/lib/ObjectYAML/ELFYAML.cpp

1455–1456

ROS -> RS

(what does the 'O' stand for...?)

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

5

I don't think this comment line here is necessary. It's implicit, since you actually check it below. (Why not also say, "that the sh_link and sh_info is 0"?)

35

Is this important to the test?

39

Perhaps worth changing this comment to say "Test that the content of SHT_RELR sections for 64-bits BE targets is correct".

I might also avoid abbreviating LE/BE in the comments (i.e. use "little endian" and "big endian").

62

Same comments as above for the 32-bit cases.

174

Maybe worth making this explicitly 1 greater than the max (and adding a similar test for the 32-bit max case).

llvm/tools/obj2yaml/elf2yaml.cpp

750

I'd write "We are going to dump the data as raw content below."

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

113

OK. I think I had an oppsoite comments before (not from you). About switching to "using".
That is why I did it.
I think we can change the whole block to using at once later.

llvm/lib/ObjectYAML/ELFYAML.cpp

1455–1456

RelOcationSection I guess... fixed.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

5

Mostly it was done because I set sh_entsize in the code of this patch.
I find your comment valid though, so I've removed this line.

35

Why not? It makes sence to show we do not drop a flag specified.
Indeed it is not a full test for this bit, but it tests something and is better than nothing.
(I do not feel we want to test much more than that atm).

Your comment was usefull for other tests below though, where I've removed the Flags field.

39

Done.

FTR. I am not sure about LE/BE -> "little endian" and "big endian" conversion,
because I think that LE/BE are common abbreviations.

174

Done.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

113

Right. I agree that in general using is easier to read, so I'd certainly support switching over wholesale in this area at another point.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

4

64-bits -> 64-bit

(a target is described as being a 64/32-bit target - other places 64-bits would be correct).

35

Indeed it is not a full test for this bit, but it tests something and is better than nothing.

Okay. I think it needs a comment to explain why it is tested then. Perhaps something along the lines of "Show that relr section dumping maintains common section properties such as flags." (there may be a clearer or more concise phrasing)

[grimar]

• Addressed review comments.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

4

(I hope I got it right)

Fixed here and in 3 more similar places in this test.
I've kept other comments, particularry one in obj2yaml/relr-section.yaml
("Test how we dump SHT_RELR sections for 32 and 64-bits targets.") unchanged.

35

Perhaps something along the lines of "Show that relr section dumping maintains common section properties such as flags." (there may be a clearer or more concise phrasing)

It is not about a dumping probably? We are testing yaml2obj here.
I've added four "## Set an arbitrary flag to demonstrate it is not dropped." comments around.
Does it look OK for you?

[jhenderson]

llvm/test/tools/obj2yaml/relr-section.yaml

1 ↗

(On Diff #238187)

Please update this 64-bits -> 64-bit too.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

4

After thinking about it yesterday, I think I figured out the rule. When 32/64-bit is used as an adjective followed by a noun (e.g. "This is a 64-bit target"), it shouldn't have the 's', whereas when it is used without a following noun (e.g. "This target is 64-bits"), it should.

Aside from the obj2yaml/relr-section.yaml case (which should be updated), I couldn't find any other 64-bits usage in comments in this patch. Which were the others you were referring to?

35

I'd change "it is not dropped" -> "flags are set when requested" perhaps. Otherwise, looks good.

[grimar]

• Addressed review comments.

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

4

After thinking about it yesterday, I think I figured out the rule. When 32/64-bit is used as an adjective followed by a noun (e.g. "This is a 64-bit target"), it shouldn't have the 's', whereas when it is used without a following noun (e.g. "This target is 64-bits"), it should.

Interesting. I am usually simply thinking about "s" as about suffix for a plural form of a noun. In Russian the correct spelling for a simple straightforward translation of "64-bit/64-bits" would be different for "target" and "targets" cases.
(In the "Test that the content of SHT_RELR sections for 64-bit little endian targets is correct." sentence I mean).
That is where my confuson here comes from I think.

Aside from the obj2yaml/relr-section.yaml case (which should be updated), I couldn't find any other 64-bits usage in comments in this patch. Which were the others you were referring to?

Nope. I wasn't sure what you meant by "other places" and only tried to point to places I found which I did (or did not) change :)

[jhenderson]

LGTM!

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

4

English is hard :)

llvm/include/llvm/ObjectYAML/ELFYAML.h

 };
 
 struct Chunk {
   enum class ChunkKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
+    RelocationOffsets,
     NoBits,
     Note,
     Hash,
     GnuHash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
struct RelocationSection : Section {
 
   RelocationSection() : Section(ChunkKind::Relocation) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Relocation;
   }
 };
 
+struct RelocationOffsetsSection : Section {
+  Optional<std::vector<llvm::yaml::Hex64>> OffsetsAndBitmaps;
+  Optional<yaml::BinaryRef> Content;
+
+  RelocationOffsetsSection() : Section(ChunkKind::RelocationOffsets) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::RelocationOffsets;
+  }
+};
+
 struct SymtabShndxSection : Section {
   std::vector<uint32_t> Entries;
 
   SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::SymtabShndxSection;
   }

llvm/lib/ObjectYAML/ELFEmitter.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;
   typedef typename ELFT::Dyn Elf_Dyn;
+  using uintX_t = typename ELFT::uint;
 
   enum class SymtabType { Static, Dynamic };
 
   /// The future ".strtab" section.
   StringTableBuilder DotStrtab{StringTableBuilder::ELF};
 
   /// The future ".shstrtab" section.
   StringTableBuilder DotShStrtab{StringTableBuilder::ELF};
template <class ELFT> class ELFState {
   void finalizeStrings();
   void writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::RelocationOffsetsSection &Section,
+                           ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::SymtabShndxSection &Shndx,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::SymverSection &Section,
                            ContiguousBlobAccumulator &CBA);
if (SecNdx == 0) {
       if (Sec->EntSize)
         SHeader.sh_entsize = *Sec->EntSize;
     } else if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::RelocationOffsetsSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec)) {
       SHeader.sh_entsize = 0;
       SHeader.sh_size = S->Size;
       // SHT_NOBITS section does not have content
void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
-  else if (Section.Type == llvm::ELF::SHT_RELR)
-    SHeader.sh_entsize = sizeof(Elf_Relr);
-  else
-    SHeader.sh_entsize = 0;
 
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
 }
 
 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) &&
if (IsRela) {
       REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
       OS.write((const char *)&REntry, sizeof(REntry));
     }
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::RelocationOffsetsSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  SHeader.sh_entsize =
+      Section.EntSize ? (uint64_t)(*Section.EntSize) : sizeof(Elf_Relr);
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    return;
+  }
+
+  for (const llvm::yaml::Hex64 &Hex : *Section.OffsetsAndBitmaps) {
+    if (!ELFT::Is64Bits && Hex > UINT32_MAX)
+      reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
+                  Twine::utohexstr(Hex));
+    support::endian::write<uintX_t>(OS, Hex, ELFT::TargetEndianness);
+  }
+
+  SHeader.sh_size = sizeof(uintX_t) * Section.OffsetsAndBitmaps->size();
+}
+
+template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
     ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   for (uint32_t E : Shndx.Entries)
     support::endian::write<uint32_t>(OS, E, ELFT::TargetEndianness);
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
   SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  using uintX_t = typename ELFT::uint;
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   Flags.flags2 = Section.Flags2;
   OS.write((const char *)&Flags, sizeof(Flags));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::DynamicSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  typedef typename ELFT::uint uintX_t;
-
   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
          "Section type is not SHT_DYNAMIC");
 
   if (!Section.Entries.empty() && Section.Content)
     reportError("cannot specify both raw content and explicit entries "
                 "for dynamic section '" +
                 Section.Name + "'");
 

llvm/lib/ObjectYAML/ELFYAML.cpp

 }
 
 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Info", Section.RelocatableSec, StringRef());
   IO.mapOptional("Relocations", Section.Relocations);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::RelocationOffsetsSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("OffsetsAndBitmaps", Section.OffsetsAndBitmaps);
+  IO.mapOptional("Content", Section.Content);
+}
+
 static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
   commonSectionMapping(IO, Group);
   IO.mapOptional("Info", Group.Signature);
   IO.mapRequired("Members", Group.Members);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
   commonSectionMapping(IO, Section);
case ELF::SHT_DYNAMIC:
     sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
     break;
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RelocationSection());
     sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
     break;
+  case ELF::SHT_RELR:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::RelocationOffsetsSection());
+    sectionMapping(IO, *cast<ELFYAML::RelocationOffsetsSection>(Section.get()));
+    break;
   case ELF::SHT_GROUP:
     if (!IO.outputting())
       Section.reset(new ELFYAML::Group());
     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
     break;
   case ELF::SHT_NOBITS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
 
   if (const auto *VD = dyn_cast<ELFYAML::VerneedSection>(C.get())) {
     if (VD->VerneedV && VD->Content)
       return "SHT_GNU_verneed: \"Dependencies\" and \"Content\" can't be used "
              "together";
     return {};
   }
 
+  if (const auto *ROS = dyn_cast<ELFYAML::RelocationOffsetsSection>(C.get())) {
+    if (ROS->OffsetsAndBitmaps && ROS->Content)
+      return "\"OffsetsAndBitmaps\" and \"Content\" can't be used together";
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

+## This is a test to test how we create SHT_RELR sections.
+
+## Test how we create SHT_RELR sections for 64-bits LE targets.
+## Test that sh_entsize is 8.
+# RUN: yaml2obj --docnum=1 %s -o %t.le64
+# RUN: llvm-readobj --sections --section-data %t.le64 | FileCheck %s --check-prefix=LE64
+
+# LE64:      Name: .relr.dyn
+# LE64-NEXT: Type: SHT_RELR
+# LE64-NEXT: Flags [
+# LE64-NEXT:   SHF_ALLOC
+# LE64-NEXT: ]
+# LE64-NEXT: Address: 0x0
+# LE64-NEXT: Offset: 0x40
+# LE64-NEXT: Size: 32
+# LE64-NEXT: Link: 0
+# LE64-NEXT: Info: 0
+# LE64-NEXT: AddressAlignment: 0
+# LE64-NEXT: EntrySize: 8
+# LE64-NEXT: SectionData (
+# LE64-NEXT:   0000: DDCCBBAA 00000000 2211FFEE 00000000
+# LE64-NEXT:   0010: 66554433 00000010 AA998877 00000010
+# LE64-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+## An arbitrary 32-bits values.
+    OffsetsAndBitmaps: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
+## An arbitrary 64-bits values.
+                         0x1000000033445566, 0x10000000778899AA ]
+
+## Test how we create SHT_RELR sections for 64-bits BE targets.
+# RUN: yaml2obj --docnum=2 %s -o %t.be64
+# RUN: llvm-readobj --sections --section-data %t.be64 | FileCheck %s --check-prefix=BE64
+
+# BE64:      Name: .relr.dyn
+# BE64:      SectionData (
+# BE64-NEXT:   0000: 00000000 AABBCCDD 00000000 EEFF1122
+# BE64-NEXT:   0010: 10000000 33445566 10000000 778899AA
+# BE64-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2MSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+## An arbitrary 32-bits values.
+    OffsetsAndBitmaps: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
+## An arbitrary 64-bits values.
+                         0x1000000033445566, 0x10000000778899AA ]
+
+## Test how we create SHT_RELR sections for 32-bit LE targets.
+## Test that sh_entsize is 4.
+# RUN: yaml2obj --docnum=3 %s -o %t.le32
+# RUN: llvm-readobj --sections --section-data %t.le32 | FileCheck %s --check-prefix=LE32
+
+# LE32:      Name: .relr.dyn
+# LE32-NEXT: Type: SHT_RELR
+# LE32-NEXT: Flags [
+# LE32-NEXT: SHF_ALLOC
+# LE32-NEXT: ]
+# LE32-NEXT: Address: 0x0
+# LE32-NEXT: Offset: 0x34
+# LE32-NEXT: Size: 16
+# LE32-NEXT: Link: 0
+# LE32-NEXT: Info: 0
+# LE32-NEXT: AddressAlignment: 0
+# LE32-NEXT: EntrySize: 4
+# LE32-NEXT: SectionData (
+# LE32-NEXT:   0000: DDCCBBAA BBAAFFEE BBAAFFEE BCAAFFEE
+# LE32-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    OffsetsAndBitmaps: [ 0xAABBCCDD, 0xEEFFAABB,
+                         0xEEFFAABB, 0xEEFFAABC ]
+
+## Test how we create SHT_RELR sections for 32-bit LE targets.
+# RUN: yaml2obj --docnum=4 %s -o %t.be32
+# RUN: llvm-readobj --sections --section-data %t.be32 | FileCheck %s --check-prefix=BE32
+
+# BE32:      Name: .relr.dyn
+# BE32:      SectionData (
+# BE32-NEXT:   0000: AABBCCDD EEFFAABB EEFFAABB EEFFAABC  |
+# BE32-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2MSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    OffsetsAndBitmaps: [ 0xAABBCCDD, 0xEEFFAABB,
+                         0xEEFFAABB, 0xEEFFAABC ]
+
+## Test we can use "Content" to describe SHT_RELR section.
+# RUN: yaml2obj --docnum=5 %s -o %t.content
+# RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
+
+# CONTENT:      Name: .relr.dyn
+# CONTENT:      SectionData (
+# CONTENT-NEXT:   0000: 112233 |
+# CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    Content: "112233"
+
+## Check we are able to set an arbitrary sh_entsize.
+# RUN: yaml2obj --docnum=6 %s -o %t.entsize
+# RUN: llvm-readelf --sections %t.entsize | FileCheck %s --check-prefix=ENTSIZE
+
+# ENTSIZE: [Nr] Name      Type Address  Off    Size   ES
+# ENTSIZE: [ 1] .relr.dyn RELR 00000000 000034 000001 34
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    EntSize: 0x34
+    Content: "12"
+
+## Test we can't use 64-bit offsets/bitmaps when creating a 32-bit object.
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=TOO-LARGE
+
+# TOO-LARGE: error: .relr.dyn: the value is too large for 32-bits: 0xaabbccddeeff0011
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    OffsetsAndBitmaps: [ 0xAABBCCDDEEFF0011 ]
+
+## Test we can't specify "OffsetsAndBitmaps" and "Content" properties at the same time.
+# RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=BOTH
+
+# BOTH: error: "OffsetsAndBitmaps" and "Content" can't be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .relr.dyn
+    Type:  SHT_RELR
+    Flags: [ SHF_ALLOC ]
+    OffsetsAndBitmaps: [ 0x0 ]
+    Content: "00"

llvm/tools/obj2yaml/elf2yaml.cpp

 template <class ELFT>
 class ELFDumper {
   typedef object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef typename ELFT::Dyn Elf_Dyn;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
+  using Elf_Relr = typename ELFT::Relr;
   using Elf_Nhdr = typename ELFT::Nhdr;
   using Elf_Note = typename ELFT::Note;
 
   ArrayRef<Elf_Shdr> Sections;
   ArrayRef<Elf_Sym> SymTable;
 
   DenseMap<StringRef, uint32_t> UsedSectionNames;
   std::vector<std::string> SectionNames;
class ELFDumper {
 
   Expected<ELFYAML::AddrsigSection *> dumpAddrsigSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::LinkerOptionsSection *>
   dumpLinkerOptionsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::DependentLibrariesSection *>
   dumpDependentLibrariesSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::RelocationOffsetsSection *>
+  dumpRelocOffsetsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymtabShndxSection *>
   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoteSection *> dumpNoteSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::GnuHashSection *> dumpGnuHashSection(const Elf_Shdr *Shdr);
for (const Elf_Shdr &Sec : Sections) {
     case ELF::SHT_REL:
     case ELF::SHT_RELA: {
       Expected<ELFYAML::RelocationSection *> SecOrErr = dumpRelocSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_RELR: {
+      Expected<ELFYAML::RelocationOffsetsSection *> SecOrErr =
+          dumpRelocOffsetsSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Chunks.emplace_back(*SecOrErr);
+      break;
+    }
     case ELF::SHT_GROUP: {
       Expected<ELFYAML::Group *> GroupOrErr = dumpGroup(&Sec);
       if (!GroupOrErr)
         return GroupOrErr.takeError();
       Y->Chunks.emplace_back(*GroupOrErr);
       break;
     }
     case ELF::SHT_MIPS_ABIFLAGS: {
for (const Elf_Rela &Rel : *Rels) {
       S->Relocations.push_back(R);
     }
   }
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::RelocationOffsetsSection *>
+ELFDumper<ELFT>::dumpRelocOffsetsSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::RelocationOffsetsSection>();
+  if (auto E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  if (Expected<ArrayRef<Elf_Relr>> Relrs = Obj.relrs(Shdr)) {
+    S->OffsetsAndBitmaps.emplace();
+    for (Elf_Relr Rel : *Relrs)
+      S->OffsetsAndBitmaps->emplace_back(Rel);
+    return S.release();
+  } else {
+    consumeError(Relrs.takeError());
+  }
+
+  Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+  S->Content = *ContentOrErr;
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::RawContentSection *>
 ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::RawContentSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   unsigned SecIndex = Shdr - &Sections[0];
   if (SecIndex != 0 || Shdr->sh_type != ELF::SHT_NULL) {