Implement some missing relocs for X86_64

[davide]

Summary

I'm still unsure about a couple of things:

1. http://www.x86-64.org/documentation/abi.pdf page 72 mentions some of these relocations are not conformant to the ABI, so I'm not sure if these should be disallowed entirely?
2. how to test this/where to put the tests

[rafaelauler]

Hi Davide,

Thanks for submitting your work. In LLD, we use the LLVM LIT test framework. To read more about it, visit http://llvm.org/docs/CommandGuide/lit.html. To see how this is used in the context of LLD, check the folder lld/test/elf. Each file in this folder is a different test. Start reading those files to get the hang of it.

As a general rule, avoid uploading binary files as part of tests. I know this is hard to do when testing a linker, because its inputs are binary files, but you can avoid this with some clever LLVM tools called obj2yaml and yaml2obj. These tools convert back and forth between binary files (including ELF) and a YAML description. Therefore, write your inputs in YAML then use yaml2obj to create the binary input, then ask lld to process it and see whether your relocations get resolved by converting the output to text again via obj2yaml.

[rafaelauler]

Another thing, when submitting patches to Phabricator, it is interesting to provide patches with full context (see http://llvm.org/docs/Phabricator.html ). To do this, use

git diff -U999999 other-branch

-or-

svn diff --diff-cmd=diff -x -U999999

This eases the task of code review because we can see the entire code. It is not cluttered because Phabricator itself will collapse unchanged parts, but we can expand them on demand.

[shankarke]

Testcase ?

[davide]

In D6235#6, @shankarke wrote:

Testcase ?

I'll write one for R_X86_64_PC64, but what about the others? Should I write one also for the relocations not supported in the ABI? Or the code should be changed to not allow those relocations?

[rafaelauler]

+rafael

Does LLVM generate these "non-ABI-conformant" relocations? Do they need to
be supported by LLD? The relocations are R_X86_64_8, R_X86_64_16,
R_X86_64_PC16 and R_X86_64_PC8.

[echristo]

In D6235#8, @rafaelauler wrote:

+rafael

Does LLVM generate these "non-ABI-conformant" relocations? Do they need to
be supported by LLD? The relocations are R_X86_64_8, R_X86_64_16,
R_X86_64_PC16 and R_X86_64_PC8.

I've rarely seen them in the wild but if you've already code the code then handling them isn't a problem.

-eric

[davide]

Shankar already commited party of this indepentently, I'm gonna split this patch and add test case and resubmit for review.

lib/ReaderWriter/ELF/X86_64/TODO.rst

 These are very simple relocation calculations to implement.
 See lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp
 
-* R_X86_64_16
-* R_X86_64_PC16
-* R_X86_64_8
-* R_X86_64_PC8
-* R_X86_64_PC64
 * R_X86_64_SIZE32
 * R_X86_64_SIZE64
 * R_X86_64_GOTPC32 (this relocation requires there to be a __GLOBAL_OFFSET_TABLE__)

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

   // TODO: Make sure that the result sign extends to the 64bit value.
 }
 
+/// \brief R_X86_64_16 - word16:  S + A
+static void reloc16(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
+  int16_t result = (uint16_t)(S + A);
+  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
+      result |
+      (uint16_t) * reinterpret_cast<llvm::support::ulittle16_t *>(location);
+}
+
+/// \brief R_X86_64_PC16 - word16:  S + A - P
+static void relocPC16(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
+  int16_t result = (int16_t)((S + A) - P);
+  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
+      result |
+      (uint16_t) * reinterpret_cast<llvm::support::ulittle16_t *>(location);
+}
+
+/// \brief R_X86_64_8 - word8:  S + A
+static void reloc8(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
+  int8_t result = (int8_t)(S + A);
+  // XXX: reinterpret_cast needed?
+  *reinterpret_cast<uint8_t *>(location) =
+      result |
+      (uint8_t) * reinterpret_cast<uint8_t *>(location);
+}
+
+/// \brief R_X86_64_PC8 - word8:  S + A - P
+static void relocPC8(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
+  int8_t result = (int8_t)((S + A) - P);
+  // XXX: reinterpret_cast needed?
+  *reinterpret_cast<uint8_t *>(location) =
+      result | (uint8_t) * reinterpret_cast<uint8_t *>(location);
+}
+
+/// \brief R_X86_64_PC64 - word64:  S + A - P
+static void relocPC64(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
+  int64_t result = (uint64_t)((S + A) - P);
+  *reinterpret_cast<llvm::support::ulittle64_t *>(location) =
+      result |
+      (uint64_t) * reinterpret_cast<llvm::support::ulittle64_t *>(location);
+}
+
 std::error_code X86_64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {

   case R_X86_64_32S:
     reloc32S(location, relocVAddress, targetVAddress, ref.addend());
     break;
+  case R_X86_64_16:
+    reloc16(location, relocVAddress, targetVAddress, ref.addend());
+    break;
+  case R_X86_64_PC16:
+    relocPC16(location, relocVAddress, targetVAddress, ref.addend());
+    break;
+  case R_X86_64_8:
+    reloc8(location, relocVAddress, targetVAddress, ref.addend());
+    break;
+  case R_X86_64_PC8:
+    relocPC8(location, relocVAddress, targetVAddress, ref.addend());
+    break;
   case R_X86_64_TPOFF64:
   case R_X86_64_DTPOFF32:
   case R_X86_64_TPOFF32: {

     std::memcpy(location - 3, instr, sizeof(instr));
     break;
   }
+  case R_X86_64_PC64:
+    relocPC64(location, relocVAddress, targetVAddress, ref.addend());
+    break;
   case LLD_R_X86_64_GOTRELINDEX: {
     const DefinedAtom *target = cast<const DefinedAtom>(ref.target());
     for (const Reference *r : *target) {