[yaml2obj] ELF Relocations Support

[atanasyan]

Summary

The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only.
Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types.

Example of relocation section specification:

Sections:
- Name: .text
  Type: SHT_PROGBITS
  Content: "0000000000000000"
  AddressAlign: 16
  Flags: [SHF_ALLOC]

- !Relocations
  Name: .rel.text
  Type: SHT_REL
  Info: .text
  AddressAlign: 4
  Relocations:
    - Offset: 0x1
      Symbol: glob1
      Type: R_MIPS_32
    - Offset: 0x2
      Symbol: glob2
      Type: R_MIPS_CALL16

[Bigcheese]

lgtm

[shankarke]

lib/Object/ELFYAML.cpp

339–379

will this switch become too long ? also I think some of the relocation values might overlap too.

[atanasyan]

lib/Object/ELFYAML.cpp

339–379

1. Yes, the switch is long. But I cannot figure out how and why do we need to leave only subset of X86_64 relocations here.
2. All these relocation types are unique constants. But in general llvm::yaml::Input::matchEnumScalar and llvm::yaml::Output::matchEnumScalar methods accept overlapped constants. In case of a YAML file reading that allow to use different names for the same constant. In case of YAML file writing, we write out the first name matched to the numerical code.

[shankarke]

lib/Object/ELFYAML.cpp

339–379

should the architecture be specified as a namespace too like how its with lld ?

[atanasyan]

lib/Object/ELFYAML.cpp

339–379

Ah, now I probably see the point. This code is not ready for writing yaml file indeed. To make this routine better we need to check current target architecture and select an appropriate set of relocation type constants. Unfortunately now we cannot test this approach because the obj2yaml tool does not handle ELF files. That is why I keep this function simple.

Anyway I will look at this function once again. Maybe I will be able to add some target checks and cover them by tests even now.

[silvas]

LGTM.

The duplication between Elf_Rel and Elf_Rela is a bit disturbing but I can't think of a significantly better way to do it. The best I can think of is to skip putting Elf_Rel{,a} in a std::vector (and calling writeArrayData) and directly output to the OS in buildRelocationArray (which would have to be renamed); that would let you push the distinction between Rel and Rela way down to the inner loop, but I'm not sure if that would end up being simpler.

[atanasyan]

1. Reduced code duplication between Elf_Rel and Elf_Rela relocation handling.
2. ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration() now accepts only relocation type names which are valid for the current architecture.

[shankarke]

LGTM

[silvas]

Nice job reducing the Rel/Rela duplication!

On a second look I have a some small questions about the tag handling.

lib/Object/ELFYAML.cpp

582–591

Is there a reason that on one side there is "!Relocation" and on the other "!Relocations" (plural)?

test/Object/yaml2obj-elf-rel.yaml

41

Is this per-relocation "!Relocation" tag needed? Doesn't the "!Relocations" on the section cover this?

tools/yaml2obj/yaml2elf.cpp

245

Stray semicolon?

267–268

This is actually unreachable, right? If we get here then someone has extended the ELFYAML::Section hierarchy without adding a case here which I think is a programming error.

[atanasyan]

lib/Object/ELFYAML.cpp

582–591

Good catch. It is just a typo. The section's type name should be "!Relocations" in both cases.

test/Object/yaml2obj-elf-rel.yaml

41

The "!Relocation" tag is optional. I will remove it from the test case to make it more clear.

tools/yaml2obj/yaml2elf.cpp

267–268

Agreed. The llvm_unreachable is better here.

[atanasyan]

Fixed some typos. User level error message replaced by llvm_unreachable call.

[silvas]

lib/Object/ELFYAML.cpp

579–580

Now that I think about it, since in the future the ELFYAML::Section hierarchy is going to be growing, I think it would make sense to standardize on a consistent tag name scheme. It just bothers me that the generic "!Section" is being used for ContentSection, while "!Relocations" for RelocationSection. Can we standardize on having the tag be the name of the class?

[atanasyan]

lib/Object/ELFYAML.cpp

579–580

Agreed. But I am not sure that ContentSection is a good name for tag. What do you think?

[shankarke]

We could just have the name as SectionContent or Content to be short.

[silvas]

lib/Object/ELFYAML.cpp

579–580

Now that I think more about it, I think that the tag system is just overcomplicating things. I think it would make a lot more sense and be simpler to just autodetect which ELFYAML::Section subclass to create based on which keys are present in the section entry.

