[lld] [mach-o] make lld respect alignment constraints more

[t.p.northover]

Summary

Hi all,

At the moment, lld is very lax about casting random pointers to ones with ABI alignment requirements, and even dereferencing them afterwards. This is not good, and we spend a lot of our time telling other developers not to do that (and that it's their fault their program now crashes), so we should probably get it right ourselves. Preferably *before* it bites us.

One big part of this (but not the only one) is the interface presented by the endian utility functions "readN" and "writeN", which effectively forces the creation of dodgy pointers. This patch attempts to fix them.

I also change the functions to have a more consistent interface (all use uintN_t) and change the "swap" parameter ("are we compiling for an architecture that's different to our own?") into an absolute "isBig" ("are we compiling for a big-endian target?").

The interfaces are still ugly, and if anyone has a better suggestion I'd love to hear it (this patch catches all uses, so it would be a good time to refactor it properly if there's a better way). Ideas I've considered so far:

• read<uint32_t>(...). Slightly nicer implementation, but even more verbose usage. Might be worth it if structs could be accommodated.
• "typedef ulittle32_t utarget32_t" in ArchHandler or similar. Would require making *everything* a template.
• virtual functions in ArchHandler. Would eliminate passing isBig around, but may not always have an ArchHandler.

How does it look?

Tim.

[kledzik]

How come in the ArchHandler_x86_64 you use:

write32(loc, value, false);

but inside

[kledzik]

How come in the ArchHandler_x86_64 you use:

write32(loc, value, false);

but inside ArchHandler_arm64 you use:

write32(loc, value, _isBig);

Seems like each arch has a fixed endianness. Given that,

write32(loc, value, false);

could be optimized to:

writeLittle32(loc, value); // or use little32_t directly?

Have you looked at the codegen of this verse the old 'swap' parameter. Just to make sure the compiler really is optimizing what you think it should be?

[t.p.northover]

Good point. After thinking about it over night, I'm leaning towards directly using ulittle and ubig within each ArchHandler. I'll see how it looks.

[t.p.northover]

I definitely think it's neater with the explicit ulittle32_t in the individual archhandlers; shame we can't do something similar in the generic code.

I also checked speed on check-lld. The difference (if there was one) seemed to be well within the noise limits.

Does it look better to you too?

Cheers.

Tim.

[kledzik]

The ArchHandlers look much better!

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

266–268

This is sad that the casts are needed. Perhaps, read32() can be overloaded to take a uint32_t* so all these casts can be removed.

[t.p.northover]

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

266–268

I was trying to avoid it (even creating improperly aligned pointers is very dodgy, anything making that easier is a worry), but there are a lot of casts here. I'll make them templated and put an assertion about pointer alignment in there.

[t.p.northover]

How about this? I think all the readN calls are cast-free now.

[kledzik]

LGTM

[t.p.northover]

Thanks Nick. Should be r220730.

lib/ReaderWriter/MachO/ArchHandler.h

public:
   /// Analyzes a relocation from a .o file and returns the info
   /// (kind, target, addend) needed to instantiate a Reference.
   /// Two helper functions are passed as parameters to find the target atom
   /// given a symbol index or address.
   virtual std::error_code 
           getReferenceInfo(const normalized::Relocation &reloc,
                            const DefinedAtom *inAtom,
                            uint32_t offsetInAtom,
-                           uint64_t fixupAddress, bool swap,
+                           uint64_t fixupAddress, bool isBigEndian,
                            FindAtomBySectionAndAddress atomFromAddress,
                            FindAtomBySymbolIndex atomFromSymbolIndex,
                            Reference::KindValue *kind, 
                            const lld::Atom **target, 
                            Reference::Addend *addend) = 0;
 
   /// Analyzes a pair of relocations from a .o file and returns the info
   /// (kind, target, addend) needed to instantiate a Reference.
   /// Two helper functions are passed as parameters to find the target atom
   /// given a symbol index or address.
   virtual std::error_code 
       getPairReferenceInfo(const normalized::Relocation &reloc1,
                            const normalized::Relocation &reloc2,
                            const DefinedAtom *inAtom,
                            uint32_t offsetInAtom,
-                           uint64_t fixupAddress, bool swap,
+                           uint64_t fixupAddress, bool isBig,
                            FindAtomBySectionAndAddress atomFromAddress,
                            FindAtomBySymbolIndex atomFromSymbolIndex,
                            Reference::KindValue *kind, 
                            const lld::Atom **target, 
                            Reference::Addend *addend) = 0;
 
   /// Prototype for a helper function.  Given an atom, finds the symbol table
   /// index for it in the output file.
public:
 
   /// Only relevant for 32-bit arm archs.
   virtual const DefinedAtom *createShim(MachOFile &file, bool thumbToArm,
                                         const DefinedAtom &) {
     llvm_unreachable("shims only support on arm");
   }
 
   /// Does a given unwind-cfi atom represent a CIE (as opposed to an FDE).
-  static bool isDwarfCIE(bool swap, const DefinedAtom *atom);
+  static bool isDwarfCIE(bool isBig, const DefinedAtom *atom);
 
   struct ReferenceInfo {
     Reference::KindArch arch;
     uint16_t            kind;
     uint32_t            offset;
     int32_t             addend;
   };
 
protected:
   /// Create normalized Relocation initialized from pattern.
   static normalized::Relocation relocFromPattern(RelocPattern pattern);
   /// One liner to add a relocation.
   static void appendReloc(normalized::Relocations &relocs, uint32_t offset,
                           uint32_t symbol, uint32_t value,
                           RelocPattern pattern);
 
 
-  static int16_t  readS16(bool swap, const uint8_t *addr);
-  static int32_t  readS32(bool swap, const uint8_t *addr);
-  static uint32_t readU32(bool swap, const uint8_t *addr);
-  static int64_t  readS64(bool swap, const uint8_t *addr);
+  static int16_t  readS16(const uint8_t *addr, bool isBig);
+  static int32_t  readS32(const uint8_t *addr, bool isBig);
+  static uint32_t readU32(const uint8_t *addr, bool isBig);
+  static int64_t  readS64(const uint8_t *addr, bool isBig);
 };
 
 } // namespace mach_o
 } // namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_ARCH_HANDLER_H

lib/ReaderWriter/MachO/ArchHandler.cpp

void ArchHandler::appendReloc(normalized::Relocations &relocs, uint32_t offset,
   normalized::Relocation reloc = relocFromPattern(pattern);
   reloc.offset = offset;
   reloc.symbol = symbol;
   reloc.value  = value;
   relocs.push_back(reloc);
 }
 
 
