[mips64] Add support for MCJIT for MIPS64

[vstefanovic]

Summary

Initial support for resolving MIPS64 relocations in MCJIT.

[vstefanovic]

This is the list of passing tests now:

LLVM :: ExecutionEngine/MCJIT/cross-module-sm-pic-a.ll
LLVM :: ExecutionEngine/MCJIT/eh-lg-pic.ll
LLVM :: ExecutionEngine/MCJIT/eh-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/hello-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/multi-module-sm-pic-a.ll
LLVM :: ExecutionEngine/MCJIT/non-extern-addend-smallcodemodel.ll
LLVM :: ExecutionEngine/MCJIT/remote/cross-module-sm-pic-a.ll
LLVM :: ExecutionEngine/MCJIT/remote/multi-module-sm-pic-a.ll
LLVM :: ExecutionEngine/MCJIT/remote/test-global-init-nonzero-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/remote/test-ptr-reloc-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/stubs-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/test-global-init-nonzero-sm-pic.ll
LLVM :: ExecutionEngine/MCJIT/test-ptr-reloc-sm-pic.ll

[vstefanovic]

ping

[lhames]

Hi Vladimir.

Sorry for the delayed response on this, and thanks for working on this.

I think this patch will need to be significantly re-worked before it can go in to the mainline. As it is currently written, it adds a lot of target specific fields and arguments to the RuntimeDyldELF class. We're hoping to reverse the trend of every architecture being lumped in to the one RuntimeDyldELF class. We want to implement future targets (and refactor existing targets) into target specific base classes. You can check out RuntimeDyldMachO and its subclasses for an idea of where we want to go. Some time in the next couple of weeks I'm hoping to break the X86 target out of RuntimeDyldELF and in to its own class (probably RuntimeDyldELFX86). When that happens, it might be useful for you to use as a template for a RuntimeDyldELFMips class.

A couple of specific questions: Why do you need the SymbolName field in RelocationEntry, and the IsLocal member in RelocationValueRef? We want to avoid bloating these classes, since they're shared by all targets. I may be able to suggest other places to attach/handle this information. If it really is required in those structs, I can try to plan my refactor so that RuntimeDyldMips can define its own versions.

Cheers,
Lang.

[vstefanovic]

Hi Lang, thanks for the review.

Mips64 may have three relocations packed into one relocation record, where the result of one relocation is used as the addend for the next one, and they must be resolved in the order they appear.
The current code first resolves external symbols, so for mips64 this order would be broken.

E.g.:

000000000000000c R_MIPS_GPREL16 main
000000000000000c R_MIPS_SUB *ABS*
000000000000000c R_MIPS_HI16 *ABS*

The first relocation would be added to the Relocations, and the next two to the ExternalSymbolRelocations. Instead of using these two maps, we added a different container, one for all symbols (Mips64Relocations), with section id and RelocationEntry pairs. But then external symbols' name gets lost, and that's why we added a SymbolName field in the RelocationEntry.

For the IsLocal - a mips64 GOT entry for local symbols contains only high 16 bits of the symbol address, so we added this field to keep the track whether the symbol is local.

Regards,
Vladimir

[dsanders]

I recently decided to try a mips64 native build and found that there's only two kinds of 'make check-all' failures for this build at the moment. One of them is the lack of an MCJIT which this patch addresses. I've submitted a patch for the other.

I'll wait for a version of this patch that accounts for Lang's comments before reviewing in detail but there's a couple high-level comments I'd like to add.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

1121–1129

We should take the ABI from the ELF e_flags (like PPC64 does) rather than from the triple. It should be possible to use all ABI's on all mips triples (e.g. N32 on a mips triple with -mcpu=mips64, or O32 on a mips64 triple). Admittedly this doesn't work right now but we're working on fixing it.

On a related note, this patch doesn't seem to distinguish N32 and N64. It looks like you're implementing N64 and silently treating N32 as if it were N64.

[vstefanovic]

Obsoleted by D9667.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