i.e., the deserialization deserializes Content: *and* Relocations: (and any future additions) as optional, then chooses which subclass to instantiate based on what is present. Of course, it issues an error if there is an illegal combination of keys.

The idea is that Content:, Relocations:, etc. (any future ones) would be just sugar for filling in the Content: in a more convenient/readable way; this approach makes the whole process easier to understand from a user's perspective.

I think the goal of the tags (making it a bit more "strongly typed" on disk) is admirable, but at the end of the day we are still duck typing (from a tag perspective) between Rel and Rela (and probably a bunch of other things). It's also just plain redundant.

[shankarke]

lib/Object/ELFYAML.cpp

579–580

This may be over-engineering yaml2obj IMHO.

[silvas]

lib/Object/ELFYAML.cpp

579–580

It's not clear what your comment was aimed at (my last paragraph or the approach I suggested?).

[atanasyan]

lib/Object/ELFYAML.cpp

579–580

I see the point but I think now we do not have enough information to make a correct design decision. There are only two different types of section and it is rather easy (I hope) to check what entries are in the Section block and select an appropriate binary representation. But suppose that in the future we will have more mandatory and optional Section entries. I am not sure that it will be always possible to select a binary representation in that case.

Let's define two types of section:

SectionFoo
  MegaContent (mandatory field)
  UselessContent (optional field)

SectionBar
  MegaContent (mandatory field)
  NotSoUselessContent (optional field)

It's difficult to recognize a section type in the following YAML file:

- Name: .section_name
  MegaContent: "bla-bla-bla"

If we define much more section type later or, on the contrary, understand that only RawContentSection and RelocationSection satisfy our requirements, we can combine two approaches:

1. Tag defines section type unambiguously.
2. If Tag is omitted, we can try to deduce section type from the set of declared fields.

Now I would like to keep the solution simple. Next we need to implement obj2yaml conversion for ELF binaries. This might give us additional info to select persistent design.

[atanasyan]

lib/Object/ELFYAML.cpp

579–580

From the other side, I will try to implement the approach suggested by you tomorrow. Let's take a look on the result and compare solutions.

[atanasyan]

I still think that a user should specify a section type explicitly. One more argument is an error diagnostics. If a user explicitly defines a section type but forget some mandatory fields we can show a clear error message. If we need to deduce a section type and a user missed some fields, we have to show unclear "Unknown section type" error message. Try to quickly find why the section .stub has unknown type in the example below:

Sections:
- Name: .text
  Type: SHT_PROGBITS
  Content: "0000000000000000"
  AddressAlign: 16
  Flags: [SHF_ALLOC]
- Name: .stub
  Type: SHT_PROGBITS
  AddressAlign: 16
  Flags: [SHF_ALLOC]
- Name: .eh_frame
  Type: SHT_PROGBITS
  Content: "0000000000000000"
  AddressAlign: 16
  Flags: [SHF_ALLOC]

So I suggest one more solution. Let's recognize a type of section using Type field. A section with SHT_REL or SHT_RELA type is a relocation section, otherwise it is a raw content section. If or when we have more section types we will be able to invent another solution. The only shortcoming of such approach is impossibility to define a relocation section with arbitrary (for example invalid) content but I think it is a minor problem.

[silvas]

Excellent points, Simon, I agree with all of them and you've done a very good analysis. Let's get this patch committed. I especially like the use of the Type: field as the discriminator; it leads to a very simple implementation.

I also think you're absolutely right about obj2yaml; the requirements of obj2yaml will probably influence the final design more than anything.

[atanasyan]

Thanks for review.

Closed by commit rL206017 (authored by @atanasyan)

