Add {read,write}{16,32,64}{le,be} functions

[ruiu]

Summary

Nothing wrong with reinterpret_cast<llvm::support::ulittle32_t *>(loc),
but that's redundant and not great from readability point of view.
The new functions are wrappers for that kind of reinterpet_casts.

Surprisingly or unsurprisingly, there was no use of big endian read
and write. {read,write}{16,32,64}be has no user. But I think they still
worth to be there in the header for completeness.

[• shankar.easwaran]

lgtm

[davide]

Seems fine, nice cleanup.

[Bigcheese]

These functions already exist llvm/Support/Endian.h as llvm::endian::{read,write}<{u,}int{8,16,32,64}_t, endianness, alignment>. If you would like the short names, typedef these.

[ruiu]

Can I add the typedefs to llvm/Support/Endian.h? Is that too much?

[Bigcheese]

That's fine.

include/lld/Core/Endian.h

+//===--- Endian.h - utility functions for endian-aware reads/writes -----*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_CORE_ENDIAN_H
+#define LLD_CORE_ENDIAN_H
+
+#include "llvm/Support/Endian.h"
+
+namespace lld {
+
+inline uint16_t read16le(const void *p) {
+  return *reinterpret_cast<const llvm::support::ulittle16_t *>(p);
+}
+
+inline uint32_t read32le(const void *p) {
+  return *reinterpret_cast<const llvm::support::ulittle32_t *>(p);
+}
+
+inline uint64_t read64le(const void *p) {
+  return *reinterpret_cast<const llvm::support::ulittle64_t *>(p);
+}
+
+inline void write16le(void *p, uint16_t v) {
+  *reinterpret_cast<llvm::support::ulittle16_t *>(p) = v;
+}
+
+inline void write32le(void *p, uint32_t v) {
+  *reinterpret_cast<llvm::support::ulittle32_t *>(p) = v;
+}
+
+inline void write64le(void *p, uint64_t v) {
+  *reinterpret_cast<llvm::support::ulittle64_t *>(p) = v;
+}
+
+inline uint16_t read16be(const void *p) {
+  return *reinterpret_cast<const llvm::support::ubig16_t *>(p);
+}
+
+inline uint32_t read32be(const void *p) {
+  return *reinterpret_cast<const llvm::support::ubig32_t *>(p);
+}
+
+inline uint64_t read64be(const void *p) {
+  return *reinterpret_cast<const llvm::support::ubig64_t *>(p);
+}
+
+inline void write16be(void *p, uint16_t v) {
+  *reinterpret_cast<llvm::support::ubig16_t *>(p) = v;
+}
+
+inline void write32be(void *p, uint32_t v) {
+  *reinterpret_cast<llvm::support::ubig32_t *>(p) = v;
+}
+
+inline void write64be(void *p, uint64_t v) {
+  *reinterpret_cast<llvm::support::ubig64_t *>(p) = v;
+}
+
+} // namespace lld
+
+#endif

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp ----------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64TargetHandler.h"
 #include "AArch64LinkingContext.h"