std::error_code Check(std::error_code Err) {
   }
   return Err;
 }
 } // end anonymous namespace
 
 class RuntimeDyldELF : public RuntimeDyldImpl {
   void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
                          uint64_t Value, uint32_t Type, int64_t Addend,
-                         uint64_t SymOffset = 0);
+                         uint64_t SymOffset = 0, SID SectionID = 0);
 
   void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
                                uint64_t Value, uint32_t Type, int64_t Addend,
                                uint64_t SymOffset);
 
   void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
                             uint32_t Value, uint32_t Type, int32_t Addend);
 
   void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
                                 uint64_t Value, uint32_t Type, int64_t Addend);
 
   void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
                             uint32_t Value, uint32_t Type, int32_t Addend);
 
   void resolveMIPSRelocation(const SectionEntry &Section, uint64_t Offset,
                              uint32_t Value, uint32_t Type, int32_t Addend);
 
+  void resolveMIPS64Relocation(const SectionEntry &Section, uint64_t Offset,
+                               uint64_t Value, uint32_t Type, int64_t Addend,
+                               SID SectionID);
+
   void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
                               uint64_t Value, uint32_t Type, int64_t Addend);
 
   void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
                                 uint64_t Value, uint32_t Type, int64_t Addend);
 
   unsigned getMaxStubSize() override {
     if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
class RuntimeDyldELF : public RuntimeDyldImpl {
   void findOPDEntrySection(ObjectImage &Obj, ObjSectionToIDMap &LocalSections,
                            RelocationValueRef &Rel);
 
   uint64_t findGOTEntry(uint64_t LoadAddr, uint64_t Offset);
   size_t getGOTEntrySize();
 
   void updateGOTEntries(StringRef Name, uint64_t Addr) override;
 
+  int32_t findMIPSGOTEntryOffset(uint64_t LoadAddr, uint64_t Offset,
+                                 SID GOTSectionID);
+
+  void addMips64RelocationForSection(const RelocationEntry &RE, unsigned SectionID);
+
+  void addMips64RelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName);
+
+  void resolveMips64Relocations();
   // Relocation entries for symbols whose position-independent offset is
   // updated in a global offset table.
   typedef SmallVector<RelocationValueRef, 2> GOTRelocations;
   GOTRelocations GOTEntries; // List of entries requiring finalization.
   SmallVector<std::pair<SID, GOTRelocations>, 8> GOTs; // Allocated tables.
 
+  SmallVector<std::pair<unsigned, RelocationEntry>, 64> Mips64Relocations;
   // When a module is loaded we save the SectionID of the EH frame section
   // in a table until we receive a request to register all unregistered
   // EH frame sections with the memory manager.
   SmallVector<SID, 2> UnregisteredEHFrameSections;
   SmallVector<SID, 2> RegisteredEHFrameSections;
 
+  // A map from section to a GOT section that has entries for section's GOT
+  // relocations.
+  std::map<SID, SID> SectionToGOTMap;
+
+  int64_t calculatedValue;
+
+  bool applyRelocation;
+
+  bool useCalculatedValue;
+
 public:
   RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
   relocation_iterator
   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
                        ObjectImage &Obj, ObjSectionToIDMap &ObjSectionToID,
                        const SymbolTableMap &Symbols, StubMap &Stubs) override;
   bool isCompatibleFormat(const ObjectBuffer *Buffer) const override;
   bool isCompatibleFile(const object::ObjectFile *Buffer) const override;
   void registerEHFrames() override;
   void deregisterEHFrames() override;
   void finalizeLoad(ObjectImage &ObjImg,
                     ObjSectionToIDMap &SectionMap) override;
   virtual ~RuntimeDyldELF();
 
   static std::unique_ptr<ObjectImage>
   createObjectImage(std::unique_ptr<ObjectBuffer> InputBuffer);
   static ObjectImage *createObjectImageFromFile(std::unique_ptr<object::ObjectFile> Obj);
+
+  void resolveRelocations() override;
 };
 
 } // end namespace llvm
 
 #endif

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/ObjectBuffer.h"
 #include "llvm/ExecutionEngine/ObjectImage.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/MutexGuard.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 #define DEBUG_TYPE "dyld"
 
 namespace {
 
*TargetPtr =
         ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
     break;
   case ELF::R_MIPS_UNUSED2:
     *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff);
     break;
   }
 }
 