include/llvm/Object/ELFYAML.h

 LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)
 // Just use 64, since it can hold 32-bit values too.
 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_REL)
 // Just use 64, since it can hold 32-bit values too.
 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
 
 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
 // since 64-bit can hold 32-bit values too.
 struct FileHeader {
   ELF_ELFCLASS Class;
struct Symbol {
   llvm::yaml::Hex64 Size;
 };
 struct LocalGlobalWeakSymbols {
   std::vector<Symbol> Local;
   std::vector<Symbol> Global;
   std::vector<Symbol> Weak;
 };
 struct Section {
+  enum class SectionKind { RawContent, Relocation };
+  SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   ELF_SHF Flags;
   llvm::yaml::Hex64 Address;
-  object::yaml::BinaryRef Content;
   StringRef Link;
+  StringRef Info;
   llvm::yaml::Hex64 AddressAlign;
+  Section(SectionKind Kind) : Kind(Kind) {}
+};
+struct RawContentSection : Section {
+  object::yaml::BinaryRef Content;
+  RawContentSection() : Section(SectionKind::RawContent) {}
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::RawContent;
+  }
+};
+struct Relocation {
+  uint32_t Offset;
+  uint32_t Addend;
+  ELF_REL Type;
+  StringRef Symbol;
+};
+struct RelocationSection : Section {
+  std::vector<Relocation> Relocations;
+  RelocationSection() : Section(SectionKind::Relocation) {}
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::Relocation;
+  }
 };
 struct Object {
   FileHeader Header;
-  std::vector<Section> Sections;
+  std::vector<std::unique_ptr<Section>> Sections;
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   LocalGlobalWeakSymbols Symbols;
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Section)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 
 namespace llvm {
 namespace yaml {
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
 };

 };
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
   static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
 };
 
 template <>
+struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
+  static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
+};
+
+template <>
 struct MappingTraits<ELFYAML::FileHeader> {
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
 };
 
 template <>
 struct MappingTraits<ELFYAML::LocalGlobalWeakSymbols> {
   static void mapping(IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols);
 };
 
+template <> struct MappingTraits<ELFYAML::Relocation> {
+  static void mapping(IO &IO, ELFYAML::Relocation &Rel);
+};
+
 template <>
-struct MappingTraits<ELFYAML::Section> {
-  static void mapping(IO &IO, ELFYAML::Section &Section);
+struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
+  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Object> {
   static void mapping(IO &IO, ELFYAML::Object &Object);
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 #endif

lib/Object/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X);
   ECase(STT_SECTION)
   ECase(STT_FILE)
   ECase(STT_COMMON)
   ECase(STT_TLS)
   ECase(STT_GNU_IFUNC)
 #undef ECase
 }
 
