Add RelocVisitor support for MachO

[loladiro]

Summary

This commit adds partial support for MachO relocations to RelocVisitor.
A simple test case is added to show that relocations are indeed being
applied and that using llvm-dwarfdump on MachO files no longer errors.
Correctness is not yet tested, due to an unrelated bug in DebugInfo,
which will be fixed with appropriate testcase in a followup commit.

[majnemer]

include/llvm/Object/RelocVisitor.h

21

Please sort this after ELFObjectFile.h

[loladiro]

Resort headers.

[loladiro]

Bump. Could somebody look at the DWARFDebugLine bug fix at least? It doesn't have to do much with MachO (except that it's exposed by running it on the MachO test case). That's the major functional point that needs review here.

[echristo]

Seems reasonable to me. The booleans to printLineInfoForInput should be annotated in the calls.

-eric

[loladiro]

Rebased and split out the DWARF line info bugfix, which I will submit separately.

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct Row {
     void postAppend();
     void reset(bool default_is_stmt);
     void dump(raw_ostream &OS) const;
 
     static bool orderByAddress(const Row& LHS, const Row& RHS) {
       return LHS.Address < RHS.Address;
     }
 
+    static bool orderByAddressLeq(const Row& LHS, const Row& RHS) {
+      return LHS.Address <= RHS.Address;
+    }
+
     // The program-counter value corresponding to a machine instruction
     // generated by the compiler.
     uint64_t Address;
     // An unsigned integer indicating a source line number. Lines are numbered
     // beginning at 1. The compiler may emit the value 0 in cases where an
     // instruction cannot be attributed to any source line.
     uint32_t Line;
     // An unsigned integer indicating a column number within a source line.

include/llvm/Object/MachO.h

public:
   std::error_code
   getRelocationTypeName(DataRefImpl Rel,
                         SmallVectorImpl<char> &Result) const override;
   std::error_code
   getRelocationValueString(DataRefImpl Rel,
                            SmallVectorImpl<char> &Result) const override;
   std::error_code getRelocationHidden(DataRefImpl Rel,
                                       bool &Result) const override;
+  uint8_t getRelocationLength(DataRefImpl Rel) const;
 
   // MachO specific.
   std::error_code getLibraryShortNameByIndex(unsigned Index, StringRef &) const;
 
   // TODO: Would be useful to have an iterator based version
   // of the load command interface too.
 
   basic_symbol_iterator symbol_begin_impl() const override;

include/llvm/Object/RelocVisitor.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_RELOCVISITOR_H
 #define LLVM_OBJECT_RELOCVISITOR_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.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;
public:
   // TODO: Should handle multiple applied relocations via either passing in the
   // previously computed value or just count paired relocations as a single
   // visit.
   RelocToApply visit(uint32_t RelocType, RelocationRef R, uint64_t Value = 0) {
     if (isa<ELFObjectFileBase>(ObjToVisit))
       return visitELF(RelocType, R, Value);
     if (isa<COFFObjectFile>(ObjToVisit))
       return visitCOFF(RelocType, R, Value);
+    if (isa<MachOObjectFile>(ObjToVisit))
+      return visitMachO(RelocType, R, Value);
 
     HasError = true;
     return RelocToApply();
   }
 
   bool error() { return HasError; }
 
 private:
case Triple::x86_64:
         return visitCOFF_AMD64_ADDR64(R, Value);
       }
       break;
     }
     HasError = true;
     return RelocToApply();
   }
 
+  RelocToApply visitMachO(uint32_t RelocType, RelocationRef R, uint64_t Value) {
+    switch (ObjToVisit.getArch()) {
+    default: break;
+    case Triple::x86_64:
+      switch (RelocType) {
+        default: break;
+        case MachO::X86_64_RELOC_UNSIGNED:
+          return visitMACHO_X86_64_UNSIGNED(R, Value);
+      }
+    }
+    HasError = true;
+    return RelocToApply();
+  }
+
   int64_t getELFAddend32LE(RelocationRef R) {
     const ELF32LEObjectFile *Obj = cast<ELF32LEObjectFile>(R.getObjectFile());
     DataRefImpl DRI = R.getRawDataRefImpl();
     int64_t Addend;
     Obj->getRelocationAddend(DRI, Addend);
     return Addend;
   }
 
