[ORC][MIPS] Setup t9 register and call function through this register

[atanasyan]

Summary

MIPS ABI states that every function must be called through jalr $t9. In other words, a function expect that t9 register points to the beginning of its code. A function uses this register to calculate offset to the Global Offset Table and save it to the gp register.

lui   $gp, %hi(_gp_disp)
addiu $gp, %lo(_gp_disp)
addu  $gp, $gp, $t9

If t9 and as a result $gp point to the wrong place the following code loads incorrect value from GOT and passes control to invalid code.

lw    $v0,%call16(foo)($gp)
jalr  $t9

OrcMips32 and OrcMips64 writeResolverCode methods pass control to the resolved address, but do not setup $t9 before the call. The t9 holds value of the beginning of resolver code so any attempts to call routines via GOT failed.

This change fixes the problem. The OrcLazy/hidden-visibility.ll test starts to pass correctly. Before the change it fails on MIPS because the exitOnLazyCallThroughFailure called from the resolver code could not call libc routine exit via GOT.

[atanasyan]

Gentle ping...

[atanasyan]

Gentle ping...

[erceg95]

Sorry for delay, it looks good to me.

[atanasyan]

Thanks for review.

llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcABISupport.h

 
 // @brief Mips32 support.
 //
 // Mips32 supports lazy JITing.
 class OrcMips32_Base {
 public:
   static const unsigned PointerSize = 4;
   static const unsigned TrampolineSize = 20;
-  static const unsigned ResolverCodeSize = 0xf8;
+  static const unsigned ResolverCodeSize = 0xfc;
   using IndirectStubsInfo = GenericIndirectStubsInfo<16>;
 
   using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
                                             void *TrampolineId);
   /// @brief Write the requsted number of trampolines into the given memory,
   ///        which must be big enough to hold 1 pointer, plus NumTrampolines
   ///        trampolines.
   static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,unsigned NumTrampolines);

 
 // @brief Mips64 support.
 //
 // Mips64 supports lazy JITing.
 class OrcMips64 {
 public:
   static const unsigned PointerSize = 8;
   static const unsigned TrampolineSize = 40;
-  static const unsigned ResolverCodeSize = 0x11C;
+  static const unsigned ResolverCodeSize = 0x120;
 
   using IndirectStubsInfo = GenericIndirectStubsInfo<32>;
   using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
                                             void *TrampolineId);
   /// @brief Write the resolver code into the given memory. The user is be
   ///        responsible for allocating the memory and setting permissions.
   static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr);
 

llvm/trunk/lib/ExecutionEngine/Orc/OrcABISupport.cpp

const uint32_t ResolverCode[] = {
       0x8fb1001c,                    // 0xd4: lw $s1,28($sp)
       0x8fb00018,                    // 0xd8: lw $s0,24($sp)
       0x8fa70014,                    // 0xdc: lw $a3,20($sp)
       0x8fa60010,                    // 0xe0: lw $a2,16($sp)
       0x8fa5000c,                    // 0xe4: lw $a1,12($sp)
       0x8fa40008,                    // 0xe8: lw $a0,8($sp)
       0x27bd0068,                    // 0xec: addiu $sp,$sp,104
       0x0300f825,                    // 0xf0: move $ra, $t8
-      0x00000000                     // 0xf4: jr $v0/v1
+      0x00000000,                    // 0xf4: move $t9, $v0/v1
+      0x03200008                     // 0xf8: jr $t9
   };
 
   const unsigned ReentryFnAddrOffset = 0x7c;   // JIT re-entry fn addr lui
   const unsigned CallbackMgrAddrOffset = 0x6c; // Callback manager addr lui
-  const unsigned offsett = 0xf4;
+  const unsigned Offsett = 0xf4;
 
   memcpy(ResolverMem, ResolverCode, sizeof(ResolverCode));
 
-  //Depending on endian return value will be in v0 or v1.
-  uint32_t JumpV0 = 0x00400008;
-  uint32_t JumpV1 = 0x00600008;
-
-  if(isBigEndian == true)
-    memcpy(ResolverMem + offsett, &JumpV1, sizeof(JumpV1));
-  else
-    memcpy(ResolverMem + offsett, &JumpV0, sizeof(JumpV0));
+  // Depending on endian return value will be in v0 or v1.
+  uint32_t MoveVxT9 = isBigEndian ? 0x0060c825 : 0x0040c825;
+  memcpy(ResolverMem + Offsett, &MoveVxT9, sizeof(MoveVxT9));
 
   uint64_t CallMgrAddr = reinterpret_cast<uint64_t>(CallbackMgr);
   uint32_t CallMgrLUi = 0x3c040000 | (((CallMgrAddr + 0x8000) >> 16) & 0xFFFF);
   uint32_t CallMgrADDiu = 0x24840000 | ((CallMgrAddr) & 0xFFFF);
   memcpy(ResolverMem + CallbackMgrAddrOffset, &CallMgrLUi, sizeof(CallMgrLUi));
   memcpy(ResolverMem + CallbackMgrAddrOffset + 4, &CallMgrADDiu,
          sizeof(CallMgrADDiu));
 
const uint32_t ResolverCode[] = {
       0xdfa80030,                     // 0xf8: ld a4, 48(sp)
       0xdfa70028,                     // 0xfc: ld a3, 40(sp)
       0xdfa60020,                     // 0x100: ld a2, 32(sp)
       0xdfa50018,                     // 0x104: ld a1, 24(sp)
       0xdfa40010,                     // 0x108: ld a0, 16(sp)
       0xdfa30008,                     // 0x10c: ld v1, 8(sp)
       0x67bd00d0,                     // 0x110: daddiu $sp,$sp,208
       0x0300f825,                     // 0x114: move $ra, $t8
-      0x00400008                      // 0x118: jr $v0
+      0x0040c825,                     // 0x118: move $t9, $v0
+      0x03200008                      // 0x11c: jr $t9
   };
 
   const unsigned ReentryFnAddrOffset = 0x8c;   // JIT re-entry fn addr lui
   const unsigned CallbackMgrAddrOffset = 0x6c; // Callback manager addr lui
 
   memcpy(ResolverMem, ResolverCode, sizeof(ResolverCode));
 
   uint64_t CallMgrAddr = reinterpret_cast<uint64_t>(CallbackMgr);