+void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
+    IO &IO, ELFYAML::ELF_REL &Value) {
+  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
+  assert(Object && "The IO context is not initialized");
+#define ECase(X) IO.enumCase(Value, #X, ELF::X);
+  switch (Object->Header.Machine) {
+  case ELF::EM_X86_64:
+    ECase(R_X86_64_NONE)
+    ECase(R_X86_64_64)
+    ECase(R_X86_64_PC32)
+    ECase(R_X86_64_GOT32)
+    ECase(R_X86_64_PLT32)
+    ECase(R_X86_64_COPY)
+    ECase(R_X86_64_GLOB_DAT)
+    ECase(R_X86_64_JUMP_SLOT)
+    ECase(R_X86_64_RELATIVE)
+    ECase(R_X86_64_GOTPCREL)
+    ECase(R_X86_64_32)
+    ECase(R_X86_64_32S)
+    ECase(R_X86_64_16)
+    ECase(R_X86_64_PC16)
+    ECase(R_X86_64_8)
+    ECase(R_X86_64_PC8)
+    ECase(R_X86_64_DTPMOD64)
+    ECase(R_X86_64_DTPOFF64)
+    ECase(R_X86_64_TPOFF64)
+    ECase(R_X86_64_TLSGD)
+    ECase(R_X86_64_TLSLD)
+    ECase(R_X86_64_DTPOFF32)
+    ECase(R_X86_64_GOTTPOFF)
+    ECase(R_X86_64_TPOFF32)
+    ECase(R_X86_64_PC64)
+    ECase(R_X86_64_GOTOFF64)
+    ECase(R_X86_64_GOTPC32)
+    ECase(R_X86_64_GOT64)
+    ECase(R_X86_64_GOTPCREL64)
+    ECase(R_X86_64_GOTPC64)
+    ECase(R_X86_64_GOTPLT64)
+    ECase(R_X86_64_PLTOFF64)
+    ECase(R_X86_64_SIZE32)
+    ECase(R_X86_64_SIZE64)
+    ECase(R_X86_64_GOTPC32_TLSDESC)
+    ECase(R_X86_64_TLSDESC_CALL)
+    ECase(R_X86_64_TLSDESC)
+    ECase(R_X86_64_IRELATIVE)
+    break;
+  case ELF::EM_MIPS:
+    ECase(R_MIPS_NONE)
+    ECase(R_MIPS_16)
+    ECase(R_MIPS_32)
+    ECase(R_MIPS_REL32)
+    ECase(R_MIPS_26)
+    ECase(R_MIPS_HI16)
+    ECase(R_MIPS_LO16)
+    ECase(R_MIPS_GPREL16)
+    ECase(R_MIPS_LITERAL)
+    ECase(R_MIPS_GOT16)
+    ECase(R_MIPS_PC16)
+    ECase(R_MIPS_CALL16)
+    ECase(R_MIPS_GPREL32)
+    ECase(R_MIPS_UNUSED1)
+    ECase(R_MIPS_UNUSED2)
+    ECase(R_MIPS_SHIFT5)
+    ECase(R_MIPS_SHIFT6)
+    ECase(R_MIPS_64)
+    ECase(R_MIPS_GOT_DISP)
+    ECase(R_MIPS_GOT_PAGE)
+    ECase(R_MIPS_GOT_OFST)
+    ECase(R_MIPS_GOT_HI16)
+    ECase(R_MIPS_GOT_LO16)
+    ECase(R_MIPS_SUB)
+    ECase(R_MIPS_INSERT_A)
+    ECase(R_MIPS_INSERT_B)
+    ECase(R_MIPS_DELETE)
+    ECase(R_MIPS_HIGHER)
+    ECase(R_MIPS_HIGHEST)
+    ECase(R_MIPS_CALL_HI16)
+    ECase(R_MIPS_CALL_LO16)
+    ECase(R_MIPS_SCN_DISP)
+    ECase(R_MIPS_REL16)
+    ECase(R_MIPS_ADD_IMMEDIATE)
+    ECase(R_MIPS_PJUMP)
+    ECase(R_MIPS_RELGOT)
+    ECase(R_MIPS_JALR)
+    ECase(R_MIPS_TLS_DTPMOD32)
+    ECase(R_MIPS_TLS_DTPREL32)
+    ECase(R_MIPS_TLS_DTPMOD64)
+    ECase(R_MIPS_TLS_DTPREL64)
+    ECase(R_MIPS_TLS_GD)
+    ECase(R_MIPS_TLS_LDM)
+    ECase(R_MIPS_TLS_DTPREL_HI16)
+    ECase(R_MIPS_TLS_DTPREL_LO16)
+    ECase(R_MIPS_TLS_GOTTPREL)
+    ECase(R_MIPS_TLS_TPREL32)
+    ECase(R_MIPS_TLS_TPREL64)
+    ECase(R_MIPS_TLS_TPREL_HI16)
+    ECase(R_MIPS_TLS_TPREL_LO16)
+    ECase(R_MIPS_GLOB_DAT)
+    ECase(R_MIPS_COPY)
+    ECase(R_MIPS_JUMP_SLOT)
+    ECase(R_MICROMIPS_26_S1)
+    ECase(R_MICROMIPS_HI16)
+    ECase(R_MICROMIPS_LO16)
+    ECase(R_MICROMIPS_GOT16)
+    ECase(R_MICROMIPS_PC16_S1)
+    ECase(R_MICROMIPS_CALL16)
+    ECase(R_MICROMIPS_GOT_DISP)
+    ECase(R_MICROMIPS_GOT_PAGE)
+    ECase(R_MICROMIPS_GOT_OFST)
+    ECase(R_MICROMIPS_TLS_GD)
+    ECase(R_MICROMIPS_TLS_LDM)
+    ECase(R_MICROMIPS_TLS_DTPREL_HI16)
+    ECase(R_MICROMIPS_TLS_DTPREL_LO16)
+    ECase(R_MICROMIPS_TLS_TPREL_HI16)
+    ECase(R_MICROMIPS_TLS_TPREL_LO16)
+    ECase(R_MIPS_NUM)
+    ECase(R_MIPS_PC32)
+    break;
+  case ELF::EM_HEXAGON:
+    ECase(R_HEX_NONE)
+    ECase(R_HEX_B22_PCREL)
+    ECase(R_HEX_B15_PCREL)
+    ECase(R_HEX_B7_PCREL)
+    ECase(R_HEX_LO16)
+    ECase(R_HEX_HI16)
+    ECase(R_HEX_32)
+    ECase(R_HEX_16)
+    ECase(R_HEX_8)
+    ECase(R_HEX_GPREL16_0)
+    ECase(R_HEX_GPREL16_1)
+    ECase(R_HEX_GPREL16_2)
+    ECase(R_HEX_GPREL16_3)
+    ECase(R_HEX_HL16)
+    ECase(R_HEX_B13_PCREL)
+    ECase(R_HEX_B9_PCREL)
+    ECase(R_HEX_B32_PCREL_X)
+    ECase(R_HEX_32_6_X)
+    ECase(R_HEX_B22_PCREL_X)
+    ECase(R_HEX_B15_PCREL_X)
+    ECase(R_HEX_B13_PCREL_X)
+    ECase(R_HEX_B9_PCREL_X)
+    ECase(R_HEX_B7_PCREL_X)
+    ECase(R_HEX_16_X)
+    ECase(R_HEX_12_X)
+    ECase(R_HEX_11_X)
+    ECase(R_HEX_10_X)
+    ECase(R_HEX_9_X)
+    ECase(R_HEX_8_X)
+    ECase(R_HEX_7_X)
+    ECase(R_HEX_6_X)
+    ECase(R_HEX_32_PCREL)
+    ECase(R_HEX_COPY)
+    ECase(R_HEX_GLOB_DAT)
+    ECase(R_HEX_JMP_SLOT)
+    ECase(R_HEX_RELATIVE)
+    ECase(R_HEX_PLT_B22_PCREL)
+    ECase(R_HEX_GOTREL_LO16)
+    ECase(R_HEX_GOTREL_HI16)
+    ECase(R_HEX_GOTREL_32)
+    ECase(R_HEX_GOT_LO16)
+    ECase(R_HEX_GOT_HI16)
+    ECase(R_HEX_GOT_32)
+    ECase(R_HEX_GOT_16)
+    ECase(R_HEX_DTPMOD_32)
+    ECase(R_HEX_DTPREL_LO16)
+    ECase(R_HEX_DTPREL_HI16)
+    ECase(R_HEX_DTPREL_32)
+    ECase(R_HEX_DTPREL_16)
+    ECase(R_HEX_GD_PLT_B22_PCREL)
+    ECase(R_HEX_GD_GOT_LO16)
+    ECase(R_HEX_GD_GOT_HI16)
+    ECase(R_HEX_GD_GOT_32)
+    ECase(R_HEX_GD_GOT_16)
+    ECase(R_HEX_IE_LO16)
+    ECase(R_HEX_IE_HI16)
+    ECase(R_HEX_IE_32)
+    ECase(R_HEX_IE_GOT_LO16)
+    ECase(R_HEX_IE_GOT_HI16)
+    ECase(R_HEX_IE_GOT_32)
+    ECase(R_HEX_IE_GOT_16)
+    ECase(R_HEX_TPREL_LO16)
+    ECase(R_HEX_TPREL_HI16)
+    ECase(R_HEX_TPREL_32)
+    ECase(R_HEX_TPREL_16)
+    ECase(R_HEX_6_PCREL_X)
+    ECase(R_HEX_GOTREL_32_6_X)
+    ECase(R_HEX_GOTREL_16_X)
+    ECase(R_HEX_GOTREL_11_X)
+    ECase(R_HEX_GOT_32_6_X)
+    ECase(R_HEX_GOT_16_X)
+    ECase(R_HEX_GOT_11_X)
+    ECase(R_HEX_DTPREL_32_6_X)
+    ECase(R_HEX_DTPREL_16_X)
+    ECase(R_HEX_DTPREL_11_X)
+    ECase(R_HEX_GD_GOT_32_6_X)
+    ECase(R_HEX_GD_GOT_16_X)
+    ECase(R_HEX_GD_GOT_11_X)
+    ECase(R_HEX_IE_32_6_X)
+    ECase(R_HEX_IE_16_X)
+    ECase(R_HEX_IE_GOT_32_6_X)
+    ECase(R_HEX_IE_GOT_16_X)
+    ECase(R_HEX_IE_GOT_11_X)
+    ECase(R_HEX_TPREL_32_6_X)
+    ECase(R_HEX_TPREL_16_X)
+    ECase(R_HEX_TPREL_11_X)
+    break;
+  default:
+    llvm_unreachable("Unsupported architecture");
+  }
+#undef ECase
+}
+
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   IO.mapRequired("Class", FileHdr.Class);
   IO.mapRequired("Data", FileHdr.Data);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapRequired("Type", FileHdr.Type);
   IO.mapRequired("Machine", FileHdr.Machine);
   IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));

 
 void MappingTraits<ELFYAML::LocalGlobalWeakSymbols>::mapping(
     IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols) {
   IO.mapOptional("Local", Symbols.Local);
   IO.mapOptional("Global", Symbols.Global);
   IO.mapOptional("Weak", Symbols.Weak);
 }
 