private:
 
   int64_t getELFAddend64BE(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());
+    return Obj->getRelocationLength(R.getRawDataRefImpl());
+  }
+
   /// 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
private:
   /// AMD64 COFF
   RelocToApply visitCOFF_AMD64_SECREL(RelocationRef R, uint64_t Value) {
     return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
   }
 
   RelocToApply visitCOFF_AMD64_ADDR64(RelocationRef R, uint64_t Value) {
     return RelocToApply(Value, /*Width=*/8);
   }
+
+  // X86_64 MachO
+  RelocToApply visitMACHO_X86_64_UNSIGNED(RelocationRef R, uint64_t Value) {
+    uint8_t Length = getLengthMachO64(R);
+    Length = 1<<Length;
+    return RelocToApply(Value, Length);
+  }
 };
 
 }
 }
 #endif

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

if (seq_pos == start_pos) {
       // For the first sequence, we need to find which row in the sequence is the
       // first in our range. Rows are stored in a vector, so we may use
       // arithmetical operations with iterators.
       DWARFDebugLine::Row row;
       row.Address = address;
       RowIter first_row = Rows.begin() + cur_seq.FirstRowIndex;
       RowIter last_row = Rows.begin() + cur_seq.LastRowIndex;
       RowIter row_pos = std::upper_bound(first_row, last_row, row,
-                                         DWARFDebugLine::Row::orderByAddress);
+                                         DWARFDebugLine::Row::orderByAddressLeq);
       // The 'row_pos' iterator references the first row that is greater than
-      // our start address. Unless that's the first row, we want to start at
-      // the row before that.
+      // our or equal to start address.
       first_row_index = cur_seq.FirstRowIndex + (row_pos - first_row);
-      if (row_pos != first_row)
-        --first_row_index;
     } else
       first_row_index = cur_seq.FirstRowIndex;
 
     // For the last sequence in our range, we need to figure out the last row in
     // range.  For all other sequences we can go to the end of the sequence.
     if (cur_seq.HighPC > end_addr) {
       DWARFDebugLine::Row row;
       row.Address = end_addr;
       RowIter first_row = Rows.begin() + cur_seq.FirstRowIndex;
       RowIter last_row = Rows.begin() + cur_seq.LastRowIndex;
       RowIter row_pos = std::upper_bound(first_row, last_row, row,
-                                         DWARFDebugLine::Row::orderByAddress);
+                                         DWARFDebugLine::Row::orderByAddressLeq);
       // The 'row_pos' iterator references the first row that is greater than
-      // our end address.  The row before that is the last row we want.
+      // or equal our end address. The row before that is the last row we want,
+      // since end_address is the first address past the end of the range we're
+      // looking up.
       last_row_index = cur_seq.FirstRowIndex + (row_pos - first_row) - 1;
     } else
       // Contrary to what you might expect, DWARFDebugLine::SequenceLastRowIndex
       // isn't a valid index within the current sequence.  It's that plus one.
       last_row_index = cur_seq.LastRowIndex - 1;
 
     for (uint32_t i = first_row_index; i <= last_row_index; ++i) {
       result.push_back(i);

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;
 }
 
+uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
+  MachO::any_relocation_info RE = getRelocation(Rel);
+  return getAnyRelocationLength(RE);
+}
+
 //
 // guessLibraryShortName() is passed a name of a dynamic library and returns a
 // guess on what the short name is.  Then name is returned as a substring of the
 // StringRef Name passed in.  The name of the dynamic library is recognized as
 // a framework if it has one of the two following forms:
 //      Foo.framework/Versions/A/Foo
 //      Foo.framework/Foo
 // Where A and Foo can be any string.  And may contain a trailing suffix

