[BOLT] Fix flush pending relocs

[rafauler]

Summary

https://github.com/facebookincubator/BOLT/pull/255 accidentally
omitted a relocation type when refactoring the code. Add this type back
and change function name so its intent is more clear.

[Amir]

Thanks for noticing and fixing this. Can you please reformat this diff?

[rafauler]

clang-format

bolt/include/bolt/Core/Relocation.h

struct Relocation {
   static bool skipRelocationType(uint64_t Type);
 
   /// Handle special cases when relocation should not be processed by BOLT or
   /// change relocation \p Type to proper one before continuing if \p Contents
   /// and \P Type mismatch occured.
   static bool skipRelocationProcess(uint64_t &Type, uint64_t Contents);
 
   // Adjust value depending on relocation type (make it PC relative or not)
-  static uint64_t adjustValue(uint64_t Type, uint64_t Value,
-                              uint64_t PC);
+  static uint64_t encodeValue(uint64_t Type, uint64_t Value, uint64_t PC);
 
   /// Extract current relocated value from binary contents. This is used for
   /// RISC architectures where values are encoded in specific bits depending
   /// on the relocation value. For X86, we limit to sign extending the value
   /// if necessary.
   static uint64_t extractValue(uint64_t Type, uint64_t Contents, uint64_t PC);
 
   /// Return true if relocation type is PC-relative. Return false otherwise.

bolt/lib/Core/BinarySection.cpp

for (BinaryPatch &Patch : Patches)
     OS.pwrite(Patch.Bytes.data(), Patch.Bytes.size(),
               SectionFileOffset + Patch.Offset);
 
   for (Relocation &Reloc : PendingRelocations) {
     uint64_t Value = Reloc.Addend;
     if (Reloc.Symbol)
       Value += Resolver(Reloc.Symbol);
 
-    Value = Relocation::adjustValue(Reloc.Type, Value,
+    Value = Relocation::encodeValue(Reloc.Type, Value,
                                     SectionAddress + Reloc.Offset);
 
     OS.pwrite(reinterpret_cast<const char *>(&Value),
               Relocation::getSizeForType(Reloc.Type),
               SectionFileOffset + Reloc.Offset);
 
     LLVM_DEBUG(
         dbgs() << "BOLT-DEBUG: writing value 0x" << Twine::utohexstr(Value)

bolt/lib/Core/Relocation.cpp

static bool skipRelocationProcessAArch64(uint64_t &Type, uint64_t Contents) {
   case ELF::R_AARCH64_LD64_GOT_LO12_NC:
     if (IsAdr(Contents))
       return true;
   }
 
   return false;
 }
 
-static uint64_t adjustValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t encodeValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
-    llvm_unreachable("not supported relocation");
+    llvm_unreachable("unsupported relocation");
+  case ELF::R_X86_64_64:
   case ELF::R_X86_64_32:
     break;
   case ELF::R_X86_64_PC32:
     Value -= PC;
     break;
   }
   return Value;
 }
 
-static uint64_t adjustValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t encodeValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
-    llvm_unreachable("not supported relocation");
+    llvm_unreachable("unsupported relocation");
   case ELF::R_AARCH64_ABS32:
     break;
   case ELF::R_AARCH64_PREL16:
   case ELF::R_AARCH64_PREL32:
   case ELF::R_AARCH64_PREL64:
     Value -= PC;
     break;
   }

 }
 
 bool Relocation::skipRelocationProcess(uint64_t &Type, uint64_t Contents) {
   if (Arch == Triple::aarch64)
     return skipRelocationProcessAArch64(Type, Contents);
   return skipRelocationProcessX86(Type, Contents);
 }
 
-uint64_t Relocation::adjustValue(uint64_t Type, uint64_t Value,
-                                 uint64_t PC) {
+uint64_t Relocation::encodeValue(uint64_t Type, uint64_t Value, uint64_t PC) {
   if (Arch == Triple::aarch64)
-    return adjustValueAArch64(Type, Value, PC);
-  return adjustValueX86(Type, Value, PC);
+    return encodeValueAArch64(Type, Value, PC);
+  return encodeValueX86(Type, Value, PC);
 }
 
 uint64_t Relocation::extractValue(uint64_t Type, uint64_t Contents,
                                   uint64_t PC) {
   if (Arch == Triple::aarch64)
     return extractValueAArch64(Type, Contents, PC);
   return extractValueX86(Type, Contents, PC);
 }