[Mips64] Add support for MCJIT for MIPS64r2 and MIPS64r6

[vradosavljevic]

Summary

Add support for resolving MIPS64r2 and MIPS64r6 relocations in MCJIT.

[dsanders]

This supersedes D5913 doesn't it? If so, could you mark that review abandoned.

I believe testcases similar to test/ExecutionEngine/RuntimeDyld/{AArch64,ARM,X86}/* will be required so that we can test the application of relocations without needing to execute JIT'ed code.

As with D5913, there are a couple big issues with this patch. The first is that checking for Triple::mips64/Triple::mips64el is insufficient since this (currently, see below) includes both N32 and N64 and these ABI's need to be treated differently. For example, the 3-in-1 reloc encoding is not used on N32. I don't mind if N32 support arrives in a later patch but this patch needs to identify N32 and N64 and error on N32 while handling N64 rather than quietly doing the wrong thing. The second issue is that using Triple::mips/Triple::mipsel vs Triple::mips64/Triple::mips64el to distinguish 32-bit and 64-bit ABI's is incorrect. It's valid to execute O32 binaries with a 64-bit triple, and N32/N64 binaries with a 32-bit triple. Admittedly, LLVM for Mips targets already has a number of issues in this area but I'd like to avoid adding more.

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

295

I think the answer is 'no' but: Does test/ExecutionEngine/MCJIT/lit.local.cfg need updating?

[lhames]

As dsanders noted, this needs some llvm-rtdyld checker tests along the lines of test/ExecutionEngine/RuntimeDyld/{AArch64,ARM,X86}/* .

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

124–139

Could you please note in the comments that these data structures are MIPS64 specific? At some point in the future we would like to split RuntimeDyldELF into multiple target-specific subclasses along the same lines as RuntimeDyldMachO. When that happens it will be very helpful to know that these data structures can be moved into the RuntimeDyldELF_MIPS64 subclass.

[vradosavljevic]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

124–139

Done.

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

295

We don't have to change test/ExecutionEngine/MCJIT/lit.local.cfg, because 'Mips' contains all Mips triples.
You can see that in autoconf/configure.ac.

mips-* | mips64-*)      host_arch="Mips" ;;
mipsel-* | mips64el-*)  host_arch="Mips" ;;

[vradosavljevic]

Comments addressed. Added llvm-rtdyld checker test, marked MCJIT and OrcMCJIT PIC tests as XFAIL only for mips32 architecture, and added an error report when using N32/O32 ABI's with Mips64 triple.

[dsanders]

Comments addressed. Added llvm-rtdyld checker test, marked MCJIT and OrcMCJIT PIC tests as XFAIL only for mips32 architecture, and added an error report when using N32/O32 ABI's with Mips64 triple.

There's still several triple checks that should be ABI checks. Using the triple for more than distinguishing the Mips target from the others is incorrect.

Also, the llvm-rtdyld test doesn't seem to cover many relocations. Could you expand on it?

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

777

Target triple -> ABI checks.

Only N64 should take this path.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

This particular overload of resolveMIPS64Relocation is only called from this function. So if we rename it to evaluateMIPS64Relocation(), stop it applying the reloc, and have it take/return the current calculated value we can use it as per this pseudo-code:

int64_t calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type, RE.Addend, RE.SectionID, RE.SymOffset, calculatedValue);
if (r_type2 == ELF::R_MIPS_NONE)
  applyMIPS64Relocation(Section.Address + RE.Offset, calculatedValue);

This is neater than passing values in side-channels such as member variables.

578–579

Endian bug. You can't use reinterpret_cast since the host and target may have different endians (particularly for test-cases). Use the endian-aware writeBytesUnaligned() or similar instead. Likewise for the other instances below.

1289

Triple checks -> ABI checks.

1603–1606

Not 100% sure about this one, but I think it's only correct for N64 due to pointer size differences. If this is the case, then we need an ABI check

1667

Triple check -> ABI check.

1670–1671

mips64/mips64el and O32 is not an error case, it's valid. Admittedly it doesn't work in LLVM at this point (this is a bug) so maybe including O32 in this error is ok for now. Could you add a comment explaining that.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

124–132

These three shouldn't be members variables. See below.

[vradosavljevic]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

My understanding of Mips64 ABI is there can be more relocation entries for the same instruction, so i'm using applyRelocation, useCalculatedValue and calculatedValue as members variables to keep them for the following relocation entry if that's the case.

Mips64 ABI allows us e.g.:
000000000000000c R_MIPS_GPREL16 main
000000000000000c R_MIPS_SUB *ABS*
000000000000000c R_MIPS_HI16 *ABS*

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

So if this is the case (theoretically), we should use result of r_type3 from the first relocation entry, for r_type in the second relocation entry (in our case we should use calculatedValue).

From Mips64 ABI:

Up to three operations may be specified per record, by the fields r_type , r_type2 , and r_type3 . They are applied in that order, and a zero field implies no further operations from this record. (The following record may continue the sequence if it references the same offset.)

1670–1671

Should i change triple checks for mips and mipsel to O32 ABI checks and report an error only for N32 ABI?

[dsanders]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

There are multiple ABI's that can be used on Mips64. When you refer to the 'Mips64 ABI', I believe you are referring to the N64 ABI. Is this correct? There is also an N32 ABI which behaves differently. For example, the 3-in-1 reloc encoding only applies to the N64 ABI and not the N32 ABI, and pointers/symbols are 4-bytes for N32 and 8-bytes for N64.
For the sake of completeness, there is also the O64 ABI and the EABI64 ABI but we haven't implemented those two.

My main issue with this chunk of code was its use of sideband mechanisms to implement argument/return value passing instead of using a normal function call. It passes arguments in by writing to a member, returns them by writing to a member, and reads the result by reading a member. Using function arguments and return values is much clearer and does not increase the size of the object unnecessarily.

Here's the example code with all three relocs accounted for and tidied up:

int64_t calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type, RE.Addend, RE.SectionID, RE.SymOffset, calculatedValue);
if (r_type2 != ELF::R_MIPS_NONE)
  calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type2, RE.Addend, RE.SectionID, RE.SymOffset, calculatedValue);
if (r_type3 != ELF::R_MIPS_NONE)
  calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type3, RE.Addend, RE.SectionID, RE.SymOffset, calculatedValue);
applyMIPS64Relocation(Section.Address + RE.Offset, calculatedValue);

1670–1671

Yes. It's ok to use triples to distinguish Mips from other targets, but not to determine the ABI. The only one we need to emit an error for is N32.

The combination of O32 and a mips64/mips64el triple won't work for now because the code generator will assert up front rather than allow the various bugs to confuse the user. However, we should still accept this combination here because we do the right thing in these layers.
The same applies to N32/N64 and mips/mipsel triples.

[vradosavljevic]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

Yes, i'm referring to Mips N64 ABI. This may not be the end of calculating, so we need to check if the next relocation entry is for the same instruction. If it is for the same instruction, we need to send calculatedValue to next relocation entry.

[dsanders]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

Ah, I see the complicating issue. I'm going to have to look up the details of relocation composition to comment on that. The main thing I'm wondering is why Mips needs to do this and other targets don't. I know that some relocation mechanisms would write the calculated value to the section data after one relocation and read it back for the next relocation.

[dsanders]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

I've now looked it up. The 64-bit ELF Object
File Specification (available at https://dmz-portal.mips.com/mw/images/8/82/007-4658-001.pdf), gives the following definition for the 'A' operands:

Represents an addend obtained as the value of the field being relocated
prior to relocation (.rel), from a .rela addend field, or as the preceding
result for a composed relocation (either).

Since N64 uses RELA relocations, I believe my example above should be passing in calculatedValue instead of RE.Addend for all except the first relocation for that address, like so:

int64_t calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type, RE.Addend, RE.SectionID, RE.SymOffset);
if (r_type2 != ELF::R_MIPS_NONE)
  calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type2, calculatedValue, RE.SectionID, RE.SymOffset);
if (r_type3 != ELF::R_MIPS_NONE)
  calculatedValue = evaluateMIPS64Relocation(Section, RE.Offset, Value, r_type3, calculatedValue, RE.SectionID, RE.SymOffset);
applyMIPS64Relocation(Section.Address + RE.Offset, calculatedValue);

It's possible that the two calculatedValue arguments should be 'calculatedValue + RE.Addend' but the spec was a bit unclear on this so I'm not 100% sure. Your current patch implements the former so I've gone with that.

Yes, i'm referring to Mips N64 ABI. This may not be the end of calculating, so we need
to check if the next relocation entry is for the same instruction. If it is for the same
instruction, we need to send calculatedValue to next relocation entry.

Why not handle composition of multiple relocs in resolveRelocationList?

The main thing I'm wondering is why Mips needs to do this and other targets don't.

To partially answer my own question, relocation composition isn't particularly unique to to Mips but it seems that we may use it more often than other targets.

[petarj]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

What Vladimir is trying to say is that - theoretically speaking - getting calculatedValue for r_type can require calculatedValue that we calculated from r_type3 in the previous RelocationEntry.

[dsanders]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

526–529

Yes, I understood that. What I'm trying to say is that you don't need sideband data to achieve that. resolveRelocationList can iterate over all the composed relocations, evaluating it as it goes, and then it can apply the calculated value.

[vradosavljevic]

New patch uploaded. Please take a look.

[dsanders]

Thanks, that's much cleaner. Most of my comments on the latest patch are nits or notes on things that will need to be followed up on. There is one question among them though, as well as one more comment below.

We seem to have lost the ability to compose distinct relocs in this patch. This should be ok in the immediate term (because we do handle our common composition case of the 3-in-1 relocs) but it's something we'll need to follow up on.

Assuming it's safe to only check r_type for R_MIPS_CALL16, R_MIPS_GOT_PAGE, or R_MIPS_GOT_DISP : LGTM with the nits fixed.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

189–191

Nit: Seems unnecessary. It's about to be destroyed anyway and we don't seem to be managing memory.

515–516

For follow-up: It would be preferable to use a MipsABIInfo object. It's essentially an enum representing the ABI but you can ask it questions (e.g. Does the current ABI use REL or RELA relocations? etc.) using the member functions.

I don't think we should do this now though. I think it should wait until Architectures have their own subclasses. If we tried to do it now it would probably require Mips support to always be compiled into LLVM and that's undesirable.

519–524

For follow-up: This is a good example of knowledge that would be suitable for MipsABIInfo. There are multiple places that need to know how to map ELF e_flags to the ABI.

539

Nit: Variables should begin with a capital.

r_type/r_type2/r_type3 are arguably ok since they are trying to match member names of an ELF64 structure so there's no need to change those.

562

Nit: Capitalization

564

Nit: Doesn't match the function name (the 'resolve' and the 'Mips')

582–584

Optional nit: Move the return into the cases. E.g:

case ELF::R_MIPS_64:
  return Value + Addend;

1055

Nit:

else
  llvm_unreachable("Mips ABI not handled");

1290–1293

Is it definitely only r_type that matters? Is it possible to have these relocs in r_type2 or r_type3?

1613

Nit:

else
  llvm_unreachable(...);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

68

Nit: calculatedValue should begin with a capital

[vradosavljevic]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

189–191

Done.

539

Done.

564

Done.

582–584

Done.

1055

Done.

1290–1293

Yes only r_type matters, and in these cases r_type2 and r_type3 are R_MIPS_NONE.

1613

Done.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

68

Done.

[vradosavljevic]

Comments addressed.

[dsanders]

LGTM

[petarj]

In D9667#179660, @dsanders wrote:

We seem to have lost the ability to compose distinct relocs in this patch. This should be ok in the immediate term (because we do handle our common composition case of the 3-in-1 relocs) but it's something we'll need to follow up on.

Yes, we should not forget that. Vladimir, can you create a ticket for this one?
lgtm.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 
 void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
                                             uint64_t Value) {
   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
     const RelocationEntry &RE = Relocs[i];
     // Ignore relocations for sections that were not loaded
     if (Sections[RE.SectionID].Address == nullptr)
       continue;
+    if (Arch == Triple::mips64el || Arch == Triple::mips64)
+      // MIPS64 N64 ABI is specific in resolving relocations since
+      // there are three relocation types in a single entry and may be
+      // applied a number of relocation operations to a single instruction.
+      // Call MIPS64 specific routine that is aware of this.
+      resolveMIPS64Relocation(Relocs, Value, i);
+    else
       resolveRelocation(RE, Value);
   }
 }
 
 void RuntimeDyldImpl::resolveExternalSymbols() {
   while (!ExternalSymbolRelocations.empty()) {
     StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
 
     StringRef Name = i->first();

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

 namespace llvm {
 
 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);
 
+  void resolveMIPS64Relocation(const RelocationList &Relocs, uint64_t Value,
+                               unsigned RelocIndex) override;
+
   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, uint64_t SymOffset);
+
   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)
       return 20; // movz; movk; movk; movk; br
     if (Arch == Triple::arm || Arch == Triple::thumb)
       return 8; // 32-bit instruction and 32-bit address
     else if (Arch == Triple::mipsel || Arch == Triple::mips)
       return 16;
     else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)
       return 44;
     else if (Arch == Triple::x86_64)
       return 6; // 2-byte jmp instruction + 32-bit relative address
     else if (Arch == Triple::systemz)
       return 16;
     else
       return 0;
   }
 
   unsigned getStubAlignment() override {
class RuntimeDyldELF : public RuntimeDyldImpl {
   // The tentative ID for the GOT section
   unsigned GOTSectionID;
 
   // Records the current number of allocated slots in the GOT
   // (This would be equivalent to GOTEntries.size() were it not for relocations
   // that consume more than one slot)
   unsigned CurrentGOTIndex;
 
+  // Apply relocation in instruction (Mips64 specific)
+  bool applyRelocation;
+
+  // True if using the result of the previous relocation type (Mips64 specific)
+  bool useCalculatedValue;
+
+  // The result of the previous relocation type (Mips64 specific)
+  int64_t calculatedValue;
+
+  // A map from section to a GOT section that has entries for section's GOT
+  // relocations. (Mips64 specific)
+  DenseMap<SID, SID> SectionToGOTMap;
+
+  // A map to avoid duplicate got entries (Mips64 specific)
+  StringMap<uint64_t> GOTSymbolOffsets;
+
   // 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;
 
 public:
   RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

 }
 
 } // namespace
 
 namespace llvm {
 
 RuntimeDyldELF::RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
                                RuntimeDyld::SymbolResolver &Resolver)
-    : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
-RuntimeDyldELF::~RuntimeDyldELF() {}
+    : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0),
+      applyRelocation(true), useCalculatedValue(false), calculatedValue(0) {}
+RuntimeDyldELF::~RuntimeDyldELF() { SectionToGOTMap.clear(); }
 
 void RuntimeDyldELF::registerEHFrames() {
   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
     SID EHFrameSID = UnregisteredEHFrameSections[i];
     uint8_t *EHFrameAddr = Sections[EHFrameSID].Address;
     uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress;
     size_t EHFrameSize = Sections[EHFrameSID].Size;
     MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
*TargetPtr =
       ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
     break;
   case ELF::R_MIPS_LO16:
     *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff);
     break;
   }
 }
 
+void RuntimeDyldELF::resolveMIPS64Relocation(const RelocationList &Relocs,
+                                             uint64_t Value,
+                                             unsigned RelocIndex) {
+  const RelocationEntry &RE = Relocs[RelocIndex];
+  const SectionEntry &Section = Sections[RE.SectionID];
+
+  uint32_t r_type = RE.RelType & 0xff;
+  uint32_t r_type2 = (RE.RelType >> 8) & 0xff;
+  uint32_t r_type3 = (RE.RelType >> 16) & 0xff;
+
+  // If next type is R_MIPS_NONE, apply the relocation,
+  // otherwise use the result of this type of relocation as addend for
+  // next type of the same relocation entry.
+  useCalculatedValue = !applyRelocation;
+  applyRelocation = r_type2 == ELF::R_MIPS_NONE;
+  resolveMIPS64Relocation(Section, RE.Offset, Value, r_type, RE.Addend,
+                          RE.SectionID, RE.SymOffset);
+
+  useCalculatedValue = !applyRelocation;
+  applyRelocation = r_type3 == ELF::R_MIPS_NONE;
+  resolveMIPS64Relocation(Section, RE.Offset, Value, r_type2, RE.Addend,
+                          RE.SectionID, RE.SymOffset);
+
+  // If the next relocation entry is not for the same instruction,
+  // apply the relocation, otherwise use the result as addend for
+  // next relocation entry
+  useCalculatedValue = !applyRelocation;
+  if (RelocIndex + 1 == Relocs.size())
+    applyRelocation = true;
+  else {
+    const RelocationEntry &REnext = Relocs[RelocIndex + 1];
+    applyRelocation = REnext.SectionID != RE.SectionID ||
+                      REnext.Offset != RE.Offset;
+  }
+  resolveMIPS64Relocation(Section, RE.Offset, Value, r_type3, RE.Addend,
+                          RE.SectionID, RE.SymOffset);
+}
+
+void RuntimeDyldELF::resolveMIPS64Relocation(const SectionEntry &Section,
+                                             uint64_t Offset, uint64_t Value,
+                                             uint32_t Type, int64_t Addend,
+                                             SID SectionID,
+                                             uint64_t SymOffset) {
+  if (useCalculatedValue) {
+    Addend = calculatedValue;
+    Value = 0;
+  }
+
+  DEBUG(dbgs() << "resolveMips64Relocation, LocalAddress: 0x"
+               << format("%llx", Section.Address + Offset)
+               << " FinalAddress: 0x"
+               << format("%llx", Section.LoadAddress + Offset)
+               << " Value: 0x" << format("%llx", Value) << " Type: 0x"
+               << format("%x", Type) << " Addend: 0x" << format("%llx", Addend)
+               << " SymOffset: " << format("%x", SymOffset)
+               << "\n");
+
+  switch (Type) {
+  default:
+    llvm_unreachable("Not implemented relocation type!");
+    break;
+  case ELF::R_MIPS_JALR:
+  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 = ((*TargetPtr) & 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 = ((*TargetPtr) & 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 = ((*TargetPtr) & 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 = ((*TargetPtr) & 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);
+    uint64_t *LocalGOTAddr =
+       (uint64_t *)(getSectionAddress(SectionToGOTMap[SectionID]) + SymOffset);
+
+    Value += Addend;
+    if (Type == ELF::R_MIPS_GOT_PAGE)
+      Value = (Value + 0x8000) & 0xffffffffffff0000;
+
+    if (*LocalGOTAddr)
+      assert(*LocalGOTAddr == Value &&
+                   "GOT entry has two different addresses.");
+    else
+      *LocalGOTAddr = Value;
+
+    calculatedValue = SymOffset - 0x7ff0;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 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 = ((*TargetPtr) & 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;
+  }
+  case ELF::R_MIPS_PC16: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - FinalAddress - 4) >> 2;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xffff0000) | (calculatedValue & 0xffff);
+    break;
+  }
+  case ELF::R_MIPS_PC18_S3: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - ((FinalAddress | 7) ^ 7)) >> 3;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xfffc0000) | (calculatedValue & 0x3ffff);
+    break;
+  }
+  case ELF::R_MIPS_PC19_S2: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - FinalAddress) >> 2;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xfff80000) | (calculatedValue & 0x7ffff);
+    break;
+  }
+  case ELF::R_MIPS_PC21_S2: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - FinalAddress) >> 2;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xffe00000) | (calculatedValue & 0x1fffff);
+    break;
+  }
+  case ELF::R_MIPS_PC26_S2: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - FinalAddress) >> 2;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xfc000000) | (calculatedValue & 0x3ffffff);
+    break;
+  }
+  case ELF::R_MIPS_PCHI16: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue =
+        ((Value + Addend - FinalAddress + 0x8000) >> 16) & 0xffff;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xffff0000) | calculatedValue;
+    break;
+  }
+  case ELF::R_MIPS_PCLO16: {
+    uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address
+                                                       + Offset);
+    uint64_t FinalAddress = (Section.LoadAddress + Offset);
+    calculatedValue = (Value + Addend - FinalAddress) & 0xffff;
+    if (applyRelocation)
+      *TargetPtr = ((*TargetPtr) & 0xffff0000) | calculatedValue;
+    break;
+  }
+  }
+}
+
 // Return the .TOC. section and offset.
 void RuntimeDyldELF::findPPC64TOCSection(const ObjectFile &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
case Triple::mipsel:
     resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
                           Type, (uint32_t)(Addend & 0xffffffffL));
     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:
     llvm_unreachable("Unsupported CPU type!");
   }
 }
 
 void *RuntimeDyldELF::computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const {
   return (void*)(Sections[SectionID].ObjAddress + Offset);
if (RelType == ELF::R_MIPS_26) {
       if (RelType == ELF::R_MIPS_HI16)
         Value.Addend += ((*Placeholder) & 0x0000ffff) << 16;
       else if (RelType == ELF::R_MIPS_LO16)
         Value.Addend += ((*Placeholder) & 0x0000ffff);
       else if (RelType == ELF::R_MIPS_32)
         Value.Addend += *Placeholder;
       processSimpleRelocation(SectionID, Offset, RelType, Value);
     }
+  } else if (Arch == Triple::mips64el || Arch == Triple::mips64) {
+    uint32_t r_type = RelType & 0xff;
+    RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
+    if (r_type == ELF::R_MIPS_CALL16 || r_type == ELF::R_MIPS_GOT_PAGE
+        || r_type == ELF::R_MIPS_GOT_DISP) {
+      StringMap<uint64_t>::iterator i = GOTSymbolOffsets.find(TargetName);
+      if (i != GOTSymbolOffsets.end())
+        RE.SymOffset = i->second;
+      else {
+        RE.SymOffset = allocateGOTEntries(SectionID, 1);
+        GOTSymbolOffsets[TargetName] = RE.SymOffset;
+      }
+    }
+    if (Value.SymbolName)
+      addRelocationForSymbol(RE, Value.SymbolName);
+    else
+      addRelocationForSection(RE, Value.SectionID);
   } 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.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);
     break;
   default:
     llvm_unreachable("Unsupported CPU type!");
   }
   return Result;
 }
 
 uint64_t RuntimeDyldELF::allocateGOTEntries(unsigned SectionID, unsigned no)
 {
if (GOTSectionID != 0) {
     Sections[GOTSectionID] = SectionEntry(".got", Addr, TotalSize, 0);
 
     if (Checker)
       Checker->registerSection(Obj.getFileName(), GOTSectionID);
 
     // 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) {
+      unsigned AbiVariant;
+      Obj.getPlatformFlags(AbiVariant);
+      if ((AbiVariant & ELF::EF_MIPS_ABI2) ||
+          (AbiVariant & ELF::EF_MIPS_ABI_O32))
+        llvm_unreachable("N32 ABI and O32 ABI are not supported on Mips64");
+      // To correctly resolve Mips GOT relocations, we need a mapping from
+      // object's sections to GOTs.
+      for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
+           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] = GOTSectionID;
+        }
+      }
+      GOTSymbolOffsets.clear();
+    }
   }
 
   // Look for and record the EH frame section.
   ObjSectionToIDMap::iterator i, e;
   for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
     const SectionRef &Section = i->first;
     StringRef Name;
     Section.getName(Name);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

RuntimeDyld::SymbolInfo getSymbol(StringRef Name) const {
     const auto &SymEntry = pos->second;
     uint64_t TargetAddr =
       getSectionLoadAddress(SymEntry.getSectionID()) + SymEntry.getOffset();
     return RuntimeDyld::SymbolInfo(TargetAddr, SymEntry.getFlags());
   }
 
   void resolveRelocations();
 
+  virtual void resolveMIPS64Relocation(const RelocationList &Relocs,
+                                       uint64_t Value, unsigned RelocId) {
+    llvm_unreachable("Mips64 relocations are only implemented for ELF");
+  }
+
   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; }
 
   // Mark the error condition as handled and continue.

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]");
 }

test/ExecutionEngine/MCJIT/cross-module-sm-pic-a.ll

 ; RUN: %lli -extra-module=%p/Inputs/cross-module-b.ll -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386
+; XFAIL: mips-, mipsel-, i686, i386
 
 declare i32 @FB()
 
 define i32 @FA() {
   ret i32 0
 }
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/MCJIT/eh-lg-pic.ll

 ; RUN: %lli -relocation-model=pic -code-model=large %s
-; XFAIL: cygwin, win32, mingw, mips, i686, i386, aarch64, arm, asan, msan
+; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 

test/ExecutionEngine/MCJIT/eh-sm-pic.ll

 ; RUN: %lli -relocation-model=pic -code-model=small %s
-; XFAIL: cygwin, win32, mingw, mips, i686, i386, darwin, aarch64, arm, asan, msan
+; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, darwin, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 

test/ExecutionEngine/MCJIT/multi-module-sm-pic-a.ll

 ; RUN: %lli -extra-module=%p/Inputs/multi-module-b.ll -extra-module=%p/Inputs/multi-module-c.ll -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386
+; XFAIL: mips-, mipsel-, i686, i386
 
 declare i32 @FB()
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/MCJIT/remote/cross-module-sm-pic-a.ll

 ; RUN: %lli -extra-module=%p/Inputs/cross-module-b.ll -disable-lazy-compilation=true -remote-mcjit -mcjit-remote-process=lli-child-target%exeext -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386, arm
+; XFAIL: mips-, mipsel-, i686, i386, arm
 
 declare i32 @FB()
 
 define i32 @FA() {
   ret i32 0
 }
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/MCJIT/remote/multi-module-sm-pic-a.ll

 ; RUN: %lli -extra-module=%p/Inputs/multi-module-b.ll -extra-module=%p/Inputs/multi-module-c.ll -disable-lazy-compilation=true -remote-mcjit -mcjit-remote-process=lli-child-target%exeext -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386, arm
+; XFAIL: mips-, mipsel-, i686, i386, arm
 
 declare i32 @FB()
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/MCJIT/remote/test-global-init-nonzero-sm-pic.ll

 ; RUN: %lli -remote-mcjit -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @count = global i32 1, align 4
 
 define i32 @main() nounwind uwtable {
 entry:
   %retval = alloca i32, align 4
   %i = alloca i32, align 4
   store i32 0, i32* %retval

test/ExecutionEngine/MCJIT/remote/test-ptr-reloc-sm-pic.ll

 ; RUN: %lli -remote-mcjit -O0 -relocation-model=pic -code-model=small %s
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @.str = private unnamed_addr constant [6 x i8] c"data1\00", align 1
 @ptr = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), align 4
 @.str1 = private unnamed_addr constant [6 x i8] c"data2\00", align 1
 @ptr2 = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 4
 
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind readonly {
 entry:
   %0 = load i8*, i8** @ptr, align 4
   %1 = load i8*, i8** @ptr2, align 4
   %cmp = icmp eq i8* %0, %1
   %. = zext i1 %cmp to i32
   ret i32 %.
 }
 

test/ExecutionEngine/MCJIT/stubs-sm-pic.ll

 ; RUN: %lli -disable-lazy-compilation=false -relocation-model=pic -code-model=small %s
-; XFAIL: mips, i686, i386, aarch64, arm
+; XFAIL: mips-, mipsel-, i686, i386, aarch64, arm
 
 define i32 @main() nounwind {
 entry:
   call void @lazily_compiled_address_is_consistent()
   ret i32 0
 }
 
 ; Test PR3043: @test should have the same address before and after

test/ExecutionEngine/MCJIT/test-global-init-nonzero-sm-pic.ll

 ; RUN: %lli -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @count = global i32 1, align 4
 
 define i32 @main() nounwind uwtable {
 entry:
   %retval = alloca i32, align 4
   %i = alloca i32, align 4
   store i32 0, i32* %retval

test/ExecutionEngine/MCJIT/test-ptr-reloc-sm-pic.ll

 ; RUN: %lli -O0 -relocation-model=pic -code-model=small %s
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @.str = private unnamed_addr constant [6 x i8] c"data1\00", align 1
 @ptr = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), align 4
 @.str1 = private unnamed_addr constant [6 x i8] c"data2\00", align 1
 @ptr2 = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 4
 
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind readonly {
 entry:
   %0 = load i8*, i8** @ptr, align 4
   %1 = load i8*, i8** @ptr2, align 4
   %cmp = icmp eq i8* %0, %1
   %. = zext i1 %cmp to i32
   ret i32 %.
 }
 

test/ExecutionEngine/OrcMCJIT/cross-module-sm-pic-a.ll

 ; RUN: %lli -jit-kind=orc-mcjit -extra-module=%p/Inputs/cross-module-b.ll -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386
+; XFAIL: mips-, mipsel-, i686, i386
 
 declare i32 @FB()
 
 define i32 @FA() {
   ret i32 0
 }
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/OrcMCJIT/eh-lg-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -relocation-model=pic -code-model=large %s
-; XFAIL: cygwin, win32, mingw, mips, i686, i386, aarch64, arm, asan, msan
+; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 

test/ExecutionEngine/OrcMCJIT/eh-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -relocation-model=pic -code-model=small %s
-; XFAIL: cygwin, win32, mingw, mips, i686, i386, darwin, aarch64, arm, asan, msan
+; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, darwin, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 

test/ExecutionEngine/OrcMCJIT/multi-module-sm-pic-a.ll

 ; RUN: %lli -jit-kind=orc-mcjit -extra-module=%p/Inputs/multi-module-b.ll -extra-module=%p/Inputs/multi-module-c.ll -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386
+; XFAIL: mips-, mipsel-, i686, i386
 
 declare i32 @FB()
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/OrcMCJIT/remote/cross-module-sm-pic-a.ll

 ; RUN: %lli -jit-kind=orc-mcjit -extra-module=%p/Inputs/cross-module-b.ll -disable-lazy-compilation=true -remote-mcjit -mcjit-remote-process=lli-child-target%exeext -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386, arm
+; XFAIL: mips-, mipsel-, i686, i386, arm
 
 declare i32 @FB()
 
 define i32 @FA() {
   ret i32 0
 }
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/OrcMCJIT/remote/multi-module-sm-pic-a.ll

 ; RUN: %lli -jit-kind=orc-mcjit -extra-module=%p/Inputs/multi-module-b.ll -extra-module=%p/Inputs/multi-module-c.ll -disable-lazy-compilation=true -remote-mcjit -mcjit-remote-process=lli-child-target%exeext -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, i686, i386, arm
+; XFAIL: mips-, mipsel-, i686, i386, arm
 
 declare i32 @FB()
 
 define i32 @main() {
   %r = call i32 @FB( )   ; <i32> [#uses=1]
   ret i32 %r
 }
 

test/ExecutionEngine/OrcMCJIT/remote/test-global-init-nonzero-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -remote-mcjit -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @count = global i32 1, align 4
 
 define i32 @main() nounwind uwtable {
 entry:
   %retval = alloca i32, align 4
   %i = alloca i32, align 4
   store i32 0, i32* %retval

test/ExecutionEngine/OrcMCJIT/remote/test-ptr-reloc-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -remote-mcjit -O0 -relocation-model=pic -code-model=small %s
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @.str = private unnamed_addr constant [6 x i8] c"data1\00", align 1
 @ptr = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), align 4
 @.str1 = private unnamed_addr constant [6 x i8] c"data2\00", align 1
 @ptr2 = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 4
 
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind readonly {
 entry:
   %0 = load i8*, i8** @ptr, align 4
   %1 = load i8*, i8** @ptr2, align 4
   %cmp = icmp eq i8* %0, %1
   %. = zext i1 %cmp to i32
   ret i32 %.
 }
 

test/ExecutionEngine/OrcMCJIT/stubs-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -disable-lazy-compilation=false -relocation-model=pic -code-model=small %s
-; XFAIL: mips, i686, i386, aarch64, arm
+; XFAIL: mips-, mipsel-, i686, i386, aarch64, arm
 
 define i32 @main() nounwind {
 entry:
   call void @lazily_compiled_address_is_consistent()
   ret i32 0
 }
 
 ; Test PR3043: @test should have the same address before and after

test/ExecutionEngine/OrcMCJIT/test-global-init-nonzero-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -relocation-model=pic -code-model=small %s > /dev/null
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @count = global i32 1, align 4
 
 define i32 @main() nounwind uwtable {
 entry:
   %retval = alloca i32, align 4
   %i = alloca i32, align 4
   store i32 0, i32* %retval

test/ExecutionEngine/OrcMCJIT/test-ptr-reloc-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -O0 -relocation-model=pic -code-model=small %s
-; XFAIL: mips, aarch64, arm, i686, i386
+; XFAIL: mips-, mipsel-, aarch64, arm, i686, i386
 
 @.str = private unnamed_addr constant [6 x i8] c"data1\00", align 1
 @ptr = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), align 4
 @.str1 = private unnamed_addr constant [6 x i8] c"data2\00", align 1
 @ptr2 = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 4
 
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind readonly {
 entry:
   %0 = load i8*, i8** @ptr, align 4
   %1 = load i8*, i8** @ptr2, align 4
   %cmp = icmp eq i8* %0, %1
   %. = zext i1 %cmp to i32
   ret i32 %.
 }
 

test/ExecutionEngine/RuntimeDyld/Mips/ELF_Mips64N64_PIC_relocations.s

+# RUN: llvm-mc -triple=mips64el-unknown-linux -relocation-model=pic -code-model=small -filetype=obj -o %T/test_ELF_Mips64N64.o %s
+# RUN: llvm-rtdyld -triple=mips64el-unknown-linux -verify -check=%s %/T/test_ELF_Mips64N64.o
+
+  .file "ELF_Mips64N64_PIC_relocations.ll"
+  .text
+  .globl  bar
+  .align  3
+  .type bar,@function
+  .set  nomicromips
+  .set  nomips16
+  .ent  bar
+bar:                                    # @bar
+  .frame  $sp,0,$ra
+  .mask   0x00000000,0
+  .fmask  0x00000000,0
+  .set  noreorder
+  .set  nomacro
+  .set  noat
+# BB#0:
+  jr  $ra
+  addiu $2, $zero, 0
+  .set  at
+  .set  macro
+  .set  reorder
+  .end  bar
+$func_end0:
+  .size bar, ($func_end0)-bar
+
+  .globl  main
+  .align  3
+  .type main,@function
+  .set  nomicromips
+  .set  nomips16
+  .ent  main
+main:                                   # @main
+  .frame  $sp,16,$ra
+  .mask   0x00000000,0
+  .fmask  0x00000000,0
+  .set  noreorder
+  .set  nomacro
+  .set  noat
+# BB#0:
+  daddiu  $sp, $sp, -16
+$tmp0:
+  sd  $ra, 8($sp)
+  sd  $gp, 0($sp)
+
+# Check upper 16-bits of offset between the address of main function
+# and the global offset table.
+# rtdyld-check:  decode_operand(inst1, 1)[15:0] = ((section_addr(test_ELF_Mips64N64.o, .got) + 0x7ff0) - main + 0x8000)[31:16]
+inst1:
+  lui  $1, %hi(%neg(%gp_rel(main)))
+  daddu $1, $1, $25
+
+# Check lower 16-bits of offset between the address of main function
+# and the global offset table.
+# rtdyld-check:  decode_operand(inst2, 2)[15:0] = ((section_addr(test_ELF_Mips64N64.o, .got) + 0x7ff0) - main)[15:0]
+inst2:
+  daddiu  $gp, $1, %lo(%neg(%gp_rel(main)))
+
+# $gp register contains address of the .got section + 0x7FF0. 0x7FF0 is
+# the offset of $gp from the beginning of the .got section. Check that we are
+# loading address of bar from correct offset. In this case bar is
+# the first entry in the .got section, so offset will be 0 - 0x7FF0.
+# rtdyld-check:  decode_operand(inst3, 2)[15:0] = 0x8010
+#
+# Check that the address of the bar is at the beginning of the
+# global offset table
+# rtdyld-check: *{8}(section_addr(test_ELF_Mips64N64.o, .got)) = bar
+inst3:
+  ld  $25, %call16(bar)($gp)
+  jalr  $25
+  nop
+  ld  $gp, 0($sp)
+  ld  $ra, 8($sp)
+  jr  $ra
+  daddiu  $sp, $sp, 16
+  .set  at
+  .set  macro
+  .set  reorder
+  .end  main
+$func_end1:
+  .size main, ($func_end1)-main
+
+
+  .section  ".note.GNU-stack","",@progbits

test/ExecutionEngine/RuntimeDyld/Mips/lit.local.cfg

+if not 'Mips' in config.root.targets:
+    config.unsupported = True
+

unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

 protected:
   MCJITCAPITest() {
     // The architectures below are known to be compatible with MCJIT as they
     // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
     // kept in sync.
     SupportedArchs.push_back(Triple::aarch64);
     SupportedArchs.push_back(Triple::arm);
     SupportedArchs.push_back(Triple::mips);
+    SupportedArchs.push_back(Triple::mips64);
+    SupportedArchs.push_back(Triple::mips64el);
     SupportedArchs.push_back(Triple::x86);
     SupportedArchs.push_back(Triple::x86_64);
 
     // Some architectures have sub-architectures in which tests will fail, like
     // ARM. These two vectors will define if they do have sub-archs (to avoid
     // extra work for those who don't), and if so, if they are listed to work
     HasSubArchs.push_back(Triple::arm);
     SupportedSubArchs.push_back("armv6");

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

MCJITTestBase()
     : TrivialModuleBuilder(HostTriple)
     , OptLevel(CodeGenOpt::None)
     , RelocModel(Reloc::Default)
     , CodeModel(CodeModel::Default)
     , MArch("")
     , MM(new SectionMemoryManager)
   {
     // The architectures below are known to be compatible with MCJIT as they
     // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
     // kept in sync.
     SupportedArchs.push_back(Triple::aarch64);
     SupportedArchs.push_back(Triple::arm);
     SupportedArchs.push_back(Triple::mips);
     SupportedArchs.push_back(Triple::mipsel);
+    SupportedArchs.push_back(Triple::mips64);
+    SupportedArchs.push_back(Triple::mips64el);
     SupportedArchs.push_back(Triple::x86);
     SupportedArchs.push_back(Triple::x86_64);
 
     // Some architectures have sub-architectures in which tests will fail, like
     // ARM. These two vectors will define if they do have sub-archs (to avoid
     // extra work for those who don't), and if so, if they are listed to work
     HasSubArchs.push_back(Triple::arm);
     SupportedSubArchs.push_back("armv6");