lib/Target/PowerPC/PPCJITInfo.cpp

   1 //===-- PPCJITInfo.cpp - Implement the JIT interfaces for the PowerPC -----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the JIT interfaces for the 32-bit PowerPC target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "jit"
  15 #include "PPCJITInfo.h"
  16 #include "PPCRelocations.h"
  17 #include "llvm/CodeGen/MachineCodeEmitter.h"
  18 #include "llvm/Config/alloca.h"
  19 #include "llvm/Support/Debug.h"
  20 #include <set>
  21 #include <iostream>
  22 using namespace llvm;
  23
  24 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
  25
  26 #define BUILD_ADDIS(RD,RS,IMM16) \
  27   ((15 << 26) | ((RD) << 21) | ((RS) << 16) | ((IMM16) & 65535))
  28 #define BUILD_ORI(RD,RS,UIMM16) \
  29   ((24 << 26) | ((RS) << 21) | ((RD) << 16) | ((UIMM16) & 65535))
  30 #define BUILD_MTSPR(RS,SPR)      \
  31   ((31 << 26) | ((RS) << 21) | ((SPR) << 16) | (467 << 1))
  32 #define BUILD_BCCTRx(BO,BI,LINK) \
  33   ((19 << 26) | ((BO) << 21) | ((BI) << 16) | (528 << 1) | ((LINK) & 1))
  34
  35 // Pseudo-ops
  36 #define BUILD_LIS(RD,IMM16)    BUILD_ADDIS(RD,0,IMM16)
  37 #define BUILD_MTCTR(RS)        BUILD_MTSPR(RS,9)
  38 #define BUILD_BCTR(LINK)       BUILD_BCCTRx(20,0,LINK)
  39
  40
  41 static void EmitBranchToAt(void *At, void *To, bool isCall) {
  42   intptr_t Addr = (intptr_t)To;
  43
  44   // FIXME: should special case the short branch case.
  45   unsigned *AtI = (unsigned*)At;
  46
  47   AtI[0] = BUILD_LIS(12, Addr >> 16);   // lis r12, hi16(address)
  48   AtI[1] = BUILD_ORI(12, 12, Addr);     // ori r12, r12, low16(address)
  49   AtI[2] = BUILD_MTCTR(12);             // mtctr r12
  50   AtI[3] = BUILD_BCTR(isCall);          // bctr/bctrl
  51 }
  52
  53 extern "C" void PPC32CompilationCallback();
  54
  55 #if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)
  56 // CompilationCallback stub - We can't use a C function with inline assembly in
  57 // it, because we the prolog/epilog inserted by GCC won't work for us.  Instead,
  58 // write our own wrapper, which does things our way, so we have complete control
  59 // over register saving and restoring.
  60 asm(
  61     ".text\n"
  62     ".align 2\n"
  63     ".globl _PPC32CompilationCallback\n"
  64 "_PPC32CompilationCallback:\n"
  65     // Make space for 8 ints r[3-10] and 13 doubles f[1-13] and the
  66     // FIXME: need to save v[0-19] for altivec?
  67     // Set up a proper stack frame
  68     "stwu r1, -208(r1)\n"
  69     "mflr r0\n"
  70     "stw r0,  216(r1)\n"
  71     // Save all int arg registers
  72     "stw r10, 204(r1)\n"    "stw r9,  200(r1)\n"
  73     "stw r8,  196(r1)\n"    "stw r7,  192(r1)\n"
  74     "stw r6,  188(r1)\n"    "stw r5,  184(r1)\n"
  75     "stw r4,  180(r1)\n"    "stw r3,  176(r1)\n"
  76     // Save all call-clobbered FP regs.
  77     "stfd f13, 168(r1)\n"   "stfd f12, 160(r1)\n"
  78     "stfd f11, 152(r1)\n"   "stfd f10, 144(r1)\n"
  79     "stfd f9,  136(r1)\n"   "stfd f8,  128(r1)\n"
  80     "stfd f7,  120(r1)\n"   "stfd f6,  112(r1)\n"
  81     "stfd f5,  104(r1)\n"   "stfd f4,   96(r1)\n"
  82     "stfd f3,   88(r1)\n"   "stfd f2,   80(r1)\n"
  83     "stfd f1,   72(r1)\n"
  84     // Arguments to Compilation Callback:
  85     // r3 - our lr (address of the call instruction in stub plus 4)
  86     // r4 - stub's lr (address of instruction that called the stub plus 4)
  87     "mr   r3, r0\n"
  88     "lwz  r2, 208(r1)\n" // stub's frame
  89     "lwz  r4, 8(r2)\n" // stub's lr
  90     "bl _PPC32CompilationCallbackC\n"
  91     "mtctr r3\n"
  92     // Restore all int arg registers
  93     "lwz r10, 204(r1)\n"    "lwz r9,  200(r1)\n"
  94     "lwz r8,  196(r1)\n"    "lwz r7,  192(r1)\n"
  95     "lwz r6,  188(r1)\n"    "lwz r5,  184(r1)\n"
  96     "lwz r4,  180(r1)\n"    "lwz r3,  176(r1)\n"
  97     // Restore all FP arg registers
  98     "lfd f13, 168(r1)\n"    "lfd f12, 160(r1)\n"
  99     "lfd f11, 152(r1)\n"    "lfd f10, 144(r1)\n"
 100     "lfd f9,  136(r1)\n"    "lfd f8,  128(r1)\n"
 101     "lfd f7,  120(r1)\n"    "lfd f6,  112(r1)\n"
 102     "lfd f5,  104(r1)\n"    "lfd f4,   96(r1)\n"
 103     "lfd f3,   88(r1)\n"    "lfd f2,   80(r1)\n"
 104     "lfd f1,   72(r1)\n"
 105     // Pop 3 frames off the stack and branch to target
 106     "lwz  r1, 208(r1)\n"
 107     "lwz  r2, 8(r1)\n"
 108     "mtlr r2\n"
 109     "bctr\n"
 110     );
 111 #else
 112 void PPC32CompilationCallback() {
 113   assert(0 && "This is not a power pc, you can't execute this!");
 114   abort();
 115 }
 116 #endif
 117
 118 extern "C" unsigned *PPC32CompilationCallbackC(unsigned *StubCallAddrPlus4,
 119                                                unsigned *OrigCallAddrPlus4) {
 120   // Adjust the pointer to the address of the call instruction in the stub
 121   // emitted by emitFunctionStub, rather than the instruction after it.
 122   unsigned *StubCallAddr = StubCallAddrPlus4 - 1;
 123   unsigned *OrigCallAddr = OrigCallAddrPlus4 - 1;
 124
 125   void *Target = JITCompilerFunction(StubCallAddr);
 126
 127   // Check to see if *OrigCallAddr is a 'bl' instruction, and if we can rewrite
 128   // it to branch directly to the destination.  If so, rewrite it so it does not
 129   // need to go through the stub anymore.
 130   unsigned OrigCallInst = *OrigCallAddr;
 131   if ((OrigCallInst >> 26) == 18) {     // Direct call.
 132     intptr_t Offset = ((intptr_t)Target - (intptr_t)OrigCallAddr) >> 2;
 133
 134     if (Offset >= -(1 << 23) && Offset < (1 << 23)) {   // In range?
 135       // Clear the original target out.
 136       OrigCallInst &= (63 << 26) | 3;
 137       // Fill in the new target.
 138       OrigCallInst |= (Offset & ((1 << 24)-1)) << 2;
 139       // Replace the call.
 140       *OrigCallAddr = OrigCallInst;
 141     }
 142   }
 143
 144   // Assert that we are coming from a stub that was created with our
 145   // emitFunctionStub.
 146   assert((*StubCallAddr >> 26) == 19 && "Call in stub is not indirect!");
 147   StubCallAddr -= 6;
 148
 149   // Rewrite the stub with an unconditional branch to the target, for any users
 150   // who took the address of the stub.
 151   EmitBranchToAt(StubCallAddr, Target, false);
 152
 153   // Put the address of the target function to call and the address to return to
 154   // after calling the target function in a place that is easy to get on the
 155   // stack after we restore all regs.
 156   return (unsigned *)Target;
 157 }
 158
 159
 160
 161 TargetJITInfo::LazyResolverFn
 162 PPCJITInfo::getLazyResolverFunction(JITCompilerFn Fn) {
 163   JITCompilerFunction = Fn;
 164   return PPC32CompilationCallback;
 165 }
 166
 167 void *PPCJITInfo::emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
 168   // If this is just a call to an external function, emit a branch instead of a
 169   // call.  The code is the same except for one bit of the last instruction.
 170   if (Fn != (void*)(intptr_t)PPC32CompilationCallback) {
 171     MCE.startFunctionStub(4*4);
 172     void *Addr = (void*)(intptr_t)MCE.getCurrentPCValue();
 173     MCE.emitWordBE(0);
 174     MCE.emitWordBE(0);
 175     MCE.emitWordBE(0);
 176     MCE.emitWordBE(0);
 177     EmitBranchToAt(Addr, Fn, false);
 178     return MCE.finishFunctionStub(0);
 179   }
 180
 181   MCE.startFunctionStub(4*7);
 182   MCE.emitWordBE(0x9421ffe0);     // stwu    r1,-32(r1)
 183   MCE.emitWordBE(0x7d6802a6);     // mflr r11
 184   MCE.emitWordBE(0x91610028);     // stw r11, 40(r1)
 185   void *Addr = (void*)(intptr_t)MCE.getCurrentPCValue();
 186   MCE.emitWordBE(0);
 187   MCE.emitWordBE(0);
 188   MCE.emitWordBE(0);
 189   MCE.emitWordBE(0);
 190   EmitBranchToAt(Addr, Fn, true/*is call*/);
 191   return MCE.finishFunctionStub(0);
 192 }
 193
 194
 195 void PPCJITInfo::relocate(void *Function, MachineRelocation *MR,
 196                           unsigned NumRelocs, unsigned char* GOTBase) {
 197   for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
 198     unsigned *RelocPos = (unsigned*)Function + MR->getMachineCodeOffset()/4;
 199     intptr_t ResultPtr = (intptr_t)MR->getResultPointer();
 200     switch ((PPC::RelocationType)MR->getRelocationType()) {
 201     default: assert(0 && "Unknown relocation type!");
 202     case PPC::reloc_pcrel_bx:
 203       // PC-relative relocation for b and bl instructions.
 204       ResultPtr = (ResultPtr-(intptr_t)RelocPos) >> 2;
 205       assert(ResultPtr >= -(1 << 23) && ResultPtr < (1 << 23) &&
 206              "Relocation out of range!");
 207       *RelocPos |= (ResultPtr & ((1 << 24)-1))  << 2;
 208       break;
 209     case PPC::reloc_pcrel_bcx:
 210       // PC-relative relocation for BLT,BLE,BEQ,BGE,BGT,BNE, or other
 211       // bcx instructions.
 212       ResultPtr = (ResultPtr-(intptr_t)RelocPos) >> 2;
 213       assert(ResultPtr >= -(1 << 13) && ResultPtr < (1 << 13) &&
 214              "Relocation out of range!");
 215       *RelocPos |= (ResultPtr & ((1 << 14)-1))  << 2;
 216       break;
 217     case PPC::reloc_absolute_ptr_high: // Pointer relocations.
 218     case PPC::reloc_absolute_ptr_low:
 219     case PPC::reloc_absolute_high:     // high bits of ref -> low 16 of instr
 220     case PPC::reloc_absolute_low: {    // low bits of ref  -> low 16 of instr
 221       ResultPtr += MR->getConstantVal();
 222
 223       // If this is a high-part access, get the high-part.
 224       if (MR->getRelocationType() == PPC::reloc_absolute_high ||
 225           MR->getRelocationType() == PPC::reloc_absolute_ptr_high) {
 226         // If the low part will have a carry (really a borrow) from the low
 227         // 16-bits into the high 16, add a bit to borrow from.
 228         if (((int)ResultPtr << 16) < 0)
 229           ResultPtr += 1 << 16;
 230         ResultPtr >>= 16;
 231       }
 232
 233       // Do the addition then mask, so the addition does not overflow the 16-bit
 234       // immediate section of the instruction.
 235       unsigned LowBits  = (*RelocPos + ResultPtr) & 65535;
 236       unsigned HighBits = *RelocPos & ~65535;
 237       *RelocPos = LowBits | HighBits;  // Slam into low 16-bits
 238       break;
 239     }
 240     case PPC::reloc_absolute_low_ix: {  // low bits of ref  -> low 14 of instr
 241       ResultPtr += MR->getConstantVal();
 242       // Do the addition then mask, so the addition does not overflow the 16-bit
 243       // immediate section of the instruction.
 244       unsigned LowBits  = (*RelocPos + ResultPtr) & 0xFFFC;
 245       unsigned HighBits = *RelocPos & 0xFFFF0003;
 246       *RelocPos = LowBits | HighBits;  // Slam into low 14-bits.
 247       break;
 248     }
 249     }
 250   }
 251 }
 252
 253 void PPCJITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
 254   EmitBranchToAt(Old, New, false);
 255 }