-void MappingTraits<ELFYAML::Section>::mapping(IO &IO,
-                                              ELFYAML::Section &Section) {
+static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapOptional("Name", Section.Name, StringRef());
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
   IO.mapOptional("Address", Section.Address, Hex64(0));
-  IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Link", Section.Link);
+  IO.mapOptional("Info", Section.Info);
   IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
 }
 
+static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+}
+
+static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Relocations", Section.Relocations);
+}
+
+void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
+    IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
+  ELFYAML::ELF_SHT sectionType;
+  if (IO.outputting())
+    sectionType = Section->Type;
+  IO.mapRequired("Type", sectionType);
+
+  switch (sectionType) {
+  case ELF::SHT_REL:
+  case ELF::SHT_RELA:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::RelocationSection());
+    sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
+    break;
+  default:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::RawContentSection());
+    sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
+  }
+}
+
+void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
+                                                 ELFYAML::Relocation &Rel) {
+  IO.mapRequired("Offset", Rel.Offset);
+  IO.mapRequired("Symbol", Rel.Symbol);
+  IO.mapRequired("Type", Rel.Type);
+  IO.mapOptional("Addend", Rel.Addend);
+}
+
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
+  assert(!IO.getContext() && "The IO context is initialized already");
+  IO.setContext(&Object);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("Sections", Object.Sections);
   IO.mapOptional("Symbols", Object.Symbols);