test/DebugInfo/debuglineinfo-macho.test

+RUN: llvm-rtdyld -printobjline %p/Inputs/test-simple-macho.o \
+RUN:   | FileCheck %s -check-prefix TEST_SIMPLE
+RUN: llvm-rtdyld -printobjline %p/Inputs/test-multiple-macho.o \
+RUN:   | FileCheck %s -check-prefix TEST_MULTIPLE
+
+TEST_SIMPLE:      Function: _foo, Size = 11
+TEST_SIMPLE-NEXT:  Line info @ 0: simple.c, line:1
+TEST_SIMPLE-NEXT:  Line info @ 7: simple.c, line:2
+TEST_SIMPLE-NEXT:  Line info @ 11: simple.c, line:2
+
+TEST_MULTIPLE:      Function: _bar, Size = 48
+TEST_MULTIPLE-NEXT:   Line info @ 0: multiple.c, line:5
+TEST_MULTIPLE-NEXT:   Line info @ 7: multiple.c, line:6
+TEST_MULTIPLE-NEXT:   Line info @ 16: multiple.c, line:9
+TEST_MULTIPLE-NEXT:   Line info @ 21: multiple.c, line:9
+TEST_MULTIPLE-NEXT:   Line info @ 26: multiple.c, line:7
+TEST_MULTIPLE-NEXT:   Line info @ 33: multiple.c, line:10
+TEST_MULTIPLE-NEXT: Function: _foo, Size = 16
+TEST_MULTIPLE-NEXT:   Line info @ 0: multiple.c, line:1
+TEST_MULTIPLE-NEXT:   Line info @ 7: multiple.c, line:2
+TEST_MULTIPLE-NEXT: Function: _fubar, Size = 46
+TEST_MULTIPLE-NEXT:   Line info @ 0: multiple.c, line:12
+TEST_MULTIPLE-NEXT:   Line info @ 7: multiple.c, line:13
+TEST_MULTIPLE-NEXT:   Line info @ 12: multiple.c, line:17
+TEST_MULTIPLE-NEXT:   Line info @ 25: multiple.c, line:15
+TEST_MULTIPLE-NEXT:   Line info @ 34: multiple.c, line:19
+TEST_MULTIPLE-NEXT:   Line info @ 41: multiple.c, line:21
+TEST_MULTIPLE-NEXT:   Line info @ 46: multiple.c, line:21

tools/llvm-rtdyld/llvm-rtdyld.cpp

 using namespace llvm::object;
 
 static cl::list<std::string>
 InputFileList(cl::Positional, cl::ZeroOrMore,
               cl::desc("<input file>"));
 
 enum ActionType {
   AC_Execute,
+  AC_PrintObjectLineInfo,
   AC_PrintLineInfo,
   AC_Verify
 };
 
 static cl::opt<ActionType>
 Action(cl::desc("Action to perform:"),
        cl::init(AC_Execute),
        cl::values(clEnumValN(AC_Execute, "execute",
                              "Load, link, and execute the inputs."),
+                  clEnumValN(AC_PrintObjectLineInfo, "printobjline",
+                             "Print the line info directly from the input file"),
                   clEnumValN(AC_PrintLineInfo, "printline",
                              "Load, link, and print line information for each function."),
                   clEnumValN(AC_Verify, "verify",
                              "Load, link and verify the resulting memory image."),
                   clEnumValEnd));
 
 static cl::opt<std::string>
 EntryPoint("entry",
if (sys::fs::is_regular_file(Dylib)) {
                      << ErrMsg << "\n";
     } else
       llvm::errs() << "Dylib not found: '" << Dylib << "'.\n";
   }
 }
 
 /* *** */
 