-int16_t ArchHandler::readS16(bool swap, const uint8_t *addr) {
-  return read16(swap, *reinterpret_cast<const uint16_t*>(addr));
+int16_t ArchHandler::readS16(const uint8_t *addr, bool isBig) {
+    return read16(addr, isBig);
 }
 
-int32_t ArchHandler::readS32(bool swap, const uint8_t *addr) {
-  return read32(swap, *reinterpret_cast<const uint32_t*>(addr));
+int32_t ArchHandler::readS32(const uint8_t *addr, bool isBig) {
+  return read32(addr, isBig);
 }
 
-uint32_t ArchHandler::readU32(bool swap, const uint8_t *addr) {
-  return read32(swap, *reinterpret_cast<const uint32_t*>(addr));
+uint32_t ArchHandler::readU32(const uint8_t *addr, bool isBig) {
+  return read32(addr, isBig);
 }
 
-int64_t ArchHandler::readS64(bool swap, const uint8_t *addr) {
-  return read64(swap, *reinterpret_cast<const uint64_t*>(addr));
+  int64_t ArchHandler::readS64(const uint8_t *addr, bool isBig) {
+  return read64(addr, isBig);
 }
 
-bool ArchHandler::isDwarfCIE(bool swap, const DefinedAtom *atom) {
+bool ArchHandler::isDwarfCIE(bool isBig, const DefinedAtom *atom) {
   assert(atom->contentType() == DefinedAtom::typeCFI);
-  uint32_t size = read32(swap, *(uint32_t *)atom->rawContent().data());
+  uint32_t size = read32(atom->rawContent().data(), isBig);
 
   uint32_t idOffset = sizeof(uint32_t);
   if (size == 0xffffffffU)
     idOffset += sizeof(uint64_t);
 
-  return read32(swap, *(uint32_t *)(atom->rawContent().data() + idOffset)) == 0;
+  return read32(atom->rawContent().data() + idOffset, isBig) == 0;
 }
 
 const Atom *ArchHandler::fdeTargetFunction(const DefinedAtom *fde) {
   for (auto ref : *fde) {
     if (ref->kindNamespace() == Reference::KindNamespace::mach_o &&
         ref->kindValue() == unwindRefToFunctionKind()) {
       assert(ref->kindArch() == kindArch() && "unexpected Reference arch");
       return ref->target();

lib/ReaderWriter/MachO/ArchHandler_arm.cpp

 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "MachONormalizedFileBinaryUtils.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 namespace lld {
 namespace mach_o {
 
+using llvm::support::ulittle32_t;
+using llvm::support::little32_t;
+
+
 class ArchHandler_arm : public ArchHandler {
 public:
            ArchHandler_arm();
   virtual ~ArchHandler_arm();
 
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override { return Reference::KindArch::ARM; }
void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t inAtomAddress, bool &thumbMode,
                        bool targetIsThumb);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress,
                              uint64_t targetAddress,
                              uint64_t inAtomAddress, bool &thumbMode,
                              bool targetIsThumb);
-  
-  const bool _swap;
 };
 
 //===----------------------------------------------------------------------===//
 //  ArchHandler_arm
 //===----------------------------------------------------------------------===//
 
-ArchHandler_arm::ArchHandler_arm() :
-  _swap(!MachOLinkingContext::isHostEndian(MachOLinkingContext::arch_armv7)) {}
+ArchHandler_arm::ArchHandler_arm() { }
 
 ArchHandler_arm::~ArchHandler_arm() { }
 
 const Registry::KindStrings ArchHandler_arm::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(modeThumbCode),
   LLD_KIND_STRING_ENTRY(modeArmCode),
   LLD_KIND_STRING_ENTRY(modeData),
   LLD_KIND_STRING_ENTRY(thumb_bl22),
if (isa<DefinedAtom>(target)) {
         value &= -2; // mask off thumb-bit
     }
   }
   return value;
 }
 
 std::error_code ArchHandler_arm::getReferenceInfo(
     const Relocation &reloc, const DefinedAtom *inAtom, uint32_t offsetInAtom,
-    uint64_t fixupAddress, bool swap,
+    uint64_t fixupAddress, bool isBig,
     FindAtomBySectionAndAddress atomFromAddress,
     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
     const lld::Atom **target, Reference::Addend *addend) {
   typedef std::error_code E;
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
-  uint32_t instruction = readU32(swap, fixupContent);
+  uint32_t instruction = *(ulittle32_t *)fixupContent;
   int32_t displacement;
   switch (relocPattern(reloc)) {
   case ARM_THUMB_RELOC_BR22 | rPcRel | rExtern | rLength4:
     // ex: bl _foo (and _foo is undefined)
     if ((instruction & 0xD000F800) == 0x9000F000)
       *kind = thumb_b22;
     else
       *kind = thumb_bl22;
std::error_code ArchHandler_arm::getReferenceInfo(
   return std::error_code();
 }
 
 std::error_code
 ArchHandler_arm::getPairReferenceInfo(const normalized::Relocation &reloc1,
                                      const normalized::Relocation &reloc2,
                                      const DefinedAtom *inAtom,
                                      uint32_t offsetInAtom,
-                                     uint64_t fixupAddress, bool swap,
+                                     uint64_t fixupAddress, bool isBig,
                                      FindAtomBySectionAndAddress atomFromAddr,
                                      FindAtomBySymbolIndex atomFromSymbolIndex,
                                      Reference::KindValue *kind,
                                      const lld::Atom **target,
                                      Reference::Addend *addend) {
   bool pointerDiff = false;
   bool funcRel;
   bool top;
case ((ARM_RELOC_LOCAL_SECTDIFF | rScattered | rLength4) << 16 |
     // ex: .long _foo - .
     pointerDiff = true;
     break;
   default:
     return make_dynamic_error_code(Twine("unsupported arm relocation pair"));
   }
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   std::error_code ec;
-  uint32_t instruction = readU32(swap, fixupContent);
+  uint32_t instruction = *(ulittle32_t *)fixupContent;
   uint32_t value;
   uint32_t fromAddress;
   uint32_t toAddress;
   uint16_t instruction16;
   uint16_t other16;
   const lld::Atom *fromTarget;
   Reference::Addend offsetInTo;
   Reference::Addend offsetInFrom;
if (reloc1.isExtern) {
         return ec;
       *addend = value - toAddress;
     }
   }
 
   return std::error_code();
 }
 
-void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *location,
+void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *loc,
                                       uint64_t fixupAddress,
                                       uint64_t targetAddress,
                                       uint64_t inAtomAddress,
                                       bool &thumbMode, bool targetIsThumb) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::ARM);
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
   int32_t displacement;
   uint16_t value16;
   uint32_t value32;
   switch (ref.kindValue()) {
   case modeThumbCode:
     thumbMode = true;
     break;
   case modeArmCode:
     thumbMode = false;
     break;
   case modeData:
     break;
   case thumb_b22:
   case thumb_bl22:
     assert(thumbMode);
     displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
-    value32 = setDisplacementInThumbBranch(*loc32, fixupAddress, displacement,
-                                           targetIsThumb);
-    write32(*loc32, _swap, value32);
+    value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
+                                           displacement, targetIsThumb);
+    *loc32 = value32;
     break;
   case thumb_movw:
     assert(thumbMode);
     value16 = (targetAddress + ref.addend()) & 0xFFFF;
     if (targetIsThumb)
       value16 |= 1;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movt:
     assert(thumbMode);
     value16 = (targetAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movw_funcRel:
     assert(thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
     if (targetIsThumb)
       value16 |= 1;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movt_funcRel:
     assert(thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case arm_b24:
   case arm_bl24:
    assert(!thumbMode);
     displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
     value32 = setDisplacementInArmBranch(*loc32, displacement, targetIsThumb);
-    write32(*loc32, _swap, value32);
+    *loc32 = value32;
     break;
   case arm_movw:
     assert(!thumbMode);
     value16 = (targetAddress + ref.addend()) & 0xFFFF;
     if (targetIsThumb)
       value16 |= 1;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movt:
     assert(!thumbMode);
     value16 = (targetAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movw_funcRel:
     assert(!thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
     if (targetIsThumb)
       value16 |= 1;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movt_funcRel:
     assert(!thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case pointer32:
     if (targetIsThumb)
-      write32(*loc32, _swap, targetAddress + ref.addend() + 1);
+      *loc32 = targetAddress + ref.addend() + 1;
     else
-      write32(*loc32, _swap, targetAddress + ref.addend());
+      *loc32 = targetAddress + ref.addend();
     break;
   case delta32:
     if (targetIsThumb)
-      write32(*loc32, _swap, targetAddress - fixupAddress + ref.addend() + 1);
+      *loc32 = targetAddress - fixupAddress + ref.addend() + 1;
     else
-      write32(*loc32, _swap, targetAddress - fixupAddress + ref.addend());
+      *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
   case invalid:
     llvm_unreachable("invalid ARM Reference Kind");
     break;
if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&target)) {
      default:
        break;
     }
   }
   // Everything else is reference via an internal relocation.
   return false;
 }
 
-void ArchHandler_arm::applyFixupRelocatable(const Reference &ref,
-                                             uint8_t *location,
-                                             uint64_t fixupAddress,
-                                             uint64_t targetAddress,
-                                             uint64_t inAtomAddress,
-                                             bool &thumbMode,
-                                             bool targetIsThumb) {
+void ArchHandler_arm::applyFixupRelocatable(const Reference &ref, uint8_t *loc,
   bool useExternalReloc = useExternalRelocationTo(*ref.target());
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
   int32_t displacement;
   uint16_t value16;
   uint32_t value32;
   switch (ref.kindValue()) {
   case modeThumbCode:
     thumbMode = true;
     break;
   case modeArmCode:
     thumbMode = false;
     break;
   case modeData:
     break;
   case thumb_b22:
   case thumb_bl22:
     assert(thumbMode);
     if (useExternalReloc)
       displacement = (ref.addend() - (fixupAddress + 4));
     else
       displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
-    value32 = setDisplacementInThumbBranch(*loc32, fixupAddress, displacement,
-                                           targetIsThumb);
-    write32(*loc32, _swap, value32);
+    value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
+                                           displacement, targetIsThumb);
+    *loc32 = value32;
     break;
   case thumb_movw:
     assert(thumbMode);
     if (useExternalReloc)
       value16 = ref.addend() & 0xFFFF;
     else
       value16 = (targetAddress + ref.addend()) & 0xFFFF;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movt:
     assert(thumbMode);
     if (useExternalReloc)
       value16 = ref.addend() >> 16;
     else
       value16 = (targetAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movw_funcRel:
     assert(thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case thumb_movt_funcRel:
     assert(thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromThumbMov(*loc32, value16));
+    *loc32 = setWordFromThumbMov(*loc32, value16);
     break;
   case arm_b24:
   case arm_bl24:
     assert(!thumbMode);
     if (useExternalReloc)
       displacement = (ref.addend() - (fixupAddress + 8));
     else
       displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
-    value32 = setDisplacementInArmBranch(*loc32, displacement, targetIsThumb);
-    write32(*loc32, _swap, value32);
+    value32 = setDisplacementInArmBranch(*loc32, displacement,
+                                         targetIsThumb);
+    *loc32 = value32;
     break;
   case arm_movw:
     assert(!thumbMode);
     if (useExternalReloc)
       value16 = ref.addend() & 0xFFFF;
     else
       value16 = (targetAddress + ref.addend()) & 0xFFFF;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movt:
     assert(!thumbMode);
     if (useExternalReloc)
       value16 = ref.addend() >> 16;
     else
       value16 = (targetAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movw_funcRel:
     assert(!thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case arm_movt_funcRel:
     assert(!thumbMode);
     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
-    write32(*loc32, _swap, setWordFromArmMov(*loc32, value16));
+    *loc32 = setWordFromArmMov(*loc32, value16);
     break;
   case pointer32:
-    write32(*loc32, _swap, targetAddress + ref.addend());
+    *loc32 = targetAddress + ref.addend();
     break;
   case delta32:
-    write32(*loc32, _swap, targetAddress - fixupAddress + ref.addend());
+    *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
   default:
     llvm_unreachable("invalid ARM Reference Kind");
     break;

lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "MachONormalizedFileBinaryUtils.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 namespace lld {
 namespace mach_o {
 
+using llvm::support::ulittle32_t;
+using llvm::support::ulittle64_t;
+
+using llvm::support::little32_t;
+using llvm::support::little64_t;
+
 class ArchHandler_arm64 : public ArchHandler {
 public:
   ArchHandler_arm64();
   virtual ~ArchHandler_arm64();
 
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override {
public:
   uint32_t dwarfCompactUnwindType() override {
     // FIXME
     return -1;
   }
 
   std::error_code getReferenceInfo(const normalized::Relocation &reloc,
                                    const DefinedAtom *inAtom,
                                    uint32_t offsetInAtom,
-                                   uint64_t fixupAddress, bool swap,
+                                   uint64_t fixupAddress, bool isBig,
                                    FindAtomBySectionAndAddress atomFromAddress,
                                    FindAtomBySymbolIndex atomFromSymbolIndex,
                                    Reference::KindValue *kind,
                                    const lld::Atom **target,
                                    Reference::Addend *addend) override;
   std::error_code
       getPairReferenceInfo(const normalized::Relocation &reloc1,
                            const normalized::Relocation &reloc2,
                            const DefinedAtom *inAtom,
                            uint32_t offsetInAtom,
-                           uint64_t fixupAddress, bool swap,
+                           uint64_t fixupAddress, bool isBig,
                            FindAtomBySectionAndAddress atomFromAddress,
                            FindAtomBySymbolIndex atomFromSymbolIndex,
                            Reference::KindValue *kind,
                            const lld::Atom **target,
                            Reference::Addend *addend) override;
 
   virtual bool needsLocalSymbolInRelocatableFile(const DefinedAtom *atom) {
     return (atom->contentType() == DefinedAtom::typeCString);
void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress, uint64_t targetAddress,
                              uint64_t inAtomAddress);
 
   // Utility functions for inspecting/updating instructions.
   static uint32_t setDisplacementInBranch26(uint32_t instr, int32_t disp);
   static uint32_t setDisplacementInADRP(uint32_t instr, int64_t disp);
   static Arm64_Kinds offset12KindFromInstruction(uint32_t instr);
   static uint32_t setImm12(uint32_t instr, uint32_t offset);
-
-  const bool _swap;
 };
 
-ArchHandler_arm64::ArchHandler_arm64()
-  : _swap(!MachOLinkingContext::isHostEndian(MachOLinkingContext::arch_arm64)) {
-}
+ArchHandler_arm64::ArchHandler_arm64() {}
 
 ArchHandler_arm64::~ArchHandler_arm64() {}
 
 const Registry::KindStrings ArchHandler_arm64::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(invalid),
   LLD_KIND_STRING_ENTRY(branch26),
   LLD_KIND_STRING_ENTRY(page21),
   LLD_KIND_STRING_ENTRY(offset12),

 uint32_t ArchHandler_arm64::setImm12(uint32_t instruction, uint32_t offset) {
   assert(((offset & 0xFFFFF000) == 0) && "imm12 offset out of range");
   uint32_t imm12 = offset << 10;
   return (instruction & 0xFFC003FF) | imm12;
 }
 
 std::error_code ArchHandler_arm64::getReferenceInfo(
     const Relocation &reloc, const DefinedAtom *inAtom, uint32_t offsetInAtom,
-    uint64_t fixupAddress, bool swap,
+    uint64_t fixupAddress, bool isBig,
     FindAtomBySectionAndAddress atomFromAddress,
     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
     const lld::Atom **target, Reference::Addend *addend) {
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   switch (relocPattern(reloc)) {
   case ARM64_RELOC_BRANCH26           | rPcRel | rExtern | rLength4:
     // ex: bl _foo
     *kind = branch26;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case ARM64_RELOC_PAGE21             | rPcRel | rExtern | rLength4:
     // ex: adrp x1, _foo@PAGE
     *kind = page21;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case ARM64_RELOC_PAGEOFF12                   | rExtern | rLength4:
     // ex: ldr x0, [x1, _foo@PAGEOFF]
-    *kind = offset12KindFromInstruction(readS32(swap, fixupContent));
+    *kind = offset12KindFromInstruction(*(little32_t *)fixupContent);
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case ARM64_RELOC_GOT_LOAD_PAGE21    | rPcRel | rExtern | rLength4:
     // ex: adrp x1, _foo@GOTPAGE
     *kind = gotPage21;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case X86_64_RELOC_UNSIGNED                   | rExtern | rLength8:
     // ex: .quad _foo + N
     *kind = pointer64;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS64(swap, fixupContent);
+    *addend = *(little64_t *)fixupContent;
     return std::error_code();
   case ARM64_RELOC_POINTER_TO_GOT              | rExtern | rLength8:
     // ex: .quad _foo@GOT
     *kind = pointer64ToGOT;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
case ((ARM64_RELOC_ADDEND                                | rLength4) << 16 |
     *addend = reloc1.symbol;
     return std::error_code();
   case ((ARM64_RELOC_SUBTRACTOR                  | rExtern | rLength8) << 16 |
          ARM64_RELOC_UNSIGNED                    | rExtern | rLength8):
     // ex: .quad _foo - .
     *kind = delta64;
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
-    *addend = readS64(swap, fixupContent) + offsetInAtom;
+    *addend = *(little64_t *)fixupContent + offsetInAtom;
     return std::error_code();
   case ((ARM64_RELOC_SUBTRACTOR                  | rExtern | rLength4) << 16 |
          ARM64_RELOC_UNSIGNED                    | rExtern | rLength4):
     // ex: .quad _foo - .
     *kind = delta32;
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent) + offsetInAtom;
+    *addend = *(little32_t *)fixupContent + offsetInAtom;
     return std::error_code();
   default:
     return make_dynamic_error_code(Twine("unsupported arm64 relocation pair"));
   }
 }
 
 void ArchHandler_arm64::generateAtomContent(
     const DefinedAtom &atom, bool relocatable, FindAddressForAtom findAddress,
if (relocatable) {
                             targetAddress, atomAddress);
     } else {
       applyFixupFinal(*ref, &atomContentBuffer[offset], fixupAddress,
                       targetAddress, atomAddress);
     }
   }
 }
 
-void ArchHandler_arm64::applyFixupFinal(const Reference &ref, uint8_t *location,
+void ArchHandler_arm64::applyFixupFinal(const Reference &ref, uint8_t *loc,
                                         uint64_t fixupAddress,
                                         uint64_t targetAddress,
                                         uint64_t inAtomAddress) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::AArch64);
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  uint64_t *loc64 = reinterpret_cast<uint64_t *>(location);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
+  ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
   int32_t displacement;
   uint32_t instruction;
   uint32_t value32;
   switch (static_cast<Arm64_Kinds>(ref.kindValue())) {
   case branch26:
     displacement = (targetAddress - fixupAddress) + ref.addend();
-    value32 = setDisplacementInBranch26(*loc32, displacement);
-    write32(*loc32, _swap, value32);
+    *loc32 = setDisplacementInBranch26(*loc32, displacement);
     return;
   case page21:
   case gotPage21:
   case tlvPage21:
     displacement =
         ((targetAddress + ref.addend()) & (-4096)) - (fixupAddress & (-4096));
-    value32 = setDisplacementInADRP(*loc32, displacement);
-    write32(*loc32, _swap, value32);
+    *loc32 = setDisplacementInADRP(*loc32, displacement);
     return;
   case offset12:
   case gotOffset12:
   case tlvOffset12:
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
-    value32 = setImm12(*loc32, displacement);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, displacement);
     return;
   case offset12scale2:
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
     assert(((displacement & 0x1) == 0) &&
            "scaled imm12 not accessing 2-byte aligneds");
-    value32 = setImm12(*loc32, displacement >> 1);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, displacement >> 1);
     return;
   case offset12scale4:
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
     assert(((displacement & 0x3) == 0) &&
            "scaled imm12 not accessing 4-byte aligned");
-    value32 = setImm12(*loc32, displacement >> 2);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, displacement >> 2);
     return;
   case offset12scale8:
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
     assert(((displacement & 0x7) == 0) &&
            "scaled imm12 not accessing 8-byte aligned");
-    value32 = setImm12(*loc32, displacement >> 3);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, displacement >> 3);
     return;
   case offset12scale16:
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
     assert(((displacement & 0xF) == 0) &&
            "scaled imm12 not accessing 16-byte aligned");
-    value32 = setImm12(*loc32, displacement >> 4);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, displacement >> 4);
     return;
   case addOffset12:
-    instruction = read32(_swap, *loc32);
+    instruction = *loc32;
     assert(((instruction & 0xFFC00000) == 0xF9400000) &&
            "GOT reloc is not an LDR instruction");
     displacement = (targetAddress + ref.addend()) & 0x00000FFF;
     value32 = 0x91000000 | (instruction & 0x000003FF);
     instruction = setImm12(value32, displacement);
-    write32(*loc32, _swap, instruction);
+    *loc32 = instruction;
     return;
   case pointer64:
   case pointer64ToGOT:
-    write64(*loc64, _swap, targetAddress + ref.addend());
+    *loc64 = targetAddress + ref.addend();
     return;
   case delta64:
-    write64(*loc64, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc64 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case delta32:
   case delta32ToGOT:
-    write32(*loc32, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc32 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     // Do nothing
     return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("invalid arm64 Reference Kind");
 }
 
 void ArchHandler_arm64::applyFixupRelocatable(const Reference &ref,
-                                              uint8_t *location,
+                                              uint8_t *loc,
                                               uint64_t fixupAddress,
                                               uint64_t targetAddress,
                                               uint64_t inAtomAddress) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::AArch64);
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  uint64_t *loc64 = reinterpret_cast<uint64_t *>(location);
-  uint32_t value32;
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
+  ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
   switch (static_cast<Arm64_Kinds>(ref.kindValue())) {
   case branch26:
-    value32 = setDisplacementInBranch26(*loc32, 0);
-    write32(*loc32, _swap, value32);
+    *loc32 = setDisplacementInBranch26(*loc32, 0);
     return;
   case page21:
   case gotPage21:
   case tlvPage21:
-    value32 = setDisplacementInADRP(*loc32, 0);
-    write32(*loc32, _swap, value32);
+    *loc32 = setDisplacementInADRP(*loc32, 0);
     return;
   case offset12:
   case offset12scale2:
   case offset12scale4:
   case offset12scale8:
   case offset12scale16:
   case gotOffset12:
   case tlvOffset12:
-    value32 = setImm12(*loc32, 0);
-    write32(*loc32, _swap, value32);
+    *loc32 = setImm12(*loc32, 0);
     return;
   case pointer64:
-    write64(*loc64, _swap, ref.addend());
+    *loc64 = ref.addend();
     return;
   case delta64:
-    write64(*loc64, _swap, ref.addend() + inAtomAddress - fixupAddress);
+    *loc64 = ref.addend() + inAtomAddress - fixupAddress;
     return;
   case delta32:
-    write32(*loc32, _swap, ref.addend() + inAtomAddress - fixupAddress);
+    *loc32 = ref.addend() + inAtomAddress - fixupAddress;
     return;
   case pointer64ToGOT:
-    write64(*loc64, _swap, 0);
+    *loc64 = 0;
     return;
   case delta32ToGOT:
-    write32(*loc32, _swap, -fixupAddress);
+    *loc32 = -fixupAddress;
     return;
   case addOffset12:
     llvm_unreachable("lazy reference kind implies GOT pass was run");
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
   case invalid:
     // Fall into llvm_unreachable().

lib/ReaderWriter/MachO/ArchHandler_x86.cpp

 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "MachONormalizedFileBinaryUtils.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 namespace lld {
 namespace mach_o {
 
+using llvm::support::ulittle16_t;
+using llvm::support::ulittle32_t;
+
+using llvm::support::little16_t;
+using llvm::support::little32_t;
+
 class ArchHandler_x86 : public ArchHandler {
 public:
            ArchHandler_x86();
   virtual ~ArchHandler_x86();
 
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override { return Reference::KindArch::x86; }
private:
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
                        uint64_t inAtomAddress);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress,
                              uint64_t targetAddress,
                              uint64_t inAtomAddress);
-
-  const bool _swap;
 };
 
 //===----------------------------------------------------------------------===//
 //  ArchHandler_x86
 //===----------------------------------------------------------------------===//
 
-ArchHandler_x86::ArchHandler_x86() :
-  _swap(!MachOLinkingContext::isHostEndian(MachOLinkingContext::arch_x86)) {}
+ArchHandler_x86::ArchHandler_x86() {}
   
 ArchHandler_x86::~ArchHandler_x86() { }
   
 const Registry::KindStrings ArchHandler_x86::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(invalid),
   LLD_KIND_STRING_ENTRY(modeCode),
   LLD_KIND_STRING_ENTRY(modeData),
   LLD_KIND_STRING_ENTRY(branch32),
ArchHandler_x86::getReferenceInfo(const Relocation &reloc,
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   switch (relocPattern(reloc)) {
   case GENERIC_RELOC_VANILLA | rPcRel | rExtern | rLength4:
     // ex: call _foo (and _foo undefined)
     *kind = branch32;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = fixupAddress + 4 + readS32(swap, fixupContent);
+    *addend = fixupAddress + 4 + *(little32_t *)fixupContent;
     break;
   case GENERIC_RELOC_VANILLA | rPcRel | rLength4:
     // ex: call _foo (and _foo defined)
     *kind = branch32;
-    targetAddress = fixupAddress + 4 + readS32(swap, fixupContent);
+    targetAddress = fixupAddress + 4 + *(little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
     break;
   case GENERIC_RELOC_VANILLA | rScattered | rPcRel | rLength4:
     // ex: call _foo+n (and _foo defined)
     *kind = branch32;
-    targetAddress = fixupAddress + 4 + readS32(swap, fixupContent);
+    targetAddress = fixupAddress + 4 + *(little32_t *)fixupContent;
     if (E ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
     *addend = targetAddress - reloc.value;
     break;
   case GENERIC_RELOC_VANILLA | rPcRel | rExtern | rLength2:
     // ex: callw _foo (and _foo undefined)
     *kind = branch16;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = fixupAddress + 2 + readS16(swap, fixupContent);
+    *addend = fixupAddress + 2 + *(little16_t *)fixupContent;
     break;
   case GENERIC_RELOC_VANILLA | rPcRel | rLength2:
     // ex: callw _foo (and _foo defined)
     *kind = branch16;
-    targetAddress = fixupAddress + 2 + readS16(swap, fixupContent);
+  targetAddress = fixupAddress + 2 + *(little16_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
     break;
   case GENERIC_RELOC_VANILLA | rScattered | rPcRel | rLength2:
     // ex: callw _foo+n (and _foo defined)
     *kind = branch16;
-    targetAddress = fixupAddress + 2 + readS16(swap, fixupContent);
+    targetAddress = fixupAddress + 2 + *(little16_t *)fixupContent;
     if (E ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
     *addend = targetAddress - reloc.value;
     break;
   case GENERIC_RELOC_VANILLA | rExtern | rLength4:
     // ex: movl _foo, %eax   (and _foo undefined)
     // ex: .long _foo        (and _foo undefined)
     perms = inAtom->permissions();
     *kind =
         ((perms & DefinedAtom::permR_X) == DefinedAtom::permR_X) ? abs32
                                                                  : pointer32;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readU32(swap, fixupContent);
+    *addend = *(ulittle32_t *)fixupContent;
     break;
   case GENERIC_RELOC_VANILLA | rLength4:
     // ex: movl _foo, %eax   (and _foo defined)
     // ex: .long _foo        (and _foo defined)
     perms = inAtom->permissions();
     *kind =
         ((perms & DefinedAtom::permR_X) == DefinedAtom::permR_X) ? abs32
                                                                  : pointer32;
-    targetAddress = readU32(swap, fixupContent);
+    targetAddress = *(ulittle32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
     break;
   case GENERIC_RELOC_VANILLA | rScattered | rLength4:
     // ex: .long _foo+n      (and _foo defined)
     perms = inAtom->permissions();
     *kind =
         ((perms & DefinedAtom::permR_X) == DefinedAtom::permR_X) ? abs32
                                                                  : pointer32;
     if (E ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
-    *addend = readU32(swap, fixupContent) - reloc.value;
+    *addend = *(ulittle32_t *)fixupContent - reloc.value;
     break;
   default:
     return make_dynamic_error_code(Twine("unsupported i386 relocation type"));
   }
   return std::error_code();
 }
 
 std::error_code
ArchHandler_x86::getPairReferenceInfo(const normalized::Relocation &reloc1,
   Reference::Addend offsetInFrom;
   switch (relocPattern(reloc1) << 16 | relocPattern(reloc2)) {
   case ((GENERIC_RELOC_SECTDIFF | rScattered | rLength4) << 16 |
          GENERIC_RELOC_PAIR | rScattered | rLength4):
   case ((GENERIC_RELOC_LOCAL_SECTDIFF | rScattered | rLength4) << 16 |
          GENERIC_RELOC_PAIR | rScattered | rLength4):
     toAddress = reloc1.value;
     fromAddress = reloc2.value;
-    value = readS32(swap, fixupContent);
+    value = *(little32_t *)fixupContent;
     ec = atomFromAddr(0, toAddress, target, &offsetInTo);
     if (ec)
       return ec;
     ec = atomFromAddr(0, fromAddress, &fromTarget, &offsetInFrom);
     if (ec)
       return ec;
     if (fromTarget != inAtom) {
       if (*target != inAtom) 
for (const Reference *ref : atom) {
     } else {
       applyFixupFinal(*ref, &atomContentBuffer[offset],
                                   fixupAddress, targetAddress,
                                   atomAddress);
     }
   }
 }
 
-void ArchHandler_x86::applyFixupFinal(const Reference &ref, uint8_t *location,
+void ArchHandler_x86::applyFixupFinal(const Reference &ref, uint8_t *loc,
                                       uint64_t fixupAddress,
                                       uint64_t targetAddress,
                                       uint64_t inAtomAddress) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::x86);
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  int16_t *loc16 = reinterpret_cast<int16_t *>(location);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
   switch (ref.kindValue()) {
   case branch32:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 4)) + ref.addend());
+    *loc32 = (targetAddress - (fixupAddress + 4)) + ref.addend();
     break;
   case branch16:
-    write16(*loc16, _swap, (targetAddress - (fixupAddress + 2)) + ref.addend());
+    *loc32 = (targetAddress - (fixupAddress + 2)) + ref.addend();
     break;
   case pointer32:
   case abs32:
-    write32(*loc32, _swap, targetAddress + ref.addend());
+    *loc32 = targetAddress + ref.addend();
     break;
   case funcRel32:
-    write32(*loc32, _swap, targetAddress - inAtomAddress + ref.addend()); 
+    *loc32 = targetAddress - inAtomAddress + ref.addend();
     break;
   case delta32:
-    write32(*loc32, _swap, targetAddress - fixupAddress + ref.addend());
+    *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case negDelta32:
-    write32(*loc32, _swap, fixupAddress - targetAddress + ref.addend());
+    *loc32 = fixupAddress - targetAddress + ref.addend();
     break;
   case modeCode:
   case modeData:
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
   default:
     llvm_unreachable("invalid x86 Reference Kind");
     break;
   }
 }
 
 void ArchHandler_x86::applyFixupRelocatable(const Reference &ref,
-                                               uint8_t *location,
+                                               uint8_t *loc,
                                                uint64_t fixupAddress,
                                                uint64_t targetAddress,
                                                uint64_t inAtomAddress) {
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  int16_t *loc16 = reinterpret_cast<int16_t *>(location);
   bool useExternalReloc = useExternalRelocationTo(*ref.target());
+  ulittle16_t *loc16 = reinterpret_cast<ulittle16_t *>(loc);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
   switch (ref.kindValue()) {
   case branch32:
     if (useExternalReloc)
-      write32(*loc32, _swap, ref.addend() - (fixupAddress + 4));
+      *loc32 = ref.addend() - (fixupAddress + 4);
     else
-      write32(*loc32, _swap, (targetAddress - (fixupAddress+4)) + ref.addend());
+      *loc32  =(targetAddress - (fixupAddress+4)) + ref.addend();
     break;
   case branch16:
     if (useExternalReloc)
-      write16(*loc16, _swap, ref.addend() - (fixupAddress + 2));
+      *loc16 = ref.addend() - (fixupAddress + 2);
     else
-      write16(*loc16, _swap, (targetAddress - (fixupAddress+2)) + ref.addend());
+      *loc16 = (targetAddress - (fixupAddress+2)) + ref.addend();
     break;
   case pointer32:
   case abs32:
-    write32(*loc32, _swap, targetAddress + ref.addend());
+    *loc32 = targetAddress + ref.addend();
     break;
   case funcRel32:
-    write32(*loc32, _swap, targetAddress - inAtomAddress + ref.addend()); // FIXME
+    *loc32 = targetAddress - inAtomAddress + ref.addend(); // FIXME
     break;
   case delta32:
-    write32(*loc32, _swap, targetAddress - fixupAddress + ref.addend());
+    *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case negDelta32:
-    write32(*loc32, _swap, fixupAddress - targetAddress + ref.addend());
+    *loc32 = fixupAddress - targetAddress + ref.addend();
     break;
   case modeCode:
   case modeData:
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
   default:

lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "MachONormalizedFileBinaryUtils.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 namespace lld {
 namespace mach_o {
 
+using llvm::support::ulittle32_t;
+using llvm::support::ulittle64_t;
+
+using llvm::support::little32_t;
+using llvm::support::little64_t;
+
 class ArchHandler_x86_64 : public ArchHandler {
 public:
            ArchHandler_x86_64();
   virtual ~ArchHandler_x86_64();
 
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override {
void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
                        uint64_t inAtomAddress, uint64_t imageBaseAddress,
                        FindAddressForAtom findSectionAddress);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress,
                              uint64_t targetAddress,
                              uint64_t inAtomAddress);
-
-  const bool _swap;
 };
 
 
-ArchHandler_x86_64::ArchHandler_x86_64() :
-  _swap(!MachOLinkingContext::isHostEndian(MachOLinkingContext::arch_x86_64)) {}
+ArchHandler_x86_64::ArchHandler_x86_64() { }
 
 ArchHandler_x86_64::~ArchHandler_x86_64() { }
 
 const Registry::KindStrings ArchHandler_x86_64::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(invalid), LLD_KIND_STRING_ENTRY(branch32),
   LLD_KIND_STRING_ENTRY(ripRel32), LLD_KIND_STRING_ENTRY(ripRel32Minus1),
   LLD_KIND_STRING_ENTRY(ripRel32Minus2), LLD_KIND_STRING_ENTRY(ripRel32Minus4),
   LLD_KIND_STRING_ENTRY(ripRel32Anon), LLD_KIND_STRING_ENTRY(ripRel32GotLoad),
if (*kind == invalid)
     return make_dynamic_error_code(Twine("unknown type"));
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   switch (*kind) {
   case branch32:
   case ripRel32:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent);
+    *addend = *(little32_t *)fixupContent;
     return std::error_code();
   case ripRel32Minus1:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent) + 1;
+    *addend = *(little32_t *)fixupContent + 1;
     return std::error_code();
   case ripRel32Minus2:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent) + 2;
+    *addend = *(little32_t *)fixupContent + 2;
     return std::error_code();
   case ripRel32Minus4:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent) + 4;
+    *addend = *(little32_t *)fixupContent + 4;
     return std::error_code();
   case ripRel32Anon:
-    targetAddress = fixupAddress + 4 + readS32(swap, fixupContent);
+    targetAddress = fixupAddress + 4 + *(little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ripRel32GotLoad:
   case ripRel32Got:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case pointer64:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
-    *addend = readS64(swap, fixupContent);
+    *addend = *(little64_t *)fixupContent;
     return std::error_code();
   case pointer64Anon:
-    targetAddress = readS64(swap, fixupContent);
+    targetAddress = *(little64_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   default:
     llvm_unreachable("bad reloc kind");
   }
 }
 
 Reference::KindValue
 ArchHandler_x86_64::kindFromRelocPair(const normalized::Relocation &reloc1,
ArchHandler_x86_64::getPairReferenceInfo(const normalized::Relocation &reloc1,
   if (E ec = atomFromSymbolIndex(reloc1.symbol, &fromTarget))
     return ec;
   if (fromTarget != inAtom)
     return make_dynamic_error_code(Twine("pointer diff not in base atom"));
   switch (*kind) {
   case delta64:
     if (E ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
-    *addend = readS64(swap, fixupContent) + offsetInAtom;
+    *addend = *(little64_t *)fixupContent + offsetInAtom;
     return std::error_code();
   case delta32:
     if (E ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
-    *addend = readS32(swap, fixupContent) + offsetInAtom;
+    *addend = *(little32_t *)fixupContent + offsetInAtom;
     return std::error_code();
   case delta64Anon:
-    targetAddress = offsetInAtom + readS64(swap, fixupContent);
+    targetAddress = offsetInAtom + *(little64_t *)fixupContent;
     return atomFromAddress(reloc2.symbol, targetAddress, target, addend);
   case delta32Anon:
-    targetAddress = offsetInAtom + readS32(swap, fixupContent);
+    targetAddress = offsetInAtom + *(little32_t *)fixupContent;
     return atomFromAddress(reloc2.symbol, targetAddress, target, addend);
   default:
     llvm_unreachable("bad reloc pair kind");
   }
 }
 
 void ArchHandler_x86_64::generateAtomContent(
     const DefinedAtom &atom, bool relocatable, FindAddressForAtom findAddress,
if (relocatable) {
       applyFixupFinal(*ref, &atomContentBuffer[offset],
                       fixupAddress, targetAddress,
                       atomAddress, imageBaseAddress, findSectionAddress);
     }
   }
 }
 
 void ArchHandler_x86_64::applyFixupFinal(
-    const Reference &ref, uint8_t *location, uint64_t fixupAddress,
+    const Reference &ref, uint8_t *loc, uint64_t fixupAddress,
     uint64_t targetAddress, uint64_t inAtomAddress, uint64_t imageBaseAddress,
     FindAddressForAtom findSectionAddress) {
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
+  ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::x86_64);
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  uint64_t *loc64 = reinterpret_cast<uint64_t *>(location);
   switch (static_cast<X86_64_Kinds>(ref.kindValue())) {
   case branch32:
   case ripRel32:
   case ripRel32Anon:
   case ripRel32Got:
   case ripRel32GotLoad:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 4)) + ref.addend());
+    *loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
     return;
   case pointer64:
   case pointer64Anon:
-    write64(*loc64, _swap, targetAddress + ref.addend());
+    *loc64 = targetAddress + ref.addend();
     return;
   case ripRel32Minus1:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 5)) + ref.addend());
+    *loc32 = targetAddress - (fixupAddress + 5) + ref.addend();
     return;
   case ripRel32Minus2:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 6)) + ref.addend());
+    *loc32 = targetAddress - (fixupAddress + 6) + ref.addend();
     return;
   case ripRel32Minus4:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 8)) + ref.addend());
+    *loc32 = targetAddress - (fixupAddress + 8) + ref.addend();
     return;
   case delta32:
   case delta32Anon:
-    write32(*loc32, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc32 = targetAddress - fixupAddress + ref.addend();
     return;
   case delta64:
   case delta64Anon:
   case unwindFDEToFunction:
-    write64(*loc64, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc64 = targetAddress - fixupAddress + ref.addend();
     return;
   case ripRel32GotLoadNowLea:
     // Change MOVQ to LEA
-    assert(location[-2] == 0x8B);
-    location[-2] = 0x8D;
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 4)) + ref.addend());
+    assert(loc[-2] == 0x8B);
+    loc[-2] = 0x8D;
+    *loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
     return;
   case negDelta32:
