Partial RelocVisitor support for Darwin

[loladiro]

Summary

This supports as much as I have a test case for. The other relocations should be straightforward, but I'd prefer somebody with an actual use case to do that.

This is issue #16675

There's also the issue that we have two different and disjoint implementations of the relocations for all file formats. One in RuntimeDyld and one here. It would be good to combine those.

[echristo]

One small inline comment, but nothing for you to deal with. Passes the sniff test, but it needs a testcase?

-eric

include/llvm/Object/RelocVisitor.h

21

Boy do we need to unify some of these files...

[loladiro]

Turns out that this relocation is always a noop in all cases I can think of that don't involve a linker (and the linker doesn't have support for this relocation), so I can't actually write a proper testcase. I've written to the mailing list about whether or not the noop behavior is correct and I'll revisit this afterwards. I did also find a small bug in this that I will fix once I hear back on what the expected behavior is.

[loladiro]

Per discussion on the mailing list, these relocations are essentially a noop. This implements them correctly but since LLVM never emits external relocations, I can't actually write a testcase.

include/llvm/Object/MachO.h

public:
   error_code getRelocationOffset(DataRefImpl Rel, uint64_t &Res) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   error_code getRelocationType(DataRefImpl Rel, uint64_t &Res) const override;
   error_code getRelocationTypeName(DataRefImpl Rel,
                                   SmallVectorImpl<char> &Result) const override;
   error_code getRelocationValueString(DataRefImpl Rel,
                                   SmallVectorImpl<char> &Result) const override;
   error_code getRelocationHidden(DataRefImpl Rel, bool &Result) const override;
+  error_code getRelocationLength(DataRefImpl Rel, uint8_t &Res) const;
 
   error_code getLibraryNext(DataRefImpl LibData,
                             LibraryRef &Res) const override;
   error_code getLibraryPath(DataRefImpl LibData, StringRef &Res) const override;
 
   // TODO: Would be useful to have an iterator based version
   // of the load command interface too.
 

include/llvm/Object/RelocVisitor.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_RELOCVISITOR_H
 #define LLVM_OBJECT_RELOCVISITOR_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ELF.h"
+#include "llvm/Support/MachO.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace object {
 
 struct RelocToApply {
   // The computed value after applying the relevant relocations.
   int64_t Value;
RelocToApply visit(uint32_t RelocType, RelocationRef R, uint64_t SecAddr = 0,
     } else if (FileFormat == "ELF32-arm") {
       switch (RelocType) {
       default:
         HasError = true;
         return RelocToApply();
       case llvm::ELF::R_ARM_ABS32:
         return visitELF_ARM_ABS32(R, Value);
       }
+    } else if (FileFormat == "Mach-O 64-bit x86-64") {
+      switch (RelocType) {
+      case llvm::MachO::X86_64_RELOC_UNSIGNED:
+        return visitMACHO_X86_64_UNSIGNED(R, Value);
+      default:
+        HasError = true;
+        return RelocToApply();
+      }
     }
     HasError = true;
     return RelocToApply();
   }
 
   bool error() { return HasError; }
 
 private:
private:
 
   int64_t getAddend64BE(RelocationRef R) {
     const ELF64BEObjectFile *Obj = cast<ELF64BEObjectFile>(R.getObjectFile());
     DataRefImpl DRI = R.getRawDataRefImpl();
     int64_t Addend;
     Obj->getRelocationAddend(DRI, Addend);
     return Addend;
   }
+
+  uint8_t getLengthMachO64(RelocationRef R) {
+    const MachOObjectFile *Obj = cast<MachOObjectFile>(R.getObjectFile());
+    DataRefImpl DRI = R.getRawDataRefImpl();
+    uint8_t Length;
+    Obj->getRelocationLength(DRI, Length);
+    return Length;
+  }
+
   /// Operations
 
   /// 386-ELF
   RelocToApply visitELF_386_NONE(RelocationRef R) {
     return RelocToApply(0, 0);
   }
 
   // Ideally the Addend here will be the addend in the data for
RelocToApply visitELF_SPARCV9_64(RelocationRef R, uint64_t Value) {
     return RelocToApply(Value + Addend, 8);
   }
 
   RelocToApply visitELF_ARM_ABS32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getAddend32LE(R);
     return RelocToApply(Value + Addend, 4);
   }
 
+  RelocToApply visitMACHO_X86_64_UNSIGNED(RelocationRef R, uint64_t Value) {
+    uint8_t Length = getLengthMachO64(R);
+    Length = 1<<Length;
+    // Addend is taken care of when the relocation is actually applied
+    // i.e. the relocation is applied using += rather than =
+    return RelocToApply(Value, Length);
+  }
+
 };
 
 }
 }
 #endif

lib/DebugInfo/DWARFContext.cpp

if (Section.relocation_begin() != Section.relocation_end()) {
       RelocatedSection->getSize(SectionSize);
       for (const RelocationRef &Reloc : Section.relocations()) {
         uint64_t Address;
         Reloc.getOffset(Address);
         uint64_t Type;
         Reloc.getType(Type);
         uint64_t SymAddr = 0;
         // ELF relocations may need the symbol address
-        if (Obj->isELF()) {
+        if (Obj->isELF() || Obj->isMachO()) {
           object::symbol_iterator Sym = Reloc.getSymbol();
+          if (Sym != Obj->symbol_end())
             Sym->getAddress(SymAddr);
+          else {
+            // MachO relocations can target sections however,
+            // when one is not moving sections the resulting
+            // relocation is a noop, so don't do anything here.
           }
+        }
+
+        DEBUG(dbgs() << "Sym Addr " << format("%p", SymAddr) << "\n");
 
         object::RelocVisitor V(Obj->getFileFormatName());
         // The section address is always 0 for debug sections.
         object::RelocToApply R(V.visit(Type, Reloc, 0, SymAddr));
         if (V.error()) {
           SmallString<32> Name;
           error_code ec(Reloc.getTypeName(Name));
           if (ec) {

lib/Object/MachOObjectFile.cpp

if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
       if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR)
         Result = true;
     }
   }
 
   return object_error::success;
 }
 
+error_code
+MachOObjectFile::getRelocationLength(DataRefImpl Rel, uint8_t &Res) const {
+  MachO::any_relocation_info RE = getRelocation(Rel);
+  Res = getAnyRelocationLength(RE);
+  return object_error::success;
+}
+
 error_code MachOObjectFile::getLibraryNext(DataRefImpl LibData,
                                            LibraryRef &Res) const {
   report_fatal_error("Needed libraries unimplemented in MachOObjectFile");
 }
 
 error_code MachOObjectFile::getLibraryPath(DataRefImpl LibData,
                                            StringRef &Res) const {
   report_fatal_error("Needed libraries unimplemented in MachOObjectFile");