+  IO.setContext(nullptr);
 }
 
 } // end namespace yaml
 } // end namespace llvm

test/Object/yaml2obj-elf-rel.yaml

+# RUN: yaml2obj -format=elf %s | llvm-readobj -sections -relocations - | FileCheck %s
+
+!ELF
+FileHeader: !FileHeader
+  Class: ELFCLASS32
+  Data: ELFDATA2MSB
+  Type: ET_REL
+  Machine: EM_MIPS
+
+Sections:
+- Name: .text
+  Type: SHT_PROGBITS
+  Content: "0000000000000000"
+  AddressAlign: 16
+  Flags: [SHF_ALLOC]
+
+- Name: .rel.text
+  Type: SHT_REL
+  Info: .text
+  AddressAlign: 4
+  Relocations:
+    - Offset: 0x1
+      Symbol: glob1
+      Type: R_MIPS_32
+    - Offset: 0x1
+      Symbol: glob2
+      Type: R_MIPS_CALL16
+    - Offset: 0x2
+      Symbol: loc1
+      Type: R_MIPS_LO16
+
+- Name: .rela.text
+  Type: SHT_RELA
+  Link: .symtab
+  Info: .text
+  AddressAlign: 4
+  Relocations:
+    - Offset: 0x1
+      Addend: 1
+      Symbol: glob1
+      Type: R_MIPS_32
+    - Offset: 0x1
+      Addend: 2
+      Symbol: glob2
+      Type: R_MIPS_CALL16
+    - Offset: 0x2
+      Addend: 3
+      Symbol: loc1
+      Type: R_MIPS_LO16
+
+Symbols:
+  Local:
+    - Name: loc1
+    - Name: loc2
+  Global:
+    - Name: glob1
+      Section: .text
+      Value: 0x0
+      Size: 4
+    - Name: glob2
+  Weak:
+    - Name: weak1
+
+# CHECK:        Section {
+# CHECK-NEXT:     Index: 0
+# CHECK:        }
+# CHECK:        Section {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name: .text (1)
+# CHECK:        }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .rel.text (7)
+# CHECK-NEXT:     Type: SHT_REL (0x9)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset: 0x160
+# CHECK-NEXT:     Size: 24
+# CHECK-NEXT:     Link: 4
+# CHECK-NEXT:     Info: 1
+# CHECK-NEXT:     AddressAlignment: 4
+# CHECK-NEXT:     EntrySize: 8
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .rela.text (17)
+# CHECK-NEXT:     Type: SHT_RELA (0x4)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset: 0x180
+# CHECK-NEXT:     Size: 36
+# CHECK-NEXT:     Link: 4
+# CHECK-NEXT:     Info: 1
+# CHECK-NEXT:     AddressAlignment: 4
+# CHECK-NEXT:     EntrySize: 12
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 4
+# CHECK-NEXT:     Name: .symtab (28)
+# CHECK:        }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 5
+# CHECK-NEXT:     Name: .strtab (36)
+# CHECK:        }
+# CHECK:        Relocations [
+# CHECK-NEXT:     Section (2) .rel.text {
+# CHECK-NEXT:       0x1 R_MIPS_32 glob1 0x0
+# CHECK-NEXT:       0x1 R_MIPS_CALL16 glob2 0x0
+# CHECK-NEXT:       0x2 R_MIPS_LO16 loc1 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Section (3) .rela.text {
+# CHECK-NEXT:       0x1 R_MIPS_32 glob1 0x1
+# CHECK-NEXT:       0x1 R_MIPS_CALL16 glob2 0x2
+# CHECK-NEXT:       0x2 R_MIPS_LO16 loc1 0x3
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]

