[lld-macho][nfc] POC for 32 bit support

[tschuett]

less hacky

[tschuett]

minimize diff

[tschuett]

even smaller diff

[tschuett]

tweak

[tschuett]

tweak

[int3]

I'm not really seeing how this is better than the current implementation. Could you explain?

[tschuett]

Nope is fine. But it keeps the section and section_64 instead of the offset in getEmbeddedAddend.

lld/MachO/Target.h

32

This template hack is gone now.

[int3]

Yeah I'm not a fan of this. I think passing the offset is fine: we call it in exactly one place in the code, so there's little risk of confusion. And LLD-ELF has a similar design.

[tschuett]

No problem.

lld/MachO/Arch/ARM64.cpp

 
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
-struct ARM64 : TargetInfo {
+struct ARM64 : TargetInfo_LP64 {
   ARM64();
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
-                            const relocation_info) const override;
+  int64_t getEmbeddedAddend(llvm::MemoryBufferRef,
+                            const llvm::MachO::section_64 &,
+                            const llvm::MachO::relocation_info) const override;
+  int64_t getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section &,
+                            const llvm::MachO::relocation_info) const override;
+
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t pc) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
 

 #undef B
   }};
   assert(type < relocAttrsArray.size() && "invalid relocation type");
   if (type >= relocAttrsArray.size())
     return invalidRelocAttrs;
   return relocAttrsArray[type];
 }
 
-int64_t ARM64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+int64_t ARM64::getEmbeddedAddend(llvm::MemoryBufferRef mb,
+                                 const llvm::MachO::section &sec,
+                                 const llvm::MachO::relocation_info rel) const {
+  assert(wordSize == 4 && "ARM64 is 64-bit");
+  return -1;
+}
+
+int64_t ARM64::getEmbeddedAddend(MemoryBufferRef mb,
+                                 const llvm::MachO::section_64 &sec,
                                  const relocation_info rel) const {
   if (rel.r_type != ARM64_RELOC_UNSIGNED &&
       rel.r_type != ARM64_RELOC_SUBTRACTOR) {
     // All other reloc types should use the ADDEND relocation to store their
     // addends.
     // TODO(gkm): extract embedded addend just so we can assert that it is 0
     return 0;
   }
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  const uint8_t *loc = buf + offset + rel.r_address;
+  const uint8_t *loc = buf + sec.offset + rel.r_address;
   switch (rel.r_length) {
   case 2:
     return static_cast<int32_t>(read32le(loc));
   case 3:
     return read64le(loc);
   default:
     llvm_unreachable("invalid r_length");
   }
void ARM64::relaxGotLoad(uint8_t *loc, uint8_t type) const {
   assert(((instruction >> 10) & 0xfff) == 0 &&
          "non-zero embedded LDR immediate");
   // C6.2.4 ADD (immediate)
   // ADD <Xd|SP>, <Xn|SP>, #<imm>{, <shift>}
   instruction = ((instruction & 0x001fffff) | 0x91000000);
   write32le(loc, instruction);
 }
 
-ARM64::ARM64() : TargetInfo(LP64()) {
+ARM64::ARM64() : TargetInfo_LP64() {
   cpuType = CPU_TYPE_ARM64;
   cpuSubtype = CPU_SUBTYPE_ARM64_ALL;
 
   stubSize = sizeof(stubCode);
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
 }
 
 TargetInfo *macho::createARM64TargetInfo() {
   static ARM64 t;
   return &t;
 }

lld/MachO/Arch/X86_64.cpp

 
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
-struct X86_64 : TargetInfo {
+struct X86_64 : TargetInfo_LP64 {
   X86_64();
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
-                            const relocation_info) const override;
+  int64_t getEmbeddedAddend(llvm::MemoryBufferRef,
+                            const llvm::MachO::section_64 &,
+                            const llvm::MachO::relocation_info) const override;
+  int64_t getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section &,
+                            const llvm::MachO::relocation_info) const override;
+
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t relocVA) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
 
case X86_64_RELOC_SIGNED_2:
     return 2;
   case X86_64_RELOC_SIGNED_4:
     return 4;
   default:
     return 0;
   }
 }
 