-static int printLineInfoForInput() {
+static int printLineInfoForInput(bool LoadObjects, bool UseDebugObj) {
+  assert(LoadObjects || !UseDebugObj);
+
   // Load any dylibs requested on the command line.
   loadDylibs();
 
   // If we don't have any input files, read from stdin.
   if (!InputFileList.size())
     InputFileList.push_back("-");
   for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) {
     // Instantiate a dynamic linker.
for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) {
     ErrorOr<std::unique_ptr<ObjectFile>> MaybeObj(
       ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef()));
 
     if (std::error_code EC = MaybeObj.getError())
       return Error("unable to create object file: '" + EC.message() + "'");
 
     ObjectFile &Obj = **MaybeObj;
 
+    OwningBinary<ObjectFile> DebugObj;
+    std::unique_ptr<DIContext> Context;
+    std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo = nullptr;
+    ObjectFile *SymbolObj = &Obj;
+    if (LoadObjects) {
       // Load the object file
-    std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo =
+      LoadedObjInfo =
         Dyld.loadObject(Obj);
 
       if (Dyld.hasError())
         return Error(Dyld.getErrorString());
 
       // Resolve all the relocations we can.
       Dyld.resolveRelocations();
 
-    OwningBinary<ObjectFile> DebugObj = LoadedObjInfo->getObjectForDebug(Obj);
-
-    std::unique_ptr<DIContext> Context(
-      DIContext::getDWARFContext(*DebugObj.getBinary()));
+      assert(UseDebugObj);
+      DebugObj = LoadedObjInfo->getObjectForDebug(Obj);
+      SymbolObj = DebugObj.getBinary();
+      Context.reset(
+        DIContext::getDWARFContext(*SymbolObj));
+    } else {
+      Context.reset(
+          DIContext::getDWARFContext(Obj));
+    }
 
     // Use symbol info to iterate functions in the object.
-    for (object::symbol_iterator I = DebugObj.getBinary()->symbol_begin(),
-                                 E = DebugObj.getBinary()->symbol_end();
+    for (object::symbol_iterator I = SymbolObj->symbol_begin(),
+                                 E = SymbolObj->symbol_end();
          I != E; ++I) {
       object::SymbolRef::Type SymType;
       if (I->getType(SymType)) continue;
       if (SymType == object::SymbolRef::ST_Function) {
         StringRef  Name;
         uint64_t   Addr;
         uint64_t   Size;
         if (I->getName(Name)) continue;
         if (I->getAddress(Addr)) continue;
         if (I->getSize(Size)) continue;
 
+        if (!UseDebugObj) {
+          object::section_iterator Sec(SymbolObj->section_end());
+          I->getSection(Sec);
+          StringRef SecName;
+          Sec->getName(SecName);
+          uint64_t SectionLoadAddress = LoadObjects ? LoadedObjInfo->getSectionLoadAddress(SecName) : 0;
+          if (SectionLoadAddress != 0)
+            Addr += SectionLoadAddress - Sec->getAddress();
+        }
+
         outs() << "Function: " << Name << ", Size = " << Size << "\n";
 
         DILineInfoTable Lines = Context->getLineInfoForAddressRange(Addr, Size);
         DILineInfoTable::iterator  Begin = Lines.begin();
         DILineInfoTable::iterator  End = Lines.end();
         for (DILineInfoTable::iterator It = Begin; It != End; ++It) {
           outs() << "  Line info @ " << It->first - Addr << ": "
                  << It->second.FileName << ", line:" << It->second.Line << "\n";
int main(int argc, char **argv) {
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n");
 
   switch (Action) {
   case AC_Execute:
     return executeInput();
+  case AC_PrintObjectLineInfo:
+    return printLineInfoForInput(false,false);
   case AC_PrintLineInfo:
-    return printLineInfoForInput();
+    return printLineInfoForInput(true,true);
   case AC_Verify:
     return linkAndVerify();
   }
 }