+void RuntimeDyldELF::resolveMIPS64Relocation(const SectionEntry &Section,
+                                             uint64_t Offset, uint64_t Value,
+                                             uint32_t Type, int64_t Addend,
+                                             SID SectionID) {
+  uint32_t *Placeholder =
+      reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+  if (useCalculatedValue)
+    Addend = calculatedValue;
+
+  DEBUG(dbgs() << "resolveMips64Relocation, LocalAddress: "
+               << Section.Address + Offset << " FinalAddress: "
+               << format("%p", Section.LoadAddress + Offset) << " Value: "
+               << format("%x", Value) << " Type: " << format("%d", Type)
+               << " Addend: " << format("%x", Addend) << "\n");
+
+  switch (Type) {
+  default:
+    llvm_unreachable("Not implemented relocation type!");
+    break;
+  case ELF::R_MIPS_NONE:
+    break;
+  case ELF::R_MIPS_32: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = Value + Addend;
+    if (applyRelocation)
+      *TargetPtr = calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_64: {
+    uint64_t *TargetPtr = reinterpret_cast<uint64_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = Value + Addend;
+    if (applyRelocation)
+      *TargetPtr = calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_26: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = ((Value + Addend) & 0x0fffffff) >> 2;
+    if (applyRelocation)
+      *TargetPtr = ((*Placeholder) & 0xfc000000) | calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_GPREL16: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]);
+    calculatedValue = Value + Addend - (GOTAddr + 0x7ff0);
+    if (applyRelocation)
+      *TargetPtr = ((*Placeholder) & 0xffff0000) | (calculatedValue & 0xffff);
+    break;
+  }
+  case ELF::R_MIPS_SUB: {
+    uint64_t *TargetPtr = reinterpret_cast<uint64_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = Value - Addend;
+    if (applyRelocation)
+      *TargetPtr = calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_HI16: {
+    // Get the higher 16-bits. Also add 1 if bit 15 is 1.
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = ((Value + Addend + 0x8000) >> 16) & 0xffff;
+    if (applyRelocation)
+      *TargetPtr =
+          ((*Placeholder) & 0xffff0000) | calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_LO16: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = (Value + Addend) & 0xffff;
+    if (applyRelocation)
+      *TargetPtr = ((*Placeholder) & 0xffff0000) | calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_CALL16:
+  case ELF::R_MIPS_GOT_DISP:
+  case ELF::R_MIPS_GOT_PAGE: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    int32_t GOTOffset;
+    GOTOffset = findMIPSGOTEntryOffset(Value, Addend,
+                                       SectionToGOTMap[SectionID]);
+    GOTOffset -= 0x7ff0;
+    calculatedValue = GOTOffset;
+    if (applyRelocation)
+      *TargetPtr = ((*Placeholder) & 0xffff0000) | (calculatedValue & 0xffff);
+    break;
+  }
+  case ELF::R_MIPS_GOT_OFST: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    calculatedValue = (Value + Addend) & 0xffff;
+    if (applyRelocation)
+      *TargetPtr = ((*Placeholder) & 0xffff0000) | calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_GPREL32: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]);
+    calculatedValue = Value + Addend - (GOTAddr + 0x7ff0);
+    if (applyRelocation)
+      *TargetPtr = calculatedValue;
+    break;
+  }
+  }
+}
+
+void RuntimeDyldELF::resolveRelocations() {
+  // MIPS64 is specific in resolving relocations since there are three
+  // relocation types in a single entry.
+  // Call MIPS64 specific routine that is aware of this.
+  if (Arch == Triple::mips64el || Arch == Triple::mips64)
+    resolveMips64Relocations();
+  else
+    RuntimeDyldImpl::resolveRelocations();
+}
+
+void RuntimeDyldELF::resolveMips64Relocations() {
+  MutexGuard locked(lock);
+
+  applyRelocation = true;
+  for (unsigned i = 0; i != Mips64Relocations.size(); ++i) {
+    unsigned SectionID = Mips64Relocations[i].first;
+    const RelocationEntry &RE = Mips64Relocations[i].second;
+
+    if (RE.RelType == ELF::R_MIPS_NONE)
+      continue;
+    if (i + 1 != Mips64Relocations.size()) {
+      const RelocationEntry &REnext = Mips64Relocations[i + 1].second;
+      useCalculatedValue = !applyRelocation;
+      applyRelocation = (REnext.RelType == ELF::R_MIPS_NONE) ||
+            (REnext.SectionID != RE.SectionID || REnext.Offset != RE.Offset);
+    }
+
+    if (SectionID != -1U) {
+      uint64_t Addr = Sections[SectionID].LoadAddress;
+      resolveRelocation(RE, Addr);
+    } else {
+      StringRef Name = RE.SymbolName;
+      if (Name.size() == 0) {
+        // This is an absolute symbol, use an address of zero.
+        DEBUG(dbgs() << "Resolving absolute relocations."
+                     << "\n");
+        resolveRelocation(RE, 0);
+      } else {
+        uint64_t Addr = 0;
+        SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(Name);
+        if (Loc == GlobalSymbolTable.end()) {
+          // This is an external symbol, try to get its address from
+          // MemoryManager.
+          Addr = MemMgr->getSymbolAddress(Name.data());
+        } else {
+          // We found the symbol in our global table.  It was probably in a
+          // Module that we loaded previously.
+          SymbolLoc SymLoc = Loc->second;
+          Addr = getSectionLoadAddress(SymLoc.first) + SymLoc.second;
+        }
+        // FIXME: Implement error handling that doesn't kill the host program!
+        if (!Addr)
+          report_fatal_error("Program used external function '" + Name +
+                             "' which could not be resolved!");
+
+        updateGOTEntries(Name, Addr);
+        DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
+                     << format("0x%lx", Addr) << "\n");
+        resolveRelocation(RE, Addr);
+      }
+    }
+  }
+  Mips64Relocations.clear();
+}
+
+void RuntimeDyldELF::addMips64RelocationForSection(const RelocationEntry &RE,
+                                                    unsigned SectionID) {
+  Mips64Relocations.push_back(std::make_pair(SectionID, RE));
+}
+
+void RuntimeDyldELF::addMips64RelocationForSymbol(const RelocationEntry &RE,
+                                             StringRef SymbolName) {
+  // Relocation by symbol.  If the symbol is found in the global symbol table,
+  // create an appropriate section relocation.  Otherwise, add it to
+  // ExternalSymbolRelocations.
+  SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
+  if (Loc == GlobalSymbolTable.end()) {
+    Mips64Relocations.push_back(std::make_pair(-1U, RE));
+  } else {
+    // Copy the RE since we want to modify its addend.
+    RelocationEntry RECopy = RE;
+    RECopy.Addend += Loc->second.second;
+    Mips64Relocations.push_back(std::make_pair(Loc->second.first, RECopy));
+  }
+}
+
 // Return the .TOC. section and offset.
 void RuntimeDyldELF::findPPC64TOCSection(ObjectImage &Obj,
                                          ObjSectionToIDMap &LocalSections,
                                          RelocationValueRef &Rel) {
   // Set a default SectionID in case we do not find a TOC section below.
   // This may happen for references to TOC base base (sym@toc, .odp
   // relocation) without a .toc directive.  In this case just use the
   // first section (which is usually the .odp) since the code won't

 // current object Value will be the LoadAddress of the section in which
 // the symbol resides (RE.Addend provides additional information about the
 // symbol location).  For external symbols, Value will be the address of the
 // symbol in the target address space.
 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
                                        uint64_t Value) {
   const SectionEntry &Section = Sections[RE.SectionID];
   return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
-                           RE.SymOffset);
+                           RE.SymOffset, RE.SectionID);
 }
 
 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
                                        uint64_t Offset, uint64_t Value,
                                        uint32_t Type, int64_t Addend,
