[x86] Convert little endian Addend to native endian when reading MachO section data.

[dsanders]

Summary

This patch fixes the MachO_i386_DynNoPIC_relocations.s test on a big-endian Mips
host by replacing two memcpy's with a new version of support::endian::read<>()
that reads the specified number of bytes and converts it to the native endian.

[lhames]

Hi Daniel,

Thanks for tracking this down!

I've committed an alternative fix for this in r219543. I believe your fix would have worked equally well, but I want to keep the endian-aware read/write style consistent across RuntimeDyldMachO.

Could you let me know if r219543 fixes the failures you're seeing.

Cheers,
Lang.

[dsanders]

Thanks, r219543 fixes the test. The remaining two failures (MachO_ARM_PIC_relocations.s and MachO_i386_eh_frame.s) are looking like the same kind of thing but I haven't located the origin of the endian-reversed value yet.

include/llvm/Support/Endian.h

 // This file declares generic functions to read and write endian specific data.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ENDIAN_H
 #define LLVM_SUPPORT_ENDIAN_H
 
 #include "llvm/Support/AlignOf.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/SwapByteOrder.h"
 
 namespace llvm {
 namespace support {
 enum endianness {big, little, native};
 
 // These are named values for common alignments.
inline value_type read(const void *memory) {
 
   memcpy(&ret,
          LLVM_ASSUME_ALIGNED(memory,
            (detail::PickAlignment<value_type, alignment>::value)),
          sizeof(value_type));
   return byte_swap<value_type, endian>(ret);
 }
 
+/// Read a value of a particular endianness and size from memory.
+template<typename value_type,
+         endianness endian,
+         std::size_t alignment>
+inline value_type read(const void *memory, std::size_t size) {
+  switch (size) {
+  default:
+    llvm_unreachable("Unexpected size");
+    break;
+  case 1:
+    return support::endian::read<int8_t, endian, alignment>(memory);
+  case 2:
+    return support::endian::read<int16_t, endian, alignment>(memory);
+  case 4:
+    return support::endian::read<int32_t, endian, alignment>(memory);
+  case 8:
+    return support::endian::read<int64_t, endian, alignment>(memory);
+  }
+}
+
 /// Read a value of a particular endianness from a buffer, and increment the
 /// buffer past that value.
 template<typename value_type, endianness endian, std::size_t alignment>
 inline value_type readNext(const unsigned char *&memory) {
   value_type ret = read<value_type, endian, alignment>(memory);
   memory += sizeof(value_type);
   return ret;
 }

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h

processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
     SectionEntry &Section = Sections[SectionID];
     uint32_t RelocType = MachO->getAnyRelocationType(RE);
     bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
     unsigned Size = MachO->getAnyRelocationLength(RE);
     uint64_t Offset;
     RelI->getOffset(Offset);
     uint8_t *LocalAddress = Section.Address + Offset;
     unsigned NumBytes = 1 << Size;
-    int64_t Addend = 0;
-    memcpy(&Addend, LocalAddress, NumBytes);
+    int64_t Addend =
+        support::endian::read<int64_t, support::little, support::unaligned>(
+            LocalAddress, NumBytes);
 
     ++RelI;
     MachO::any_relocation_info RE2 =
         MachO->getRelocation(RelI->getRawDataRefImpl());
 
     uint32_t AddrA = MachO->getScatteredRelocationValue(RE);
     section_iterator SAI = getSectionByAddress(*MachO, AddrA);
     assert(SAI != MachO->section_end() && "Can't find section for address A");
relocation_iterator processI386ScatteredVANILLA(
     SectionEntry &Section = Sections[SectionID];
     uint32_t RelocType = MachO->getAnyRelocationType(RE);
     bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
     unsigned Size = MachO->getAnyRelocationLength(RE);
     uint64_t Offset;
     RelI->getOffset(Offset);
     uint8_t *LocalAddress = Section.Address + Offset;
     unsigned NumBytes = 1 << Size;
-    int64_t Addend = 0;
-    memcpy(&Addend, LocalAddress, NumBytes);
+    int64_t Addend =
+        support::endian::read<int64_t, support::little, support::unaligned>(
+            LocalAddress, NumBytes);
 
     unsigned SymbolBaseAddr = MachO->getScatteredRelocationValue(RE);
     section_iterator TargetSI = getSectionByAddress(*MachO, SymbolBaseAddr);
     assert(TargetSI != MachO->section_end() && "Can't find section for symbol");
     uint64_t SectionBaseAddr = TargetSI->getAddress();
     SectionRef TargetSection = *TargetSI;
     bool IsCode = TargetSection.isText();
     uint32_t TargetSectionID =