tools/yaml2obj/yaml2elf.cpp

 /// \brief "Single point of truth" for the ELF file construction.
 /// TODO: This class still has a ways to go before it is truly a "single
 /// point of truth".
 template <class ELFT>
 class ELFState {
   typedef typename object::ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
+  typedef typename object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
+  typedef typename object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
 
   /// \brief The future ".strtab" section.
   StringTableBuilder DotStrtab;
 
   /// \brief The future ".shstrtab" section.
   StringTableBuilder DotShStrtab;
 
   NameToIdxMap SN2I;
+  NameToIdxMap SymN2I;
   const ELFYAML::Object &Doc;
 
   bool buildSectionIndex();
+  bool buildSymbolIndex(std::size_t &StartIndex,
+                        const std::vector<ELFYAML::Symbol> &Symbols);
   void initELFHeader(Elf_Ehdr &Header);
   bool initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader,
                                ContiguousBlobAccumulator &CBA);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA);
   void addSymbols(const std::vector<ELFYAML::Symbol> &Symbols,
                   std::vector<Elf_Sym> &Syms, unsigned SymbolBinding);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::RawContentSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+  bool writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::RelocationSection &Section,
+                           ContiguousBlobAccumulator &CBA);
 
   // - SHT_NULL entry (placed first, i.e. 0'th entry)
   // - symbol table (.symtab) (placed third to last)
   // - string table (.strtab) (placed second to last)
   // - section header string table (.shstrtab) (placed last)
   unsigned getDotSymTabSecNo() const { return Doc.Sections.size() + 1; }
   unsigned getDotStrTabSecNo() const { return Doc.Sections.size() + 2; }
   unsigned getDotShStrTabSecNo() const { return Doc.Sections.size() + 3; }
bool ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   Elf_Shdr SHeader;
   zero(SHeader);
   SHeaders.push_back(SHeader);
 
   for (const auto &Sec : Doc.Sections) {
     zero(SHeader);
-    SHeader.sh_name = DotShStrtab.addString(Sec.Name);
-    SHeader.sh_type = Sec.Type;
-    SHeader.sh_flags = Sec.Flags;
-    SHeader.sh_addr = Sec.Address;
-
-    Sec.Content.writeAsBinary(CBA.getOSAndAlignedOffset(SHeader.sh_offset));
-    SHeader.sh_size = Sec.Content.binary_size();
+    SHeader.sh_name = DotShStrtab.addString(Sec->Name);
+    SHeader.sh_type = Sec->Type;
+    SHeader.sh_flags = Sec->Flags;
+    SHeader.sh_addr = Sec->Address;
+    SHeader.sh_addralign = Sec->AddressAlign;
 
-    if (!Sec.Link.empty()) {
+    if (!Sec->Link.empty()) {
       unsigned Index;
-      if (SN2I.lookup(Sec.Link, Index)) {
-        errs() << "error: Unknown section referenced: '" << Sec.Link
-               << "' at YAML section '" << Sec.Name << "'.\n";
-        return false;;
+      if (SN2I.lookup(Sec->Link, Index)) {
+        errs() << "error: Unknown section referenced: '" << Sec->Link
+               << "' at YAML section '" << Sec->Name << "'.\n";
+        return false;
       }
       SHeader.sh_link = Index;
     }
-    SHeader.sh_info = 0;
-    SHeader.sh_addralign = Sec.AddressAlign;
-    SHeader.sh_entsize = 0;
+
+    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get()))
+      writeSectionContent(SHeader, *S, CBA);
+    else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
+      if (S->Link.empty())
+        // For relocation section set link to .symtab by default.
+        SHeader.sh_link = getDotSymTabSecNo();
+
+      unsigned Index;
+      if (SN2I.lookup(S->Info, Index)) {
+        errs() << "error: Unknown section referenced: '" << S->Info
+               << "' at YAML section '" << S->Name << "'.\n";
+        return false;
+      }
+      SHeader.sh_info = Index;
+
+      if (!writeSectionContent(SHeader, *S, CBA))
+        return false;
+    } else
+      llvm_unreachable("Unknown section type");
+
     SHeaders.push_back(SHeader);
   }
   return true;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
                                              ContiguousBlobAccumulator &CBA) {
if (!Sym.Section.empty()) {
       Symbol.st_shndx = Index;
     } // else Symbol.st_shndex == SHN_UNDEF (== 0), since it was zero'd earlier.
     Symbol.st_value = Sym.Value;
     Symbol.st_size = Sym.Size;
     Syms.push_back(Symbol);
   }
 }
 