-                                       uint64_t SymOffset) {
+                                       uint64_t SymOffset, SID SectionID) {
   switch (Arch) {
   case Triple::x86_64:
     resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
     break;
   case Triple::x86:
     resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
                          (uint32_t)(Addend & 0xffffffffL));
     break;
   case Triple::aarch64:
   case Triple::aarch64_be:
     resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
     break;
   case Triple::arm: // Fall through.
   case Triple::armeb:
   case Triple::thumb:
   case Triple::thumbeb:
     resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
                          (uint32_t)(Addend & 0xffffffffL));
     break;
   case Triple::mips: // Fall through.
   case Triple::mipsel:
     resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
                           Type, (uint32_t)(Addend & 0xffffffffL));
     break;
+  case Triple::mips64:
+  case Triple::mips64el:
+    resolveMIPS64Relocation(Section, Offset, Value, Type, Addend, SectionID);
+    break;
   case Triple::ppc64: // Fall through.
   case Triple::ppc64le:
     resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
     break;
   case Triple::systemz:
     resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
     break;
   default:
relocation_iterator RuntimeDyldELF::processRelocationRef(
   if (Symbol != Obj.end_symbols()) {
     lsi = Symbols.find(TargetName.data());
     Symbol->getType(SymType);
   }
   if (lsi != Symbols.end()) {
     Value.SectionID = lsi->second.first;
     Value.Offset = lsi->second.second;
     Value.Addend = lsi->second.second + Addend;
+    Value.IsLocal = !(Symbol->getFlags() & SymbolRef::SF_Global);
   } else {
     // Search for the symbol in the global symbol table
     SymbolTableMap::const_iterator gsi = GlobalSymbolTable.end();
     if (Symbol != Obj.end_symbols())
       gsi = GlobalSymbolTable.find(TargetName.data());
     if (gsi != GlobalSymbolTable.end()) {
       Value.SectionID = gsi->second.first;
       Value.Offset = gsi->second.second;
       Value.Addend = gsi->second.second + Addend;
+      Value.IsLocal = false;
     } else {
       switch (SymType) {
       case SymbolRef::ST_Debug: {
         // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
         // and can be changed by another developers. Maybe best way is add
         // a new symbol type ST_Section to SymbolRef and use it.
         section_iterator si(Obj.end_sections());
         Symbol->getSection(si);
if (i != Stubs.end()) {
         addRelocationForSection(REHi, Value.SectionID);
         addRelocationForSection(RELo, Value.SectionID);
       }
 
       RelocationEntry RE(SectionID, Offset, RelType, Section.StubOffset);
       addRelocationForSection(RE, SectionID);
       Section.StubOffset += getMaxStubSize();
     }
+  } else if (Arch == Triple::mips64el || Arch == Triple::mips64) {
+    uint64_t r_type = RelType & 0xff;
+    uint64_t r_type2 = (RelType & 0xff00) >> 8;
+    uint64_t r_type3 = (RelType & 0xff0000) >> 16;
+
+    if (r_type == ELF::R_MIPS_CALL16 || r_type == ELF::R_MIPS_GOT_PAGE
+        || r_type == ELF::R_MIPS_GOT_DISP)
+      GOTEntries.push_back(Value);
+
+    RelocationEntry RE1(SectionID, Offset, r_type, Value.Addend, TargetName);
+    if (Value.SymbolName)
+      addMips64RelocationForSymbol(RE1, Value.SymbolName);
+    else
+      addMips64RelocationForSection(RE1, Value.SectionID);
+
+    RelocationEntry RE2(SectionID, Offset, r_type2, Value.Addend, StringRef());
+    addMips64RelocationForSymbol(RE2, StringRef());
+    RelocationEntry RE3(SectionID, Offset, r_type3, Value.Addend, StringRef());
+    addMips64RelocationForSymbol(RE3, StringRef());
   } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
     if (RelType == ELF::R_PPC64_REL24) {
       // Determine ABI variant in use for this object.
       unsigned AbiVariant;
       Obj.getObjectFile()->getPlatformFlags(AbiVariant);
       AbiVariant &= ELF::EF_PPC64_ABI;
       // A PPC branch relocation will need a stub function if the target is
       // an external symbol (Symbol::ST_Unknown) or if the target address
size_t RuntimeDyldELF::getGOTEntrySize() {
   size_t Result = 0;
   switch (Arch) {
   case Triple::x86_64:
   case Triple::aarch64:
   case Triple::aarch64_be:
   case Triple::ppc64:
   case Triple::ppc64le:
   case Triple::systemz:
+  case Triple::mips64el:
+  case Triple::mips64:
     Result = sizeof(uint64_t);
     break;
   case Triple::x86:
   case Triple::arm:
   case Triple::thumb:
   case Triple::mips:
   case Triple::mipsel:
     Result = sizeof(uint32_t);
if (GOTIndex != -1) {
       return getSectionLoadAddress(GOTSectionID) + (GOTIndex * GOTEntrySize);
     }
   }
 
   assert(GOTIndex != -1 && "Unable to find requested GOT entry.");
   return 0;
 }
 
+int32_t RuntimeDyldELF::findMIPSGOTEntryOffset(uint64_t LoadAddress,
+                                               uint64_t Offset,
+                                               SID GOTSectionID) {
+  const size_t GOTEntrySize = getGOTEntrySize();
+
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator it;
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator end =
+      GOTs.end();
+
+  int GOTIndex = -1;
+  bool IsPageEntry = false;
+  for (it = GOTs.begin(); it != end; ++it) {
+    if (it->first != GOTSectionID)
+      continue;
+
+    const GOTRelocations &GOTEntries = it->second;
+
+    // Find the matching entry in our vector.
+    uint64_t SymbolOffset = 0;
+    for (int i = 0, e = GOTEntries.size(); i != e; ++i) {
+      if (!GOTEntries[i].SymbolName) {
+        if (getSectionLoadAddress(GOTEntries[i].SectionID) == LoadAddress &&
+            GOTEntries[i].Offset == Offset) {
+          GOTIndex = i;
+          SymbolOffset = GOTEntries[i].Offset;
+          IsPageEntry = GOTEntries[i].IsLocal;
+          break;
+        }
+      } else {
+        // GOT entries for external symbols use the addend as the address when
+        // the external symbol has been resolved.
+        if (GOTEntries[i].Offset == LoadAddress) {
+          GOTIndex = i;
+          // Don't use the Addend here.  The relocation handler will use it.
+          break;
+        }
+      }
+    }
+
+    if (GOTIndex != -1) {
+      uint64_t Value = LoadAddress + SymbolOffset;
+      if (IsPageEntry) {
+        // Create GOT page entry value.
+        Value = (Value + 0x8000) & 0xffffffffffff0000;
+      }
+      if (GOTEntrySize == sizeof(uint64_t)) {
+        uint64_t *LocalGOTAddr = (uint64_t *)getSectionAddress(GOTSectionID);
+        // Fill in this entry with the address of the symbol being referenced.
+        LocalGOTAddr[GOTIndex] = Value;
+      } else {
+        uint32_t *LocalGOTAddr = (uint32_t *)getSectionAddress(GOTSectionID);
+        // Fill in this entry with the address of the symbol being referenced.
+        LocalGOTAddr[GOTIndex] = (uint32_t)(Value);
+      }
+
+      return GOTIndex * GOTEntrySize;
+    }
+  }
+
+  assert(GOTIndex != -1 && "Unable to find requested GOT entry.");
+  return 0;
+}
+
+
 void RuntimeDyldELF::finalizeLoad(ObjectImage &ObjImg,
                                   ObjSectionToIDMap &SectionMap) {
   // If necessary, allocate the global offset table
   if (MemMgr) {
     // Allocate the GOT if necessary
     size_t numGOTEntries = GOTEntries.size();
     if (numGOTEntries != 0) {
       // Allocate memory for the section
       unsigned SectionID = Sections.size();
       size_t TotalSize = numGOTEntries * getGOTEntrySize();
       uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, getGOTEntrySize(),
                                                   SectionID, ".got", false);
       if (!Addr)
         report_fatal_error("Unable to allocate memory for GOT!");
 
       GOTs.push_back(std::make_pair(SectionID, GOTEntries));
       Sections.push_back(SectionEntry(".got", Addr, TotalSize, 0));
       // For now, initialize all GOT entries to zero.  We'll fill them in as
       // needed when GOT-based relocations are applied.
       memset(Addr, 0, TotalSize);
+      if (Arch == Triple::mips64el || Arch == Triple::mips64) {
+        // To correctly resolve Mips GOT relocations, we need a mapping from
+        // object's sections to GOTs.
+        GOTEntries.clear();
+        for (section_iterator SI = ObjImg.begin_sections(), SE = ObjImg.end_sections();
+             SI != SE; ++SI) {
+          if (SI->relocation_begin() != SI->relocation_end()) {
+            section_iterator RelocatedSection = SI->getRelocatedSection();
+            ObjSectionToIDMap::iterator i = SectionMap.find(*RelocatedSection);
+            assert (i != SectionMap.end());
+            SectionToGOTMap[i->second] = SectionID;
+          }
+        }
+      }
     }
   } else {
     report_fatal_error("Unable to allocate memory for GOT!");
   }
 
   // Look for and record the EH frame section.
   ObjSectionToIDMap::iterator i, e;
   for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

public:
   };
 
   /// True if this is a PCRel relocation (MachO specific).
   bool IsPCRel;
 
   /// The size of this relocation (MachO specific).
   unsigned Size;
 
+  /// Symbol name (for target defined symbols).
+  StringRef SymbolName;
+
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
       : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-        SymOffset(0), IsPCRel(false), Size(0) {}
+        SymOffset(0), IsPCRel(false), Size(0), SymbolName() {}
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
                   uint64_t symoffset)
       : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-        SymOffset(symoffset), IsPCRel(false), Size(0) {}
+        SymOffset(symoffset), IsPCRel(false), Size(0), SymbolName() {}
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
                   bool IsPCRel, unsigned Size)
       : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-        SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
+        SymOffset(0), IsPCRel(IsPCRel), Size(Size), SymbolName() {}
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
                   unsigned SectionA, uint64_t SectionAOffset, unsigned SectionB,
                   uint64_t SectionBOffset, bool IsPCRel, unsigned Size)
       : SectionID(id), Offset(offset), RelType(type),
         Addend(SectionAOffset - SectionBOffset + addend), IsPCRel(IsPCRel),