+#include "lld/Core/Endian.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace lld;
 using namespace elf;
 
 #define PAGE(X) ((X) & ~0x0FFFL)
 
 /// \brief Check X is in the interval (-2^(bits-1), 2^bits]
 static bool withinSignedUnsignedRange(int64_t X, int bits) {
   return isIntN(bits - 1, X) || isUIntN(bits, X);
 }
 
 /// \brief R_AARCH64_ABS64 - word64: S + A
 static void relocR_AARCH64_ABS64(uint8_t *location, uint64_t P, uint64_t S,
                                  int64_t A) {
   int64_t result = (int64_t)S + A;
   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::ulittle64_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 void relocR_AARCH64_PREL32(uint8_t *location, uint64_t P, uint64_t S,
                                   int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result +
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result + (int32_t)read32le(location));
 }
 
 /// \brief R_AARCH64_ABS32 - word32:  S + A
 static std::error_code relocR_AARCH64_ABS32(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   int64_t result = S + A;
   if (!withinSignedUnsignedRange(result, 32))
     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::ulittle32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
   return std::error_code();
 }
 
 /// \brief R_AARCH64_ADR_PREL_PG_HI21 - Page(S+A) - Page(P)
 static void relocR_AARCH64_ADR_PREL_PG_HI21(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   uint64_t result = (PAGE(S + A) - PAGE(P));
   result = result >> 12;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      immlo | immhi |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, immlo | immhi | read32le(location));
   // TODO: Make sure this is correct!
 }
 
 /// \brief R_AARCH64_ADR_PREL_LO21 - S + A - P
 static void relocR_AARCH64_ADR_PREL_LO21(uint8_t *location, uint64_t P,
                                          uint64_t S, int64_t A) {
   uint64_t result = (S + A) - P;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      immlo | immhi |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, immlo | immhi | read32le(location));
   // TODO: Make sure this is correct!
 }
 
 /// \brief R_AARCH64_ADD_ABS_LO12_NC
 static void relocR_AARCH64_ADD_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                            uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) & 0xFFF);
   result <<= 10;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 static void relocJump26(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
   result &= 0x0FFFFFFC;
   result >>= 2;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_CONDBR19
 static void relocR_AARCH64_CONDBR19(uint8_t *location, uint64_t P, uint64_t S,
                                     int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
   result &= 0x01FFFFC;
   result <<= 3;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST8_ABS_LO12_NC - S + A
 static void relocR_AARCH64_LDST8_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                              uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) & 0xFFF);
   result <<= 10;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST16_ABS_LO12_NC
 static void relocR_AARCH64_LDST16_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FFC;
   result <<= 9;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST32_ABS_LO12_NC
 static void relocR_AARCH64_LDST32_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FFC;
   result <<= 8;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST64_ABS_LO12_NC
 static void relocR_AARCH64_LDST64_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FF8;
   result <<= 7;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST128_ABS_LO12_NC
 static void relocR_AARCH64_LDST128_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                                uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FF8;
   result <<= 6;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 static void 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;
   immlo = immlo << 29;
   immhi = immhi << 3;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      immlo | immhi |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 // R_AARCH64_LD64_GOT_LO12_NC
 static void relocR_AARCH64_LD64_GOT_LO12_NC(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   int32_t result = S + A;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
   result &= 0xFF8;
   result <<= 7;
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 // 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_WITH_TYPE(
       "AArch64", 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");
   result &= 0xFFF;
   result <<= 10;
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 // R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
 static void relocR_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21(uint8_t *location,
                                                      uint64_t P, uint64_t S,
                                                      int64_t A) {
   int64_t result = PAGE(S + A) - PAGE(P);
   result >>= 12;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      immlo | immhi |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, immlo | immhi | read32le(location));
 }
 
 // R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
 static void relocR_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC(uint8_t *location,
                                                        uint64_t P, uint64_t S,
                                                        int64_t A) {
   int32_t result = S + A;
   result &= 0xFF8;
   result <<= 7;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_TLSLE_ADD_TPREL_HI12
 static void relocR_AARCH64_TLSLE_ADD_TPREL_HI12(uint8_t *location, uint64_t P,
                                                 uint64_t S, int64_t A) {
   int32_t result = S + A;
   result &= 0x0FFF000;
   result >>= 2;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_TLSLE_ADD_TPREL_LO12_NC
 static void relocR_AARCH64_TLSLE_ADD_TPREL_LO12_NC(uint8_t *location,
                                                    uint64_t P, uint64_t S,
                                                    int64_t A) {
   int32_t result = S + A;
   result &= 0x0FFF;
   result <<= 10;
   DEBUG_WITH_TYPE(
       "AArch64", 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");
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
 }
 
 std::error_code AArch64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

 //===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp ----------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ARMTargetHandler.h"
 #include "ARMLinkingContext.h"
 
+#include "lld/Core/Endian.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace lld;
 using namespace elf;
 
 static Reference::Addend readAddend_THM_MOV(const uint8_t *location) {
-  const auto halfHi = uint16_t(
-      *reinterpret_cast<const llvm::support::ulittle16_t *>(location));
-  const auto halfLo = uint16_t(
-      *reinterpret_cast<const llvm::support::ulittle16_t *>(location + 2));
+  const uint16_t halfHi = read16le(location);
+  const uint16_t halfLo = read16le(location + 2);
 
   const uint16_t imm8 = halfLo & 0xFF;
   const uint16_t imm3 = (halfLo >> 12) & 0x7;
 
   const uint16_t imm4 = halfHi & 0xF;
   const uint16_t bitI = (halfHi >> 10) & 0x1;
 
   const auto result = int16_t((imm4 << 12) | (bitI << 11) | (imm3 << 8) | imm8);
   return result;
 }
 
 static Reference::Addend readAddend_ARM_MOV(const uint8_t *location) {
-  const auto value = uint32_t(
-      *reinterpret_cast<const llvm::support::ulittle32_t *>(location));
+  const uint32_t value = read32le(location);
 
   const uint32_t imm12 = value & 0xFFF;
   const uint32_t imm4 = (value >> 16) & 0xF;
 
   const auto result = int32_t((imm4 << 12) | imm12);
   return result;
 }
 
 static Reference::Addend readAddend_THM_CALL(const uint8_t *location) {
-  const auto halfHi = uint16_t(
-      *reinterpret_cast<const llvm::support::ulittle16_t *>(location));
-  const auto halfLo = uint16_t(
-      *reinterpret_cast<const llvm::support::ulittle16_t *>(location + 2));
+  const uint16_t halfHi = read16le(location);
+  const uint16_t halfLo = read16le(location + 2);
 
   const uint16_t imm10 = halfHi & 0x3FF;
   const uint16_t bitS = (halfHi >> 10) & 0x1;
 
   const uint16_t imm11 = halfLo & 0x7FF;
   const uint16_t bitJ2 = (halfLo >> 11) & 0x1;
   const uint16_t bitI2 = (~(bitJ2 ^ bitS)) & 0x1;
   const uint16_t bitJ1 = (halfLo >> 13) & 0x1;
   const uint16_t bitI1 = (~(bitJ1 ^ bitS)) & 0x1;
 
   const auto result = int32_t((bitS << 24) | (bitI1 << 23) | (bitI2 << 22) |
                               (imm10 << 12) | (imm11 << 1));
   return llvm::SignExtend64<25>(result);
 }
 
 static Reference::Addend readAddend_ARM_CALL(const uint8_t *location) {
-  const auto value = uint32_t(
-      *reinterpret_cast<const llvm::support::ulittle32_t *>(location));
+  const uint32_t value = read32le(location);
 
   const bool isBLX = (value & 0xF0000000) == 0xF0000000;
   const uint32_t bitH = isBLX ? ((value & 0x1000000) >> 24) : 0;
 
   const auto result = int32_t(((value & 0xFFFFFF) << 2) | (bitH << 1));
   return llvm::SignExtend64<26>(result);
 }
 
 static Reference::Addend readAddend(const uint8_t *location,
                                     Reference::KindValue kindValue) {
   switch (kindValue) {
   case R_ARM_ABS32:
-    return int32_t(
-        *reinterpret_cast<const llvm::support::little32_t *>(location));
+    return (int32_t)read32le(location);
   case R_ARM_THM_CALL:
   case R_ARM_THM_JUMP24:
     return readAddend_THM_CALL(location);
   case R_ARM_CALL:
   case R_ARM_JUMP24:
     return readAddend_ARM_CALL(location);
   case R_ARM_MOVW_ABS_NC:
   case R_ARM_MOVT_ABS:
     return readAddend_ARM_MOV(location);
   case R_ARM_THM_MOVW_ABS_NC:
   case R_ARM_THM_MOVT_ABS:
     return readAddend_THM_MOV(location);
   default:
     return 0;
   }
 }
 
 static inline void applyArmReloc(uint8_t *location, uint32_t result,
                                  uint32_t mask = 0xFFFFFFFF) {
   assert(!(result & ~mask));
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
-      (uint32_t(*reinterpret_cast<llvm::support::ulittle32_t *>(location)) &
-       ~mask) | (result & mask);
+  write32le(location, (read32le(location) & ~mask) | (result & mask));
 }
 
 static inline void applyThmReloc(uint8_t *location, uint16_t resHi,
                                  uint16_t resLo, uint16_t maskHi,
                                  uint16_t maskLo = 0xFFFF) {
   assert(!(resHi & ~maskHi) && !(resLo & ~maskLo));
-  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
-      (uint16_t(*reinterpret_cast<llvm::support::ulittle16_t *>(location)) &
-       ~maskHi) | (resHi & maskHi);
+  write16le(location, (read16le(location) & ~maskHi) | (resHi & maskHi));
   location += 2;
-  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
-      (uint16_t(*reinterpret_cast<llvm::support::ulittle16_t *>(location)) &
-       ~maskLo) | (resLo & maskLo);
+  write16le(location, (read16le(location) & ~maskLo) | (resLo & maskLo));
 }
 
 /// \brief R_ARM_ABS32 - (S + A) | T
 static void relocR_ARM_ABS32(uint8_t *location, uint64_t P, uint64_t S,
                              int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)((S + A) | T);
 

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp ---------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "HexagonTargetHandler.h"
 #include "HexagonLinkingContext.h"
 #include "HexagonRelocationFunctions.h"
+#include "HexagonTargetHandler.h"
 #include "HexagonRelocationHandler.h"
+#include "lld/Core/Endian.h"
 
 using namespace lld;
 using namespace elf;
 
 using namespace llvm::ELF;
 
 #define APPLY_RELOC(result)                                                    \
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =                  \
-      result |                                                                 \
-      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  write32le(location, result | read32le(location));
 
 static int relocBNPCREL(uint8_t *location, uint64_t P, uint64_t S, uint64_t A,
                         int32_t nBits) {
   int32_t result = (uint32_t)(((S + A) - P) >> 2);
   int32_t range = 1 << nBits;
   if (result < range && result > -range) {
     result = lld::scatterBits<int32_t>(result, FINDV4BITMASK(location));
     APPLY_RELOC(result);
case R_HEX_GOTREL_11_X:
     break;
 
   default:
     return make_unhandled_reloc_error();
   }
 
   return std::error_code();
 }
-
-

lib/ReaderWriter/ELF/X86/X86RelocationHandler.cpp

 //===- lib/ReaderWriter/ELF/X86/X86RelocationHandler.cpp ------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86LinkingContext.h"
 #include "X86TargetHandler.h"
+#include "lld/Core/Endian.h"
 
 using namespace lld;
 using namespace elf;
 
 namespace {
 /// \brief R_386_32 - word32:  S + A
 static int reloc32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
   int32_t result = (uint32_t)(S + A);
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
-      result |
-      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  write32le(location, result | read32le(location));
   return 0;
 }
 
 /// \brief R_386_PC32 - word32: S + A - P
 static int relocPC32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
   uint32_t result = (uint32_t)((S + A) - P);
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
-      result +
-      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  write32le(location, result + read32le(location));
   return 0;
 }
 }
 
 std::error_code X86TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

 //===- lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp ------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
+#include "lld/Core/Endian.h"
 
 using namespace lld;
 using namespace elf;
 
 /// \brief R_X86_64_64 - word64: S + A
 static void reloc64(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   uint64_t result = S + A;
-  *reinterpret_cast<llvm::support::ulittle64_t *>(location) =
-      result |
-      (uint64_t) * reinterpret_cast<llvm::support::ulittle64_t *>(location);
+  write64le(location, result | read64le(location));
 }
 
 /// \brief R_X86_64_PC32 - word32: S + A - P
 static void relocPC32(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   uint32_t result = (uint32_t)((S + A) - P);
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
-      result +
-      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  write32le(location, result + read32le(location));
 }
 
 /// \brief R_X86_64_32 - word32:  S + A
 static void reloc32(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (uint32_t)(S + A);
-  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
-      result |
-      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  write32le(location, result | read32le(location));
   // TODO: Make sure that the result zero extends to the 64bit value.
 }
 
 /// \brief R_X86_64_32S - word32:  S + A
 static void reloc32S(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
-  *reinterpret_cast<llvm::support::little32_t *>(location) =
-      result |
-      (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
+  write32le(location, result | read32le(location));
   // 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) {
   uint16_t result = (uint16_t)(S + A);
-  *reinterpret_cast<llvm::support::ulittle16_t *>(location) =
-      result |
-      (uint16_t) * reinterpret_cast<llvm::support::ulittle16_t *>(location);
+  write16le(location, result | read16le(location));
   // TODO: Check for overflow.
 }
 
 /// \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);
+  write64le(location, result | read64le(location));
 }
 
 std::error_code X86_64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
case R_X86_64_16:
     reloc16(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_X86_64_TPOFF64:
   case R_X86_64_DTPOFF32:
   case R_X86_64_TPOFF32: {
     _tlsSize = _x86_64Layout.getTLSSize();
     if (ref.kindValue() == R_X86_64_TPOFF32 ||
         ref.kindValue() == R_X86_64_DTPOFF32) {
-      int32_t result = (int32_t)(targetVAddress - _tlsSize);
-      *reinterpret_cast<llvm::support::little32_t *>(location) = result;
+      write32le(location, targetVAddress - _tlsSize);
     } else {
-      int64_t result = (int64_t)(targetVAddress - _tlsSize);
-      *reinterpret_cast<llvm::support::little64_t *>(location) = result;
+      write64le(location, targetVAddress - _tlsSize);
     }
     break;
   }
   case R_X86_64_TLSGD: {
     relocPC32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   }
   case R_X86_64_TLSLD: {

lib/ReaderWriter/PECOFF/IdataPass.cpp

 //===- lib/ReaderWriter/PECOFF/IdataPass.cpp ------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IdataPass.h"
 #include "Pass.h"
+#include "lld/Core/Endian.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
 #include "lld/Core/Simple.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include <algorithm>
 #include <cstddef>

 
 std::vector<uint8_t> HintNameAtom::assembleRawContent(uint16_t hint,
                                                       StringRef importName) {
   size_t size =
       llvm::RoundUpToAlignment(sizeof(hint) + importName.size() + 1, 2);
   std::vector<uint8_t> ret(size);
   ret[importName.size()] = 0;
   ret[importName.size() - 1] = 0;
-  *reinterpret_cast<llvm::support::ulittle16_t *>(&ret[0]) = hint;
+  write16le(&ret[0], hint);
   std::memcpy(&ret[2], importName.data(), importName.size());
   return ret;
 }
 
 std::vector<uint8_t>
 ImportTableEntryAtom::assembleRawContent(uint64_t rva, bool is64) {
   // The element size of the import table is 32 bit in PE and 64 bit
   // in PE+. In PE+, bits 62-31 are filled with zero.
   if (is64) {
     std::vector<uint8_t> ret(8);
-    *reinterpret_cast<llvm::support::ulittle64_t *>(&ret[0]) = rva;
+    write64le(&ret[0], rva);
     return ret;
   }
   std::vector<uint8_t> ret(4);
-  *reinterpret_cast<llvm::support::ulittle32_t *>(&ret[0]) = rva;
+  write32le(&ret[0], rva);
   return ret;
 }
 
 static std::vector<ImportTableEntryAtom *>
 createImportTableAtoms(IdataContext &context,
                        const std::vector<COFFSharedLibraryAtom *> &sharedAtoms,
                        bool shouldAddReference, StringRef sectionName,
                        llvm::BumpPtrAllocator &alloc) {

lib/ReaderWriter/PECOFF/ReaderImportHeader.cpp

 ///
 /// The function in this file reads a pseudo object file and creates at most two
 /// atoms. One is a shared library atom for _imp__ symbol. The another is a
 /// defined atom for the JMP instruction if the symbol is for a function.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
+#include "lld/Core/Endian.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/SharedLibraryAtom.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Casting.h"
FileImportLibrary(std::unique_ptr<MemoryBuffer> mb, MachineTypes machine)
       : File(mb->getBufferIdentifier(), kindSharedLibrary),
         _mb(std::move(mb)),  _machine(machine) {}
 
   std::error_code doParse() override {
     const char *buf = _mb->getBufferStart();
     const char *end = _mb->getBufferEnd();
 
     // The size of the string that follows the header.
-    uint32_t dataSize = *reinterpret_cast<const support::ulittle32_t *>(
-        buf + offsetof(COFF::ImportHeader, SizeOfData));
+    uint32_t dataSize
+        = read32le(buf + offsetof(COFF::ImportHeader, SizeOfData));
 
     // Check if the total size is valid.
     if (std::size_t(end - buf) != sizeof(COFF::ImportHeader) + dataSize)
       return make_error_code(NativeReaderError::unknown_file_format);
 
-    uint16_t hint = *reinterpret_cast<const support::ulittle16_t *>(
-        buf + offsetof(COFF::ImportHeader, OrdinalHint));
+    uint16_t hint = read16le(buf + offsetof(COFF::ImportHeader, OrdinalHint));
     StringRef symbolName(buf + sizeof(COFF::ImportHeader));
     StringRef dllName(buf + sizeof(COFF::ImportHeader) + symbolName.size() + 1);
 
     // TypeInfo is a bitfield. The least significant 2 bits are import
     // type, followed by 3 bit import name type.
-    uint16_t typeInfo = *reinterpret_cast<const support::ulittle16_t *>(
-        buf + offsetof(COFF::ImportHeader, TypeInfo));
+    uint16_t typeInfo = read16le(buf + offsetof(COFF::ImportHeader, TypeInfo));
     int type = typeInfo & 0x3;
     int nameType = (typeInfo >> 2) & 0x7;
 
     // Symbol name used by the linker may be different from the symbol name used
     // by the loader. The latter may lack symbol decorations, or may not even
     // have name if it's imported by ordinal.
     StringRef importName = symbolNameToImportName(symbolName, nameType);
 

lib/ReaderWriter/PECOFF/WriterPECOFF.cpp

 ///
 /// This writer currently supports 32 bit PE/COFF for x86 processor only.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
 #include "WriterImportLibrary.h"
 #include "lld/Core/DefinedAtom.h"
+#include "lld/Core/Endian.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Writer.h"
 #include "lld/ReaderWriter/AtomLayout.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
if (_stringTable.empty()) {
       // don't like zero-length symbol table.
       // Make room for the empty symbol slot, which occupies 18 byte.
       // We also need to reserve 4 bytes for the string table header.
       int size = sizeof(llvm::object::coff_symbol16) + 4;
       _stringTable.insert(_stringTable.begin(), size, 0);
       // Set the name of the dummy symbol to the first string table entry.
       // It's better than letting dumpbin print out a garabage as a symbol name.
       char *off = _stringTable.data() + 4;
-      *reinterpret_cast<ulittle32_t *>(off) = 4;
+      write32le(off, 4);
     }
     uint32_t offset = _stringTable.size();
     _stringTable.insert(_stringTable.end(), sectionName.begin(),
                         sectionName.end());
     _stringTable.push_back('\0');
     return offset - sizeof(llvm::object::coff_symbol16);
   }
 
   uint64_t size() const override { return _stringTable.size(); }
 
   void write(uint8_t *buffer) override {
     if (_stringTable.empty())
       return;
     char *off = _stringTable.data() + sizeof(llvm::object::coff_symbol16);
-    *reinterpret_cast<ulittle32_t *>(off) = _stringTable.size();
+    write32le(off, _stringTable.size());
     std::memcpy(buffer, _stringTable.data(), _stringTable.size());
   }
 
 private:
   std::vector<char> _stringTable;
 };
 
 class SectionChunk : public Chunk {
BaseRelocChunk::createBaseRelocBlock(uint64_t pageAddr,
   // aligned to a DWORD size boundary.
   uint32_t size = llvm::RoundUpToAlignment(
       sizeof(ulittle32_t) * 2 + sizeof(ulittle16_t) * relocs.size(),
       sizeof(ulittle32_t));
   std::vector<uint8_t> contents(size);
   uint8_t *ptr = &contents[0];
 
   // The first four bytes is the page RVA.
-  *reinterpret_cast<ulittle32_t *>(ptr) = pageAddr;
+  write32le(ptr, pageAddr);
   ptr += sizeof(ulittle32_t);
 
   // The second four bytes is the size of the block, including the the page
   // RVA and this size field.
-  *reinterpret_cast<ulittle32_t *>(ptr) = size;
+  write32le(ptr, size);
   ptr += sizeof(ulittle32_t);
 
   for (const auto &reloc : relocs) {
     assert(reloc.first < _ctx.getPageSize());
-    *reinterpret_cast<ulittle16_t *>(ptr) = (reloc.second << 12) | reloc.first;
+    write16le(ptr, (reloc.second << 12) | reloc.first);
     ptr += sizeof(ulittle16_t);
   }
   return contents;
 }
 
 } // end anonymous namespace
 
 class PECOFFWriter : public Writer {