-int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+int64_t X86_64::getEmbeddedAddend(llvm::MemoryBufferRef,
+                                  const llvm::MachO::section &,
+                                  const llvm::MachO::relocation_info) const {
+  assert(wordSize == 4 && "X86_64 is 64-bit");
+  return -1;
+}
+
+int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb,
+                                  const llvm::MachO::section_64 &sec,
                                   relocation_info rel) const {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  const uint8_t *loc = buf + offset + rel.r_address;
+  const uint8_t *loc = buf + sec.offset + rel.r_address;
 
   switch (rel.r_length) {
   case 2:
     return static_cast<int32_t>(read32le(loc)) + pcrelOffset(rel.r_type);
   case 3:
     return read64le(loc) + pcrelOffset(rel.r_type);
   default:
     llvm_unreachable("invalid r_length");

 
 void X86_64::relaxGotLoad(uint8_t *loc, uint8_t type) const {
   // Convert MOVQ to LEAQ
   if (loc[-2] != 0x8b)
     error(getRelocAttrs(type).name + " reloc requires MOVQ instruction");
   loc[-2] = 0x8d;
 }
 
-X86_64::X86_64() : TargetInfo(LP64()) {
+X86_64::X86_64() : TargetInfo_LP64() {
   cpuType = CPU_TYPE_X86_64;
   cpuSubtype = CPU_SUBTYPE_X86_64_ALL;
 
   stubSize = sizeof(stub);
   stubHelperHeaderSize = sizeof(stubHelperHeader);
   stubHelperEntrySize = sizeof(stubHelperEntry);
 }
 
 TargetInfo *macho::createX86_64TargetInfo() {
   static X86_64 t;
   return &t;
 }

lld/MachO/InputFiles.cpp

if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
       relInfo = relInfos[++i];
     }
     assert(i < relInfos.size());
     if (!validateRelocationInfo(this, sec, relInfo))
       continue;
     if (relInfo.r_address & R_SCATTERED)
       fatal("TODO: Scattered relocations not supported");
 
-    int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
+    int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec, relInfo);
     assert(!(embeddedAddend && pairedAddend));
     int64_t totalAddend = pairedAddend + embeddedAddend;
     Reloc r;
     r.type = relInfo.r_type;
     r.pcrel = relInfo.r_pcrel;
     r.length = relInfo.r_length;
     r.offset = relInfo.r_address;
     if (relInfo.r_extern) {

lld/MachO/Target.h

 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 class Symbol;
 class DylibSymbol;
 class InputSection;
 
 class TargetInfo {
 public:
-  template <class LP> TargetInfo(LP) {
-    // Having these values available in TargetInfo allows us to access them
-    // without having to resort to templates.
-    pageZeroSize = LP::pageZeroSize;
-    wordSize = LP::wordSize;
-  }
+  TargetInfo(size_t wordSize, size_t pageZeroSize)
+      : wordSize(wordSize), pageZeroSize(pageZeroSize){};
 
   virtual ~TargetInfo() = default;
 
   // Validate the relocation structure and get its addend.
   virtual int64_t
-  getEmbeddedAddend(llvm::MemoryBufferRef, uint64_t offset,
+  getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section_64 &,
+                    const llvm::MachO::relocation_info) const = 0;
+  virtual int64_t
+  getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section &,
                     const llvm::MachO::relocation_info) const = 0;
   virtual void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                            uint64_t relocVA) const = 0;
 
   // Write code for lazy binding. See the comments on StubsSection for more
   // details.
   virtual void writeStub(uint8_t *buf, const Symbol &) const = 0;
   virtual void writeStubHelperHeader(uint8_t *buf) const = 0;
public:
 
   bool hasAttr(uint8_t type, RelocAttrBits bit) const {
     return getRelocAttrs(type).hasAttr(bit);
   }
 
   uint32_t cpuType;
   uint32_t cpuSubtype;
 
+  size_t wordSize;
   uint64_t pageZeroSize;
   size_t stubSize;
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
-  size_t wordSize;
 };
 
-TargetInfo *createX86_64TargetInfo();
-TargetInfo *createARM64TargetInfo();
-
 struct LP64 {
   using mach_header = llvm::MachO::mach_header_64;
   using nlist = structs::nlist_64;
   using segment_command = llvm::MachO::segment_command_64;
   using section = llvm::MachO::section_64;
 
   static constexpr uint32_t magic = llvm::MachO::MH_MAGIC_64;
   static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT_64;
struct ILP32 {
 
   static constexpr uint32_t magic = llvm::MachO::MH_MAGIC;
   static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT;
 
   static constexpr uint64_t pageZeroSize = 1ull << 12;
   static constexpr size_t wordSize = 4;
 };
 
+class TargetInfo_ILP32 : public TargetInfo {
+public:
+  TargetInfo_ILP32() : TargetInfo(ILP32::wordSize, ILP32::pageZeroSize){};
+};
+
+class TargetInfo_LP64 : public TargetInfo {
+public:
+  TargetInfo_LP64() : TargetInfo(LP64::wordSize, LP64::pageZeroSize){};
+};
+
+TargetInfo *createX86_64TargetInfo();
+TargetInfo *createARM64TargetInfo();
+
 extern TargetInfo *target;
 
 } // namespace macho
 } // namespace lld
 
 #endif