[PATCH 08/13] ELF/Aarch64: Fix R_AARCH64_ADR_GOT_PAGE write and some cleanus

[zatrazz]

Summary

This patch fixes the R_AARCH64_ADR_GOT_PAGE write by using the correct values
on final write and also adds some cleanups:

• Use write{16,32,64}le and read{16,32,64}le on relocR_AARCH64_ABS16, relocR_AARCH64_ABS16, relocR_AARCH64_PREL32, relocR_AARCH64_PREL16,

• Add error core for unaligned cases for relocR_AARCH64_LD64_GOT_LO12_NC.

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp

static std::error_code relocR_AARCH64_ABS16(uint8_t *location, uint64_t P,
   if (!withinSignedUnsignedRange(result, 16))
     return make_out_of_range_reloc_error();
   DEBUG_WITH_TYPE(
       "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
       llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
       llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
       llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
       llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
-  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
-      result |
-      (int16_t) * reinterpret_cast<llvm::support::little16_t *>(location);
+  write16le(location, result | read16le(location));
   return std::error_code();
 }
 
 /// \brief R_AARCH64_PREL64 - word64: S + A - P
 static void relocR_AARCH64_PREL64(uint8_t *location, uint64_t P,
                                   uint64_t S, int64_t A) {
   int64_t result = S + A - P;
-  *reinterpret_cast<llvm::support::little64_t *>(location) =
-      result +
-      (int64_t) * reinterpret_cast<llvm::support::little64_t *>(location);
+  write64le(location, result | read64le(location));
 }
 
 /// \brief R_AARCH64_PREL32 - word32: S + A - P
 static std::error_code relocR_AARCH64_PREL32(uint8_t *location, uint64_t P,
                                              uint64_t S, int64_t A) {
   int64_t result = S + A - P;
   if (!withinSignedUnsignedRange(result, 32))
     return make_out_of_range_reloc_error();
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result +
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
   return std::error_code();
 }
 
 /// \brief R_AARCH64_PREL16 - word16: S + A - P
 static std::error_code relocR_AARCH64_PREL16(uint8_t *location, uint64_t P,
                                              uint64_t S, int64_t A) {
   int64_t result = S + A - P;
   if (!withinSignedUnsignedRange(result, 16))
     return make_out_of_range_reloc_error();
-  *reinterpret_cast<llvm::support::little16_t *>(location) =
-      result +
-      (int16_t) * reinterpret_cast<llvm::support::little16_t *>(location);
+  write16le(location, result | read16le(location));
   return std::error_code();
 }
 
 /// \brief R_AARCH64_ADR_PREL_PG_HI21 - Page(S+A) - Page(P)
 static std::error_code relocR_AARCH64_ADR_PREL_PG_HI21(uint8_t *location,
                                                        uint64_t P, uint64_t S,
                                                        int64_t A) {
   int64_t result = PAGE(S + A) - PAGE(P);
static void relocR_AARCH64_LDST128_ABS_LO12_NC(uint8_t *location, uint64_t P,
   DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
-static void relocR_AARCH64_ADR_GOT_PAGE(uint8_t *location, uint64_t P,
+static std::error_code relocR_AARCH64_ADR_GOT_PAGE(uint8_t *location, uint64_t P,
                                         uint64_t S, int64_t A) {
   uint64_t result = PAGE(S + A) - PAGE(P);
-  result >>= 12;
-  uint32_t immlo = result & 0x3;
-  uint32_t immhi = result & 0x1FFFFC;
+  if (!isInt<32>(result))
+    return make_out_of_range_reloc_error();
+  result = (result >> 12) & 0x3FFFFL;
+  uint32_t immlo = result & 0x3L;
+  uint32_t immhi = result & 0x1FFFFCL;
   immlo = immlo << 29;
   immhi = immhi << 3;
-  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
-        llvm::dbgs() << " S: " << Twine::utohexstr(S);
-        llvm::dbgs() << " A: " << Twine::utohexstr(A);
-        llvm::dbgs() << " P: " << Twine::utohexstr(P);
-        llvm::dbgs() << " immhi: " << Twine::utohexstr(immhi);
-        llvm::dbgs() << " immlo: " << Twine::utohexstr(immlo);
-        llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
-  write32le(location, result | read32le(location));
+  DEBUG_WITH_TYPE(
+      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  write32le(location, immlo | immhi | read32le(location));
+  return std::error_code();
 }
 
 // R_AARCH64_LD64_GOT_LO12_NC
-static void relocR_AARCH64_LD64_GOT_LO12_NC(uint8_t *location, uint64_t P,
+static std::error_code relocR_AARCH64_LD64_GOT_LO12_NC(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   int32_t result = S + A;
-  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
-        llvm::dbgs() << " S: " << Twine::utohexstr(S);
-        llvm::dbgs() << " A: " << Twine::utohexstr(A);
-        llvm::dbgs() << " P: " << Twine::utohexstr(P);
-        llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
+  DEBUG_WITH_TYPE(
+      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  if ((result & 0x7) != 0)
+    return make_unaligned_range_reloc_error();
   result &= 0xFF8;
   result <<= 7;
   write32le(location, result | read32le(location));
+  return std::error_code();
 }
 
 // ADD_AARCH64_GOTRELINDEX
 static void relocADD_AARCH64_GOTRELINDEX(uint8_t *location, uint64_t P,
                                          uint64_t S, int64_t A) {
   int32_t result = S + A;
   DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
std::error_code AArch64TargetRelocationHandler::applyRelocation(
   case R_AARCH64_JUMP26:
     relocJump26(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_AARCH64_CONDBR19:
     relocR_AARCH64_CONDBR19(location, relocVAddress, targetVAddress,
                             ref.addend());
     break;
   case R_AARCH64_ADR_GOT_PAGE:
-    relocR_AARCH64_ADR_GOT_PAGE(location, relocVAddress, targetVAddress,
+    return relocR_AARCH64_ADR_GOT_PAGE(location, relocVAddress, targetVAddress,
                                        ref.addend());
-    break;
   case R_AARCH64_LD64_GOT_LO12_NC:
-    relocR_AARCH64_LD64_GOT_LO12_NC(location, relocVAddress, targetVAddress,
+    return relocR_AARCH64_LD64_GOT_LO12_NC(location, relocVAddress, targetVAddress,
                                            ref.addend());
-    break;
   case R_AARCH64_LDST8_ABS_LO12_NC:
     relocR_AARCH64_LDST8_ABS_LO12_NC(location, relocVAddress, targetVAddress,
                                      ref.addend());
     break;
   case R_AARCH64_LDST16_ABS_LO12_NC:
     relocR_AARCH64_LDST16_ABS_LO12_NC(location, relocVAddress, targetVAddress,
                                       ref.addend());
     break;

lib/ReaderWriter/ELF/TargetHandler.h

 inline std::error_code make_unhandled_reloc_error() {
   return make_dynamic_error_code(Twine("Unhandled reference type"));
 }
 
 inline std::error_code make_out_of_range_reloc_error() {
   return make_dynamic_error_code(Twine("Relocation out of range"));
 }
 
+inline std::error_code make_unaligned_range_reloc_error() {
+  return make_dynamic_error_code(Twine("Relocation not aligned"));
+}
+
 } // end namespace elf
 } // end namespace lld
 
 #endif