-        Size(Size) {
+        Size(Size), SymbolName() {
     Sections.SectionA = SectionA;
     Sections.SectionB = SectionB;
   }
+
+  RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
+                  StringRef symname)
+      : SectionID(id), Offset(offset), RelType(type), Addend(addend), SymOffset(0),
+        IsPCRel(false), Size(0), SymbolName(symname) {}
 };
 
 class RelocationValueRef {
 public:
   unsigned SectionID;
   uint64_t Offset;
   int64_t Addend;
   const char *SymbolName;
+  // Mips GOT relocations need to know whether the symbol originally was local.
+  bool IsLocal;
+
   RelocationValueRef() : SectionID(0), Offset(0), Addend(0),
-                         SymbolName(nullptr) {}
+                         SymbolName(nullptr), IsLocal(false) {}
 
   inline bool operator==(const RelocationValueRef &Other) const {
     return SectionID == Other.SectionID && Offset == Other.Offset &&
            Addend == Other.Addend && SymbolName == Other.SymbolName;
   }
   inline bool operator<(const RelocationValueRef &Other) const {
     if (SectionID != Other.SectionID)
       return SectionID < Other.SectionID;
uint64_t getSymbolLoadAddress(StringRef Name) const {
     // Work in progress.
     SymbolTableMap::const_iterator pos = GlobalSymbolTable.find(Name);
     if (pos == GlobalSymbolTable.end())
       return 0;
     SymbolLoc Loc = pos->second;
     return getSectionLoadAddress(Loc.first) + Loc.second;
   }
 
-  void resolveRelocations();
+  virtual void resolveRelocations();
 
   void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
 
   void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
 
   // Is the linker in an error state?
   bool hasError() { return HasError; }
 

lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp

 extern "C" void LLVMInitializeMipsTargetInfo() {
   RegisterTarget<Triple::mips,
         /*HasJIT=*/true> X(TheMipsTarget, "mips", "Mips");
 
   RegisterTarget<Triple::mipsel,
         /*HasJIT=*/true> Y(TheMipselTarget, "mipsel", "Mipsel");
 
   RegisterTarget<Triple::mips64,
-        /*HasJIT=*/false> A(TheMips64Target, "mips64", "Mips64 [experimental]");
+        /*HasJIT=*/true> A(TheMips64Target, "mips64", "Mips64 [experimental]");
 
   RegisterTarget<Triple::mips64el,
-        /*HasJIT=*/false> B(TheMips64elTarget,
+        /*HasJIT=*/true> B(TheMips64elTarget,
                             "mips64el", "Mips64el [experimental]");
 }