+template <class ELFT>
+void
+ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                    const ELFYAML::RawContentSection &Section,
+                                    ContiguousBlobAccumulator &CBA) {
+  Section.Content.writeAsBinary(CBA.getOSAndAlignedOffset(SHeader.sh_offset));
+  SHeader.sh_entsize = 0;
+  SHeader.sh_size = Section.Content.binary_size();
+}
+
+template <class ELFT>
+bool
+ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                    const ELFYAML::RelocationSection &Section,
+                                    ContiguousBlobAccumulator &CBA) {
+  if (Section.Type != llvm::ELF::SHT_REL &&
+      Section.Type != llvm::ELF::SHT_RELA) {
+    errs() << "error: Invalid relocation section type.\n";
+    return false;
+  }
+
+  bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
+  SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
+  SHeader.sh_size = SHeader.sh_entsize * Section.Relocations.size();
+
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset);
+
+  for (const auto &Rel : Section.Relocations) {
+    unsigned SymIdx;
+    if (SymN2I.lookup(Rel.Symbol, SymIdx)) {
+      errs() << "error: Unknown symbol referenced: '" << Rel.Symbol
+             << "' at YAML relocation.\n";
+      return false;
+    }
+
+    if (IsRela) {
+      Elf_Rela REntry;
+      zero(REntry);
+      REntry.r_offset = Rel.Offset;
+      REntry.r_addend = Rel.Addend;
+      REntry.setSymbolAndType(SymIdx, Rel.Type);
+      OS.write((const char *)&REntry, sizeof(REntry));
+    } else {
+      Elf_Rel REntry;
+      zero(REntry);
+      REntry.r_offset = Rel.Offset;
+      REntry.setSymbolAndType(SymIdx, Rel.Type);
+      OS.write((const char *)&REntry, sizeof(REntry));
+    }
+  }
+  return true;
+}
+
 template <class ELFT> bool ELFState<ELFT>::buildSectionIndex() {
   SN2I.addName(".symtab", getDotSymTabSecNo());
   SN2I.addName(".strtab", getDotStrTabSecNo());
   SN2I.addName(".shstrtab", getDotShStrTabSecNo());
 
   for (unsigned i = 0, e = Doc.Sections.size(); i != e; ++i) {
-    StringRef Name = Doc.Sections[i].Name;
+    StringRef Name = Doc.Sections[i]->Name;
     if (Name.empty())
       continue;
     // "+ 1" to take into account the SHT_NULL entry.
     if (SN2I.addName(Name, i + 1)) {
       errs() << "error: Repeated section name: '" << Name
              << "' at YAML section number " << i << ".\n";
       return false;
     }
   }
   return true;
 }
 
 template <class ELFT>
+bool
+ELFState<ELFT>::buildSymbolIndex(std::size_t &StartIndex,
+                                 const std::vector<ELFYAML::Symbol> &Symbols) {
+  for (const auto &Sym : Symbols) {
+    ++StartIndex;
+    if (Sym.Name.empty())
+      continue;
+    if (SymN2I.addName(Sym.Name, StartIndex)) {
+      errs() << "error: Repeated symbol name: '" << Sym.Name << "'.\n";
+      return false;
+    }
+  }
+  return true;
+}
+
+template <class ELFT>
 int ELFState<ELFT>::writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
   ELFState<ELFT> State(Doc);
   if (!State.buildSectionIndex())
     return 1;
 
+  std::size_t StartSymIndex = 0;
+  if (!State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Local) ||
+      !State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Global) ||
+      !State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Weak))
+    return 1;
+
   Elf_Ehdr Header;
   State.initELFHeader(Header);
 
   // TODO: Flesh out section header support.
   // TODO: Program headers.
 
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.