-    write32(*loc32, _swap, fixupAddress - targetAddress + ref.addend());
+    *loc32 = fixupAddress - targetAddress + ref.addend();
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     return;
   case imageOffset:
   case imageOffsetGot:
-    write32(*loc32, _swap, (targetAddress - imageBaseAddress) + ref.addend());
+    *loc32 = (targetAddress - imageBaseAddress) + ref.addend();
     return;
   case unwindInfoToEhFrame: {
     uint64_t val = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
     assert(val < 0xffffffU && "offset in __eh_frame too large");
-    uint32_t encoding = read32(_swap, *loc32) & 0xff000000U;
-    write32(*loc32, _swap, encoding | val);
+    *loc32 = (*loc32 & 0xff000000U) | val;
     return;
   }
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("invalid x86_64 Reference Kind");
 }
 
 
 void ArchHandler_x86_64::applyFixupRelocatable(const Reference &ref,
-                                               uint8_t *location,
+                                               uint8_t *loc,
                                                uint64_t fixupAddress,
                                                uint64_t targetAddress,
                                                uint64_t inAtomAddress)  {
-  int32_t *loc32 = reinterpret_cast<int32_t *>(location);
-  uint64_t *loc64 = reinterpret_cast<uint64_t *>(location);
+  ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
+  ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
   switch (static_cast<X86_64_Kinds>(ref.kindValue())) {
   case branch32:
   case ripRel32:
   case ripRel32Got:
   case ripRel32GotLoad:
-    write32(*loc32, _swap, ref.addend());
+    *loc32 = ref.addend();
     return;
   case ripRel32Anon:
-    write32(*loc32, _swap, (targetAddress - (fixupAddress + 4)) + ref.addend());
+    *loc32 = (targetAddress - (fixupAddress + 4)) + ref.addend();
     return;
   case pointer64:
-    write64(*loc64, _swap, ref.addend());
+    *loc64 = ref.addend();
     return;
   case pointer64Anon:
-    write64(*loc64, _swap, targetAddress + ref.addend());
+    *loc64 = targetAddress + ref.addend();
     return;
   case ripRel32Minus1:
-    write32(*loc32, _swap, ref.addend() - 1);
+    *loc32 = ref.addend() - 1;
     return;
   case ripRel32Minus2:
-    write32(*loc32, _swap, ref.addend() - 2);
+    *loc32 = ref.addend() - 2;
     return;
   case ripRel32Minus4:
-    write32(*loc32, _swap, ref.addend() - 4);
+    *loc32 = ref.addend() - 4;
     return;
   case delta32:
-    write32(*loc32, _swap, ref.addend() + inAtomAddress - fixupAddress);
+    *loc32 = ref.addend() + inAtomAddress - fixupAddress;
     return;
   case delta32Anon:
-    write32(*loc32, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc32 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case delta64:
-    write64(*loc64, _swap, ref.addend() + inAtomAddress - fixupAddress);
+    *loc64 = ref.addend() + inAtomAddress - fixupAddress;
     return;
   case delta64Anon:
-    write64(*loc64, _swap, (targetAddress - fixupAddress) + ref.addend());
+    *loc64 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case negDelta32:
-    write32(*loc32, _swap, fixupAddress - targetAddress + ref.addend());
+    *loc32 = fixupAddress - targetAddress + ref.addend();
     return;
   case ripRel32GotLoadNowLea:
     llvm_unreachable("ripRel32GotLoadNowLea implies GOT pass was run");
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
     return;

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

 
 struct UnwindInfoPage {
   std::vector<CompactUnwindEntry> entries;
 };
 }
 
 class UnwindInfoAtom : public SimpleDefinedAtom {
 public:
-  UnwindInfoAtom(ArchHandler &archHandler, const File &file, bool swap,
+  UnwindInfoAtom(ArchHandler &archHandler, const File &file, bool isBig,
                  std::vector<uint32_t> commonEncodings,
                  std::vector<const Atom *> personalities,
                  std::vector<UnwindInfoPage> pages, uint32_t numLSDAs)
       : SimpleDefinedAtom(file), _archHandler(archHandler),
         _commonEncodingsOffset(7 * sizeof(uint32_t)),
         _personalityArrayOffset(_commonEncodingsOffset +
                                 commonEncodings.size() * sizeof(uint32_t)),
         _topLevelIndexOffset(_personalityArrayOffset +
                              personalities.size() * sizeof(uint32_t)),
         _lsdaIndexOffset(_topLevelIndexOffset +
                          3 * (pages.size() + 1) * sizeof(uint32_t)),
         _firstPageOffset(_lsdaIndexOffset + 2 * numLSDAs * sizeof(uint32_t)),
-        _swap(swap) {
+        _isBig(isBig) {
 
     addHeader(commonEncodings.size(), personalities.size(), pages.size());
     addCommonEncodings(commonEncodings);
     addPersonalityFunctions(personalities);
     addTopLevelIndexes(pages);
     addLSDAIndexes(pages, numLSDAs);
     addSecondLevelPages(pages);
   }
public:
 
   void addHeader(uint32_t numCommon, uint32_t numPersonalities,
                  uint32_t numPages) {
     using normalized::write32;
 
     uint32_t headerSize = 7 * sizeof(uint32_t);
     _contents.resize(headerSize);
 
-    int32_t *headerEntries = (int32_t *)_contents.data();
+    uint8_t *headerEntries = _contents.data();
     // version
-    write32(headerEntries[0], _swap, 1);
+    write32(headerEntries, 1, _isBig);
     // commonEncodingsArraySectionOffset
-    write32(headerEntries[1], _swap, _commonEncodingsOffset);
+    write32(headerEntries + sizeof(uint32_t), _commonEncodingsOffset, _isBig);
     // commonEncodingsArrayCount
-    write32(headerEntries[2], _swap, numCommon);
+    write32(headerEntries + 2 * sizeof(uint32_t), numCommon, _isBig);
     // personalityArraySectionOffset
-    write32(headerEntries[3], _swap, _personalityArrayOffset);
+    write32(headerEntries + 3 * sizeof(uint32_t), _personalityArrayOffset,
+            _isBig);
     // personalityArrayCount
-    write32(headerEntries[4], _swap, numPersonalities);
+    write32(headerEntries + 4 * sizeof(uint32_t), numPersonalities, _isBig);
     // indexSectionOffset
-    write32(headerEntries[5], _swap, _topLevelIndexOffset);
+    write32(headerEntries + 5 * sizeof(uint32_t), _topLevelIndexOffset, _isBig);
     // indexCount
-    write32(headerEntries[6], _swap, numPages + 1);
+    write32(headerEntries + 6 * sizeof(uint32_t), numPages + 1, _isBig);
   }
 
   /// Add the list of common encodings to the section; this is simply an array
   /// of uint32_t compact values. Size has already been specified in the header.
   void addCommonEncodings(std::vector<uint32_t> &commonEncodings) {
     using normalized::write32;
 
     _contents.resize(_commonEncodingsOffset +
                      commonEncodings.size() * sizeof(uint32_t));
-    int32_t *commonEncodingsArea =
-        (int32_t *)&_contents[_commonEncodingsOffset];
+    uint8_t *commonEncodingsArea = &_contents[_commonEncodingsOffset];
 
-    for (uint32_t encoding : commonEncodings)
-      write32(*commonEncodingsArea++, _swap, encoding);
+    for (uint32_t encoding : commonEncodings) {
+      write32(commonEncodingsArea, encoding, _isBig);
+      commonEncodingsArea += sizeof(uint32_t);
+    }
   }
 
   void addPersonalityFunctions(std::vector<const Atom *> personalities) {
     _contents.resize(_personalityArrayOffset +
                      personalities.size() * sizeof(uint32_t));
 
     for (unsigned i = 0; i < personalities.size(); ++i)
       addImageReferenceIndirect(_personalityArrayOffset + i * sizeof(uint32_t),
                                 personalities[i]);
   }
 
   void addTopLevelIndexes(std::vector<UnwindInfoPage> &pages) {
     using normalized::write32;
 
     uint32_t numIndexes = pages.size() + 1;
     _contents.resize(_topLevelIndexOffset + numIndexes * 3 * sizeof(uint32_t));
 
     uint32_t pageLoc = _firstPageOffset;
 
     // The most difficult job here is calculating the LSDAs; everything else
     // follows fairly naturally, but we can't state where the first
-    int32_t *indexData = (int32_t *)&_contents[_topLevelIndexOffset];
+    uint8_t *indexData = &_contents[_topLevelIndexOffset];
     uint32_t numLSDAs = 0;
     for (unsigned i = 0; i < pages.size(); ++i) {
       // functionOffset
       addImageReference(_topLevelIndexOffset + 3 * i * sizeof(uint32_t),
                         pages[i].entries[0].rangeStart);
       // secondLevelPagesSectionOffset
-      write32(indexData[3 * i + 1], _swap, pageLoc);
-      write32(indexData[3 * i + 2], _swap,
-              _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t));
+      write32(indexData + (3 * i + 1) * sizeof(uint32_t), pageLoc, _isBig);
+      write32(indexData + (3 * i + 2) * sizeof(uint32_t),
+              _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t), _isBig);
 
       for (auto &entry : pages[i].entries)
         if (entry.lsdaLocation)
           ++numLSDAs;
     }
 
     // Finally, write out the final sentinel index
     CompactUnwindEntry &finalEntry = pages[pages.size() - 1].entries.back();
     addImageReference(_topLevelIndexOffset +
                           3 * pages.size() * sizeof(uint32_t),
                       finalEntry.rangeStart, finalEntry.rangeLength);
     // secondLevelPagesSectionOffset => 0
-    indexData[3 * pages.size() + 2] =
-        _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t);
+    write32(indexData + (3 * pages.size() + 2) * sizeof(uint32_t),
+            _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t), _isBig);
   }
 
   void addLSDAIndexes(std::vector<UnwindInfoPage> &pages, uint32_t numLSDAs) {
     _contents.resize(_lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t));
 
     uint32_t curOffset = _lsdaIndexOffset;
     for (auto &page : pages) {
       for (auto &entry : page.entries) {
void addRegularSecondLevelPage(const UnwindInfoPage &page) {
     const int16_t headerSize = sizeof(uint32_t) + 2 * sizeof(uint16_t);
     uint32_t curPageSize =
         headerSize + 2 * page.entries.size() * sizeof(uint32_t);
     _contents.resize(curPageOffset + curPageSize);
 
     using normalized::write32;
     using normalized::write16;
     // 2 => regular page
-    write32(*(int32_t *)&_contents[curPageOffset], _swap, 2);
+    write32(&_contents[curPageOffset], 2, _isBig);
     // offset of 1st entry
-    write16(*(int16_t *)&_contents[curPageOffset + 4], _swap, headerSize);
-    write16(*(int16_t *)&_contents[curPageOffset + 6], _swap,
-            page.entries.size());
+    write16(&_contents[curPageOffset + 4], headerSize, _isBig);
+    write16(&_contents[curPageOffset + 6], page.entries.size(), _isBig);
 
     uint32_t pagePos = curPageOffset + headerSize;
     for (auto &entry : page.entries) {
       addImageReference(pagePos, entry.rangeStart);
 
-      write32(reinterpret_cast<int32_t *>(_contents.data() + pagePos)[1], _swap,
-              entry.encoding);
+      write32(_contents.data() + pagePos + sizeof(uint32_t), entry.encoding,
+              _isBig);
       if ((entry.encoding & 0x0f000000U) ==
           _archHandler.dwarfCompactUnwindType())
         addEhFrameReference(pagePos + sizeof(uint32_t), entry.ehFrame);
 
       pagePos += 2 * sizeof(uint32_t);
     }
   }
 

 private:
   mach_o::ArchHandler &_archHandler;
   std::vector<uint8_t> _contents;
   uint32_t _commonEncodingsOffset;
   uint32_t _personalityArrayOffset;
   uint32_t _topLevelIndexOffset;
   uint32_t _lsdaIndexOffset;
   uint32_t _firstPageOffset;
-  bool _swap;
+  bool _isBig;
 };
 
 /// Pass for instantiating and optimizing GOT slots.
 ///
 class CompactUnwindPass : public Pass {
 public:
   CompactUnwindPass(const MachOLinkingContext &context)
       : _context(context), _archHandler(_context.archHandler()),
         _file("<mach-o Compact Unwind Pass>"),
-        _swap(!MachOLinkingContext::isHostEndian(_context.arch())) {}
+        _isBig(MachOLinkingContext::isBigEndian(_context.arch())) {}
 
 private:
   void perform(std::unique_ptr<MutableFile> &mergedFile) override {
     DEBUG(llvm::dbgs() << "MachO Compact Unwind pass\n");
 
     std::map<const Atom *, CompactUnwindEntry> unwindLocs;
     std::map<const Atom *, const Atom *> dwarfFrames;
     std::vector<const Atom *> personalities;
do {
             << "    Page from " << pages.back().entries[0].rangeStart->name()
             << " to " << pages.back().entries.back().rangeStart->name() << " + "
             << llvm::format("0x%x", pages.back().entries.back().rangeLength)
             << " has " << entriesInPage << " entries\n");
     } while (pageStart < unwindInfos.size());
 
     // FIXME: we should also erase all compact-unwind atoms; their job is done.
     UnwindInfoAtom *unwind = new (_file.allocator())
-        UnwindInfoAtom(_archHandler, _file, _swap, std::vector<uint32_t>(),
+        UnwindInfoAtom(_archHandler, _file, _isBig, std::vector<uint32_t>(),
                        personalities, pages, numLSDAs);
     mergedFile->addAtom(*unwind);
   }
 
   void collectCompactUnwindEntries(
       std::unique_ptr<MutableFile> &mergedFile,
       std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       std::vector<const Atom *> &personalities, uint32_t &numLSDAs) {
for (const Reference *ref : *atom) {
         assert(ref->addend() == 0 && "unexpected offset into LSDA atom");
         entry.lsdaLocation = ref->target();
         break;
       }
     }
 
     using normalized::read32;
     entry.rangeLength =
-        read32(_swap, ((uint32_t *)atom->rawContent().data())[2]);
-    entry.encoding = read32(_swap, ((uint32_t *)atom->rawContent().data())[3]);
+        read32(atom->rawContent().data() + 2 * sizeof(uint32_t), _isBig);
+    entry.encoding =
+        read32(atom->rawContent().data() + 3 * sizeof(uint32_t), _isBig);
     return entry;
   }
 
   void
   collectDwarfFrameEntries(std::unique_ptr<MutableFile> &mergedFile,
                            std::map<const Atom *, const Atom *> &dwarfFrames) {
     for (const DefinedAtom *ehFrameAtom : mergedFile->defined()) {
       if (ehFrameAtom->contentType() != DefinedAtom::typeCFI)
         continue;
-      if (ArchHandler::isDwarfCIE(_swap, ehFrameAtom))
+      if (ArchHandler::isDwarfCIE(_isBig, ehFrameAtom))
         continue;
 
       if (const Atom *function = _archHandler.fdeTargetFunction(ehFrameAtom))
         dwarfFrames[function] = ehFrameAtom;
     }
   }
 
   /// Every atom defined in __TEXT,__text needs an entry in the final
if (entry.lsdaLocation)
       entry.encoding |= 1U << 30;
 
     return entry;
   }
 
   const MachOLinkingContext &_context;
   mach_o::ArchHandler &_archHandler;
   MachOFile _file;
-  bool _swap;
+  bool _isBig;
 };
 
 void addCompactUnwindPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsCompactUnwindPass());
   pm.add(std::unique_ptr<Pass>(new CompactUnwindPass(ctx)));
 }
 
 } // end namesapce mach_o
 } // end namesapce lld

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

 using llvm::object::MachOObjectFile;
 
 namespace lld {
 namespace mach_o {
 namespace normalized {
 
 // Utility to call a lambda expression on each load command.
 static std::error_code forEachLoadCommand(
-    StringRef lcRange, unsigned lcCount, bool swap, bool is64,
+    StringRef lcRange, unsigned lcCount, bool isBig, bool is64,
     std::function<bool(uint32_t cmd, uint32_t size, const char *lc)> func) {
   const char* p = lcRange.begin();
   for (unsigned i=0; i < lcCount; ++i) {
     const load_command *lc = reinterpret_cast<const load_command*>(p);
     load_command lcCopy;
     const load_command *slc = lc;
-    if (swap) {
+    if (isBig != llvm::sys::IsBigEndianHost) {
       memcpy(&lcCopy, lc, sizeof(load_command));
       swapStruct(lcCopy);
       slc = &lcCopy;
     }
     if ( (p + slc->cmdsize) > lcRange.end() )
       return make_error_code(llvm::errc::executable_format_error);
 
     if (func(slc->cmd, slc->cmdsize, p))
       return std::error_code();
 
     p += slc->cmdsize;
   }
 
   return std::error_code();
 }
 
 static std::error_code appendRelocations(Relocations &relocs, StringRef buffer,
-                                         bool swap, bool bigEndian,
+                                         bool bigEndian,
                                          uint32_t reloff, uint32_t nreloc) {
   if ((reloff + nreloc*8) > buffer.size())
     return make_error_code(llvm::errc::executable_format_error);
   const any_relocation_info* relocsArray =
             reinterpret_cast<const any_relocation_info*>(buffer.begin()+reloff);
 
   for(uint32_t i=0; i < nreloc; ++i) {
-    relocs.push_back(unpackRelocation(relocsArray[i], swap, bigEndian));
+    relocs.push_back(unpackRelocation(relocsArray[i], bigEndian));
   }
   return std::error_code();
 }
 
 static std::error_code
-appendIndirectSymbols(IndirectSymbols &isyms, StringRef buffer, bool swap,
-                      bool bigEndian, uint32_t istOffset, uint32_t istCount,
+appendIndirectSymbols(IndirectSymbols &isyms, StringRef buffer, bool isBig,
+                      uint32_t istOffset, uint32_t istCount,
                       uint32_t startIndex, uint32_t count) {
   if ((istOffset + istCount*4) > buffer.size())
     return make_error_code(llvm::errc::executable_format_error);
   if (startIndex+count  > istCount)
     return make_error_code(llvm::errc::executable_format_error);
-  const uint32_t *indirectSymbolArray =
-            reinterpret_cast<const uint32_t*>(buffer.begin()+istOffset);
+  const uint8_t *indirectSymbolArray = (const uint8_t *)buffer.data();
 
   for(uint32_t i=0; i < count; ++i) {
-    isyms.push_back(read32(swap, indirectSymbolArray[startIndex+i]));
+    isyms.push_back(read32(
+        indirectSymbolArray + (startIndex + i) * sizeof(uint32_t), isBig));
   }
   return std::error_code();
 }
 
 
 template <typename T> static T readBigEndian(T t) {
   if (llvm::sys::IsLittleEndianHost)
     llvm::sys::swapByteOrder(t);
   return t;
 }
 
 
-static bool isMachOHeader(const mach_header *mh, bool &is64, bool &swap) {
-  switch (mh->magic) {
+static bool isMachOHeader(const mach_header *mh, bool &is64, bool &isBig) {
+  switch (read32(&mh->magic, false)) {
   case llvm::MachO::MH_MAGIC:
     is64 = false;
-    swap = false;
+    isBig = false;
     return true;
   case llvm::MachO::MH_MAGIC_64:
     is64 = true;
-    swap = false;
+    isBig = false;
     return true;
   case llvm::MachO::MH_CIGAM:
     is64 = false;
-    swap = true;
+    isBig = true;
     return true;
   case llvm::MachO::MH_CIGAM_64:
     is64 = true;
-    swap = true;
+    isBig = true;
     return true;
   default:
     return false;
   }
 }
 
 
 bool isThinObjectFile(StringRef path, MachOLinkingContext::Arch &arch) {
   // Try opening and mapping file at path.
   ErrorOr<std::unique_ptr<MemoryBuffer>> b = MemoryBuffer::getFileOrSTDIN(path);
   if (b.getError())
     return false;
 
   // If file length < 32 it is too small to be mach-o object file.
   StringRef fileBuffer = b->get()->getBuffer();
   if (fileBuffer.size() < 32)
     return false;
 
   // If file buffer does not start with MH_MAGIC (and variants), not obj file.
   const mach_header *mh = reinterpret_cast<const mach_header *>(
                                                             fileBuffer.begin());
-  bool is64, swap;
-  if (!isMachOHeader(mh, is64, swap))
+  bool is64, isBig;
+  if (!isMachOHeader(mh, is64, isBig))
     return false;
 
   // If not MH_OBJECT, not object file.
-  if (read32(swap, mh->filetype) != MH_OBJECT)
+  if (read32(&mh->filetype, isBig) != MH_OBJECT)
     return false;
 
   // Lookup up arch from cpu/subtype pair.
-  arch = MachOLinkingContext::archFromCpuType(read32(swap, mh->cputype),
-                                              read32(swap, mh->cpusubtype));
+  arch = MachOLinkingContext::archFromCpuType(
+      read32(&mh->cputype, isBig),
+      read32(&mh->cpusubtype, isBig));
   return true;
 }
 
 
 bool sliceFromFatFile(const MemoryBuffer &mb, MachOLinkingContext::Arch arch,
                                              uint32_t &offset, uint32_t &size) {
   const char *start = mb.getBufferStart();
   const llvm::MachO::fat_header *fh =
readBinary(std::unique_ptr<MemoryBuffer> &mb,
   uint32_t sliceSize;
   if (sliceFromFatFile(*mb, arch, sliceOffset, sliceSize)) {
     start = &start[sliceOffset];
     objSize = sliceSize;
     mh = reinterpret_cast<const mach_header *>(start);
   }
 
   // Determine endianness and pointer size for mach-o file.
-  bool is64, swap;
-  if (!isMachOHeader(mh, is64, swap))
+  bool is64, isBig;
+  if (!isMachOHeader(mh, is64, isBig))
     return make_error_code(llvm::errc::executable_format_error);
 
   // Endian swap header, if needed.
   mach_header headerCopy;
   const mach_header *smh = mh;
-  if (swap) {
+  if (isBig != llvm::sys::IsBigEndianHost) {
     memcpy(&headerCopy, mh, sizeof(mach_header));
     swapStruct(headerCopy);
     smh = &headerCopy;
   }
 
   // Validate head and load commands fit in buffer.
   const uint32_t lcCount = smh->ncmds;
   const char *lcStart =
       start + (is64 ? sizeof(mach_header_64) : sizeof(mach_header));
   StringRef lcRange(lcStart, smh->sizeofcmds);
   if (lcRange.end() > (start + objSize))
     return make_error_code(llvm::errc::executable_format_error);
 
   // Get architecture from mach_header.
   f->arch = MachOLinkingContext::archFromCpuType(smh->cputype, smh->cpusubtype);
   if (f->arch != arch) {
     return make_dynamic_error_code(Twine("file is wrong architecture. Expected "
                                   "(" + MachOLinkingContext::nameFromArch(arch)
                                   + ") found ("
                                   + MachOLinkingContext::nameFromArch(f->arch)
                                   + ")" ));
   }
-  bool isBigEndianArch = MachOLinkingContext::isBigEndian(f->arch);
   // Copy file type and flags
   f->fileType = HeaderFileType(smh->filetype);
   f->flags = smh->flags;
 
 
   // Pre-scan load commands looking for indirect symbol table.
   uint32_t indirectSymbolTableOffset = 0;
   uint32_t indirectSymbolTableCount = 0;
-  std::error_code ec = forEachLoadCommand(lcRange, lcCount, swap, is64,
+  std::error_code ec = forEachLoadCommand(lcRange, lcCount, isBig, is64,
                                           [&](uint32_t cmd, uint32_t size,
                                               const char *lc) -> bool {
     if (cmd == LC_DYSYMTAB) {
       const dysymtab_command *d = reinterpret_cast<const dysymtab_command*>(lc);
-      indirectSymbolTableOffset = read32(swap, d->indirectsymoff);
-      indirectSymbolTableCount = read32(swap, d->nindirectsyms);
+      indirectSymbolTableOffset = read32(&d->indirectsymoff, isBig);
+      indirectSymbolTableCount = read32(&d->nindirectsyms, isBig);
       return true;
     }
     return false;
   });
   if (ec)
     return ec;
 
   // Walk load commands looking for segments/sections and the symbol table.
   const data_in_code_entry *dataInCode = nullptr;
   const dyld_info_command *dyldInfo = nullptr;
   uint32_t dataInCodeSize = 0;
-  ec = forEachLoadCommand(lcRange, lcCount, swap, is64,
+  ec = forEachLoadCommand(lcRange, lcCount, isBig, is64,
                     [&] (uint32_t cmd, uint32_t size, const char* lc) -> bool {
     switch(cmd) {
     case LC_SEGMENT_64:
       if (is64) {
         const segment_command_64 *seg =
                               reinterpret_cast<const segment_command_64*>(lc);
-        const unsigned sectionCount = (swap
-                                       ? llvm::sys::getSwappedBytes(seg->nsects)
-                                       : seg->nsects);
+        const unsigned sectionCount = read32(&seg->nsects, isBig);
         const section_64 *sects = reinterpret_cast<const section_64*>
                                   (lc + sizeof(segment_command_64));
         const unsigned lcSize = sizeof(segment_command_64)
                                               + sectionCount*sizeof(section_64);
         // Verify sections don't extend beyond end of segment load command.
         if (lcSize > size)
           return true;
         for (unsigned i=0; i < sectionCount; ++i) {
           const section_64 *sect = &sects[i];
           Section section;
           section.segmentName = getString16(sect->segname);
           section.sectionName = getString16(sect->sectname);
-          section.type        = (SectionType)(read32(swap, sect->flags)
-                                                                & SECTION_TYPE);
-          section.attributes  = read32(swap, sect->flags) & SECTION_ATTRIBUTES;
-          section.alignment   = read32(swap, sect->align);
-          section.address     = read64(swap, sect->addr);
+          section.type = (SectionType)(read32(&sect->flags, isBig) &
+                                       SECTION_TYPE);
+          section.attributes  = read32(&sect->flags, isBig) & SECTION_ATTRIBUTES;
+          section.alignment   = read32(&sect->align, isBig);
+          section.address     = read64(&sect->addr, isBig);
           const uint8_t *content =
-              (uint8_t *)start + read32(swap, sect->offset);
-          size_t contentSize = read64(swap, sect->size);
+            (uint8_t *)start + read32(&sect->offset, isBig);
+          size_t contentSize = read64(&sect->size, isBig);
           // Note: this assign() is copying the content bytes.  Ideally,
           // we can use a custom allocator for vector to avoid the copy.
           section.content = llvm::makeArrayRef(content, contentSize);
-          appendRelocations(section.relocations, mb->getBuffer(),
-                            swap, isBigEndianArch, read32(swap, sect->reloff),
-                                                   read32(swap, sect->nreloc));
+          appendRelocations(section.relocations, mb->getBuffer(), isBig,
+                            read32(&sect->reloff, isBig),
+                            read32(&sect->nreloc, isBig));
           if (section.type == S_NON_LAZY_SYMBOL_POINTERS) {
             appendIndirectSymbols(section.indirectSymbols, mb->getBuffer(),
-                                  swap, isBigEndianArch,
+                                  isBig,
                                   indirectSymbolTableOffset,
                                   indirectSymbolTableCount,
-                                  read32(swap, sect->reserved1), contentSize/4);
+                                  read32(&sect->reserved1, isBig),
+                                  contentSize/4);
           }
           f->sections.push_back(section);
         }
       }
       break;
     case LC_SEGMENT:
       if (!is64) {
         const segment_command *seg =
                               reinterpret_cast<const segment_command*>(lc);
-        const unsigned sectionCount = (swap
-                                       ? llvm::sys::getSwappedBytes(seg->nsects)
-                                       : seg->nsects);
+        const unsigned sectionCount = read32(&seg->nsects, isBig);
         const section *sects = reinterpret_cast<const section*>
                                   (lc + sizeof(segment_command));
         const unsigned lcSize = sizeof(segment_command)
                                               + sectionCount*sizeof(section);
         // Verify sections don't extend beyond end of segment load command.
         if (lcSize > size)
           return true;
         for (unsigned i=0; i < sectionCount; ++i) {
           const section *sect = &sects[i];
           Section section;
           section.segmentName = getString16(sect->segname);
           section.sectionName = getString16(sect->sectname);
-          section.type        = (SectionType)(read32(swap, sect->flags)
-                                                                & SECTION_TYPE);
-          section.attributes  = read32(swap, sect->flags) & SECTION_ATTRIBUTES;
-          section.alignment   = read32(swap, sect->align);
-          section.address     = read32(swap, sect->addr);
+          section.type = (SectionType)(read32(&sect->flags, isBig) &
+                                       SECTION_TYPE);
+          section.attributes =
+              read32((uint8_t *)&sect->flags, isBig) & SECTION_ATTRIBUTES;
+          section.alignment   = read32(&sect->align, isBig);
+          section.address     = read32(&sect->addr, isBig);
           const uint8_t *content =
-              (uint8_t *)start + read32(swap, sect->offset);
-          size_t contentSize = read32(swap, sect->size);
+            (uint8_t *)start + read32(&sect->offset, isBig);
+          size_t contentSize = read32(&sect->size, isBig);
           // Note: this assign() is copying the content bytes.  Ideally,
           // we can use a custom allocator for vector to avoid the copy.
           section.content = llvm::makeArrayRef(content, contentSize);
-          appendRelocations(section.relocations, mb->getBuffer(),
-                            swap, isBigEndianArch, read32(swap, sect->reloff),
-                                                   read32(swap, sect->nreloc));
+          appendRelocations(section.relocations, mb->getBuffer(), isBig,
+                            read32(&sect->reloff, isBig),
+                            read32(&sect->nreloc, isBig));
           if (section.type == S_NON_LAZY_SYMBOL_POINTERS) {
-            appendIndirectSymbols(section.indirectSymbols, mb->getBuffer(),
-                                  swap, isBigEndianArch,
-                                  indirectSymbolTableOffset,
-                                  indirectSymbolTableCount,
-                                  read32(swap, sect->reserved1), contentSize/4);
+            appendIndirectSymbols(
+                section.indirectSymbols, mb->getBuffer(), isBig,
+                indirectSymbolTableOffset, indirectSymbolTableCount,
+                read32(&sect->reserved1, isBig), contentSize / 4);
           }
           f->sections.push_back(section);
         }
       }
       break;
     case LC_SYMTAB: {
       const symtab_command *st = reinterpret_cast<const symtab_command*>(lc);
-      const char *strings = start + read32(swap, st->stroff);
-      const uint32_t strSize = read32(swap, st->strsize);
+      const char *strings = start + read32(&st->stroff, isBig);
+      const uint32_t strSize = read32(&st->strsize, isBig);
       // Validate string pool and symbol table all in buffer.
-      if ( read32(swap, st->stroff)+read32(swap, st->strsize)
-                                                        > objSize )
+      if (read32((uint8_t *)&st->stroff, isBig) +
+              read32((uint8_t *)&st->strsize, isBig) >
+          objSize)
         return true;
       if (is64) {
-        const uint32_t symOffset = read32(swap, st->symoff);
-        const uint32_t symCount = read32(swap, st->nsyms);
+        const uint32_t symOffset = read32(&st->symoff, isBig);
+        const uint32_t symCount = read32(&st->nsyms, isBig);
         if ( symOffset+(symCount*sizeof(nlist_64)) > objSize)
           return true;
         const nlist_64 *symbols =
             reinterpret_cast<const nlist_64 *>(start + symOffset);
         // Convert each nlist_64 to a lld::mach_o::normalized::Symbol.
         for(uint32_t i=0; i < symCount; ++i) {
           const nlist_64 *sin = &symbols[i];
           nlist_64 tempSym;
-          if (swap) {
+          if (isBig != llvm::sys::IsBigEndianHost) {
             tempSym = *sin; swapStruct(tempSym); sin = &tempSym;
           }
           Symbol sout;
           if (sin->n_strx > strSize)
             return true;
           sout.name  = &strings[sin->n_strx];
           sout.type  = (NListType)(sin->n_type & N_TYPE);
           sout.scope = (sin->n_type & (N_PEXT|N_EXT));
           sout.sect  = sin->n_sect;
           sout.desc  = sin->n_desc;
           sout.value = sin->n_value;
           if (sout.type == N_UNDF)
             f->undefinedSymbols.push_back(sout);
           else if (sin->n_type & N_EXT)
             f->globalSymbols.push_back(sout);
           else
             f->localSymbols.push_back(sout);
         }
       } else {
-        const uint32_t symOffset = read32(swap, st->symoff);
-        const uint32_t symCount = read32(swap, st->nsyms);
+        const uint32_t symOffset = read32(&st->symoff, isBig);
+        const uint32_t symCount = read32(&st->nsyms, isBig);
         if ( symOffset+(symCount*sizeof(nlist)) > objSize)
           return true;
         const nlist *symbols =
             reinterpret_cast<const nlist *>(start + symOffset);
         // Convert each nlist to a lld::mach_o::normalized::Symbol.
         for(uint32_t i=0; i < symCount; ++i) {
           const nlist *sin = &symbols[i];
           nlist tempSym;
-          if (swap) {
+          if (isBig != llvm::sys::IsBigEndianHost) {
             tempSym = *sin; swapStruct(tempSym); sin = &tempSym;
           }
           Symbol sout;
           if (sin->n_strx > strSize)
             return true;
           sout.name  = &strings[sin->n_strx];
           sout.type  = (NListType)(sin->n_type & N_TYPE);
           sout.scope = (sin->n_type & (N_PEXT|N_EXT));
           sout.sect  = sin->n_sect;
           sout.desc  = sin->n_desc;
           sout.value = sin->n_value;
           if (sout.type == N_UNDF)
             f->undefinedSymbols.push_back(sout);
           else if (sout.scope == (SymbolScope)N_EXT)
             f->globalSymbols.push_back(sout);
           else
             f->localSymbols.push_back(sout);
         }
       }
       }
       break;
     case LC_ID_DYLIB: {
       const dylib_command *dl = reinterpret_cast<const dylib_command*>(lc);
-      f->installName = lc + read32(swap, dl->dylib.name);
+      f->installName = lc + read32(&dl->dylib.name, isBig);
       }
       break;
     case LC_DATA_IN_CODE: {
       const linkedit_data_command *ldc =
                             reinterpret_cast<const linkedit_data_command*>(lc);
-      dataInCode = reinterpret_cast<const data_in_code_entry*>(
-                                            start + read32(swap, ldc->dataoff));
-      dataInCodeSize = read32(swap, ldc->datasize);
+      dataInCode = reinterpret_cast<const data_in_code_entry *>(
+          start + read32(&ldc->dataoff, isBig));
+      dataInCodeSize = read32(&ldc->datasize, isBig);
       }
       break;
     case LC_LOAD_DYLIB:
     case LC_LOAD_WEAK_DYLIB:
     case LC_REEXPORT_DYLIB:
     case LC_LOAD_UPWARD_DYLIB: {
       const dylib_command *dl = reinterpret_cast<const dylib_command*>(lc);
       DependentDylib entry;
-      entry.path = lc + read32(swap, dl->dylib.name);
+      entry.path = lc + read32(&dl->dylib.name, isBig);
       entry.kind = LoadCommandType(cmd);
       f->dependentDylibs.push_back(entry);
       }
       break;
     case LC_DYLD_INFO:
     case LC_DYLD_INFO_ONLY:
       dyldInfo = reinterpret_cast<const dyld_info_command*>(lc);
       break;
     }
     return false;
   });
   if (ec)
     return ec;
 
   if (dataInCode) {
     // Convert on-disk data_in_code_entry array to DataInCode vector.
     for (unsigned i=0; i < dataInCodeSize/sizeof(data_in_code_entry); ++i) {
       DataInCode entry;
-      entry.offset = read32(swap, dataInCode[i].offset);
-      entry.length = read16(swap, dataInCode[i].length);
-      entry.kind   = (DataRegionType)read16(swap, dataInCode[i].kind);
+      entry.offset = read32(&dataInCode[i].offset, isBig);
+      entry.length = read16(&dataInCode[i].length, isBig);
+      entry.kind =
+          (DataRegionType)read16((uint8_t *)&dataInCode[i].kind, isBig);
       f->dataInCode.push_back(entry);
     }
   }
 
   if (dyldInfo) {
     // If any exports, extract and add to normalized exportInfo vector.
     if (dyldInfo->export_size) {
       const uint8_t *trieStart = reinterpret_cast<const uint8_t*>(start +

lib/ReaderWriter/MachO/MachONormalizedFileBinaryUtils.h

 //===- lib/ReaderWriter/MachO/MachONormalizedFileBinaryUtils.h ------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "MachONormalizedFile.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
 #include <system_error>
 
 #ifndef LLD_READER_WRITER_MACHO_NORMALIZED_FILE_BINARY_UTILS_H
 #define LLD_READER_WRITER_MACHO_NORMALIZED_FILE_BINARY_UTILS_H
 
 namespace lld {
 namespace mach_o {
 namespace normalized {
 
 using llvm::sys::getSwappedBytes;
 
-inline uint16_t read16(bool swap, uint16_t value) {
-    return (swap ? getSwappedBytes(value) : value);
-}
-
-inline uint32_t read32(bool swap, uint32_t value) {
-    return (swap ? getSwappedBytes(value) : value);
-}
-
-inline uint64_t read64(bool swap, uint64_t value) {
-    return (swap ? getSwappedBytes(value) : value);
-}
-
-inline void write16(int16_t &loc, bool swap, int16_t value) {
-    loc = (swap ? getSwappedBytes(value) : value);
+ using llvm::support::ubig16_t;
+ using llvm::support::ubig32_t;
+ using llvm::support::ubig64_t;
+
+ using llvm::support::ulittle16_t;
+ using llvm::support::ulittle32_t;
+ using llvm::support::ulittle64_t;
+
+template<typename T>
+static inline uint16_t read16(const T *loc, bool isBig) {
+  assert((uint64_t)loc % llvm::alignOf<T>() == 0 &&
+         "invalid pointer alignment");
+  return isBig ? *(ubig16_t *)loc : *(ulittle16_t *)loc;
+}
+
+template<typename T>
+static inline uint32_t read32(const T *loc, bool isBig) {
+  assert((uint64_t)loc % llvm::alignOf<T>() == 0 &&
+         "invalid pointer alignment");
+  return isBig ? *(ubig32_t *)loc : *(ulittle32_t *)loc;
+}
+
+template<typename T>
+static inline uint64_t read64(const T *loc, bool isBig) {
+  assert((uint64_t)loc % llvm::alignOf<T>() == 0 &&
+         "invalid pointer alignment");
+  return isBig ? *(ubig64_t *)loc : *(ulittle64_t *)loc;
+}
+
+inline void write16(uint8_t *loc, uint16_t value, bool isBig) {
+  if (isBig)
+    *(ubig16_t *)loc = value;
+  else
+    *(ulittle16_t *)loc = value;
 }
 
-inline void write32(int32_t &loc, bool swap, int32_t value) {
-    loc = (swap ? getSwappedBytes(value) : value);
+inline void write32(uint8_t *loc, uint32_t value, bool isBig) {
+  if (isBig)
+    *(ubig32_t *)loc = value;
+  else
+    *(ulittle32_t *)loc = value;
 }
 
-inline void write64(uint64_t &loc, bool swap, uint64_t value) {
-    loc = (swap ? getSwappedBytes(value) : value);
+inline void write64(uint8_t *loc, uint64_t value, bool isBig) {
+  if (isBig)
+    *(ubig64_t *)loc = value;
+  else
+    *(ulittle64_t *)loc = value;
 }
 
 inline uint32_t
 bitFieldExtract(uint32_t value, bool isBigEndianBigField, uint8_t firstBit,
                                                           uint8_t bitCount) {
   const uint32_t mask = ((1<<bitCount)-1);
   const uint8_t shift = isBigEndianBigField ? (32-firstBit-bitCount) : firstBit;
   return (value >> shift) & mask;
 }
 
 inline void
 bitFieldSet(uint32_t &bits, bool isBigEndianBigField, uint32_t newBits,
                             uint8_t firstBit, uint8_t bitCount) {
   const uint32_t mask = ((1<<bitCount)-1);
   assert((newBits & mask) == newBits);
   const uint8_t shift = isBigEndianBigField ? (32-firstBit-bitCount) : firstBit;
   bits &= ~(mask << shift);
   bits |= (newBits << shift);
 }
 
-inline Relocation
-unpackRelocation(const llvm::MachO::any_relocation_info &r, bool swap,
-                                                            bool isBigEndian) {
-  uint32_t r0 = read32(swap, r.r_word0);
-  uint32_t r1 = read32(swap, r.r_word1);
+inline Relocation unpackRelocation(const llvm::MachO::any_relocation_info &r,
+  uint32_t r0 = read32(&r.r_word0, isBigEndian);
+  uint32_t r1 = read32(&r.r_word1, isBigEndian);
 
   Relocation result;
   if (r0 & llvm::MachO::R_SCATTERED) {
     // scattered relocation record always laid out like big endian bit field
     result.offset     = bitFieldExtract(r0, true, 8, 24);
     result.scattered  = true;
     result.type       = (RelocationInfoType)
                         bitFieldExtract(r0, true, 4, 4);

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

 }
 
 std::error_code processSection(DefinedAtom::ContentType atomType,
                                const Section &section,
                                bool customSectionName,
                                const NormalizedFile &normalizedFile,
                                MachOFile &file, bool copyRefs) {
   const bool is64 = MachOLinkingContext::is64Bit(normalizedFile.arch);
-  const bool swap = !MachOLinkingContext::isHostEndian(normalizedFile.arch);
+  const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
 
   // Get info on how to atomize section.
   unsigned int       sizeMultiple;
   DefinedAtom::Scope scope;
   DefinedAtom::Merge merge;
   AtomizeModel       atomizeModel;
   sectionParseInfo(atomType, sizeMultiple, scope, merge, atomizeModel);
 
for (unsigned int offset = 0, e = section.content.size(); offset != e;) {
             size = i + 2 - offset;
             break;
           }
         }
         break;
       case atomizeCFI:
         // Break section up into dwarf unwind CFIs (FDE or CIE).
         cfi = reinterpret_cast<const uint32_t *>(&section.content[offset]);
-        size = read32(swap, *cfi) + 4;
+        size = read32(&section.content[offset], isBig) + 4;
         if (offset+size > section.content.size()) {
           return make_dynamic_error_code(Twine(Twine("Section ")
                                          + section.segmentName
                                          + "/" + section.sectionName
                                          + " is malformed.  Size of CFI "
                                          "starting at offset ("
                                          + Twine(offset)
                                          + ") is past end of section."));
if ((sym->type & N_TYPE) == N_SECT) {
       }
       return make_dynamic_error_code(Twine("no undefined atom found for sym"));
     } else {
       // Search undefs
       return make_dynamic_error_code(Twine("no atom found for symbol"));
     }
   };
 
-  const bool swap = !MachOLinkingContext::isHostEndian(normalizedFile.arch);
+  const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   // Use old-school iterator so that paired relocations can be grouped.
   for (auto it=section.relocations.begin(), e=section.relocations.end();
                                                                 it != e; ++it) {
     const Relocation &reloc = *it;
     // Find atom this relocation is in.
     if (reloc.offset > section.content.size())
       return make_dynamic_error_code(Twine("r_address (") + Twine(reloc.offset)
                                     + ") is larger than section size ("
                                     + Twine(section.content.size()) + ")");
     uint32_t offsetInAtom;
     MachODefinedAtom *inAtom = file.findAtomCoveringAddress(section,
                                                             reloc.offset,
                                                             &offsetInAtom);
     assert(inAtom && "r_address in range, should have found atom");
     uint64_t fixupAddress = section.address + reloc.offset;
 
     const lld::Atom *target = nullptr;
     Reference::Addend addend = 0;
     Reference::KindValue kind;
     std::error_code relocErr;
     if (handler.isPairedReloc(reloc)) {
      // Handle paired relocations together.
-     relocErr = handler.getPairReferenceInfo(reloc, *++it, inAtom,
-                                              offsetInAtom, fixupAddress, swap,
-                                              atomByAddr, atomBySymbol, &kind,
-                                               &target, &addend);
+      relocErr = handler.getPairReferenceInfo(
+          reloc, *++it, inAtom, offsetInAtom, fixupAddress, isBig, atomByAddr,
+          atomBySymbol, &kind, &target, &addend);
     }
     else {
       // Use ArchHandler to convert relocation record into information
       // needed to instantiate an lld::Reference object.
-      relocErr = handler.getReferenceInfo(reloc, inAtom, offsetInAtom,
-                                          fixupAddress,swap, atomByAddr,
-                                         atomBySymbol, &kind, &target, &addend);
+      relocErr = handler.getReferenceInfo(
+          reloc, inAtom, offsetInAtom, fixupAddress, isBig, atomByAddr,
     }
     if (relocErr) {
       return make_dynamic_error_code(
         Twine("bad relocation (") + relocErr.message()
          + ") in section "
          + section.segmentName + "/" + section.sectionName
          + " (r_address=" + Twine::utohexstr(reloc.offset)
          + ", r_type=" + Twine(reloc.type)

 }
 
 bool isDebugInfoSection(const Section &section) {
   if ((section.attributes & S_ATTR_DEBUG) == 0)
     return false;
   return section.segmentName.equals("__DWARF");
 }
 
-static int64_t readSPtr(bool is64, bool swap, const uint8_t *addr) {
+static int64_t readSPtr(bool is64, bool isBig, const uint8_t *addr) {
   if (is64)
-    return read64(swap, *reinterpret_cast<const uint64_t *>(addr));
+    return read64(addr, isBig);
 
-  int32_t res = read32(swap, *reinterpret_cast<const uint32_t *>(addr));
+  int32_t res = read32(addr, isBig);
   return res;
 }
 
 std::error_code addEHFrameReferences(const NormalizedFile &normalizedFile,
                                      MachOFile &file,
                                      mach_o::ArchHandler &handler) {
-  const bool swap = !MachOLinkingContext::isHostEndian(normalizedFile.arch);
+  const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   const bool is64 = MachOLinkingContext::is64Bit(normalizedFile.arch);
 
   const Section *ehFrameSection = nullptr;
   for (auto &section : normalizedFile.sections)
     if (section.segmentName == "__TEXT" &&
         section.sectionName == "__eh_frame") {
       ehFrameSection = &section;
       break;
     }
 
   // No __eh_frame so nothing to do.
   if (!ehFrameSection)
     return std::error_code();
 
   file.eachAtomInSection(*ehFrameSection,
                          [&](MachODefinedAtom *atom, uint64_t offset) -> void {
     assert(atom->contentType() == DefinedAtom::typeCFI);
 
-    if (ArchHandler::isDwarfCIE(swap, atom))
+    if (ArchHandler::isDwarfCIE(isBig, atom))
       return;
 
     // Compiler wasn't lazy and actually told us what it meant.
     if (atom->begin() != atom->end())
       return;
 
     const uint8_t *frameData = atom->rawContent().data();
-    uint32_t size = read32(swap, *(uint32_t *)frameData);
+    uint32_t size = read32(frameData, isBig);
     uint64_t cieFieldInFDE = size == 0xffffffffU
                                    ? sizeof(uint32_t) + sizeof(uint64_t)
                                    : sizeof(uint32_t);
 
     // Linker needs to fixup a reference from the FDE to its parent CIE (a
     // 32-bit byte offset backwards in the __eh_frame section).
-    uint32_t cieDelta = read32(swap, *(uint32_t *)(frameData + cieFieldInFDE));
+    uint32_t cieDelta = read32(frameData + cieFieldInFDE, isBig);
     uint64_t cieAddress = ehFrameSection->address + offset + cieFieldInFDE;
     cieAddress -= cieDelta;
 
     Reference::Addend addend;
     const Atom *cie =
         findAtomCoveringAddress(normalizedFile, file, cieAddress, &addend);
     atom->addReference(cieFieldInFDE, handler.unwindRefToCIEKind(), cie,
                        addend, handler.kindArch());
 
     // Linker needs to fixup reference from the FDE to the function it's
     // describing. FIXME: there are actually different ways to do this, and the
     // particular method used is specified in the CIE's augmentation fields
     // (hopefully)
     uint64_t rangeFieldInFDE = cieFieldInFDE + sizeof(uint32_t);
 
-    int64_t functionFromFDE = readSPtr(is64, swap, frameData + rangeFieldInFDE);
+    int64_t functionFromFDE = readSPtr(is64, isBig, frameData + rangeFieldInFDE);
     uint64_t rangeStart = ehFrameSection->address + offset + rangeFieldInFDE;
     rangeStart += functionFromFDE;
 
     const Atom *func =
         findAtomCoveringAddress(normalizedFile, file, rangeStart, &addend);
     atom->addReference(rangeFieldInFDE, handler.unwindRefToFunctionKind(), func,
                        addend, handler.kindArch());
   });