1 //===-- PPC32JITInfo.cpp - Implement the JIT interfaces for the PowerPC ---===//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This file implements the JIT interfaces for the 32-bit PowerPC target.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "jit"
15 #include "PPC32JITInfo.h"
16 #include "PPC32Relocations.h"
17 #include "llvm/CodeGen/MachineCodeEmitter.h"
18 #include "llvm/Config/alloca.h"
22 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
24 #define BUILD_ADDIS(RD,RS,IMM16) \
25 ((15 << 26) | ((RD) << 21) | ((RS) << 16) | ((IMM16) & 65535))
26 #define BUILD_ORI(RD,RS,UIMM16) \
27 ((24 << 26) | ((RS) << 21) | ((RD) << 16) | ((UIMM16) & 65535))
28 #define BUILD_MTSPR(RS,SPR) \
29 ((31 << 26) | ((RS) << 21) | ((SPR) << 16) | (467 << 1))
30 #define BUILD_BCCTRx(BO,BI,LINK) \
31 ((19 << 26) | ((BO) << 21) | ((BI) << 16) | (528 << 1) | ((LINK) & 1))
34 #define BUILD_LIS(RD,IMM16) BUILD_ADDIS(RD,0,IMM16)
35 #define BUILD_MTCTR(RS) BUILD_MTSPR(RS,9)
36 #define BUILD_BCTR(LINK) BUILD_BCCTRx(20,0,LINK)
39 static void EmitBranchToAt(void *At, void *To, bool isCall) {
40 intptr_t Addr = (intptr_t)To;
42 // FIXME: should special case the short branch case.
43 unsigned *AtI = (unsigned*)At;
45 AtI[0] = BUILD_LIS(12, Addr >> 16); // lis r12, hi16(address)
46 AtI[1] = BUILD_ORI(12, 12, Addr); // ori r12, r12, low16(address)
47 AtI[2] = BUILD_MTCTR(12); // mtctr r12
48 AtI[3] = BUILD_BCTR(isCall); // bctr/bctrl
51 extern "C" void PPC32CompilationCallback();
53 #if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)
54 // CompilationCallback stub - We can't use a C function with inline assembly in
55 // it, because we the prolog/epilog inserted by GCC won't work for us. Instead,
56 // write our own wrapper, which does things our way, so we have complete control
57 // over register saving and restoring.
61 ".globl _PPC32CompilationCallback\n"
62 "_PPC32CompilationCallback:\n"
63 // Make space for 29 ints r[3-31] and 14 doubles f[0-13]
66 "stw r11, 280(r1)\n" // Set up a proper stack frame
67 "stmw r3, 156(r1)\n" // Save all of the integer registers
68 // Save all call-clobbered FP regs.
69 "stfd f1, 44(r1)\n" "stfd f2, 52(r1)\n" "stfd f3, 60(r1)\n"
70 "stfd f4, 68(r1)\n" "stfd f5, 76(r1)\n" "stfd f6, 84(r1)\n"
71 "stfd f7, 92(r1)\n" "stfd f8, 100(r1)\n" "stfd f9, 108(r1)\n"
72 "stfd f10, 116(r1)\n" "stfd f11, 124(r1)\n" "stfd f12, 132(r1)\n"
75 // Now that everything is saved, go to the C compilation callback function,
76 // passing the address of the intregs and fpregs.
77 "addi r3, r1, 156\n" // &IntRegs[0]
78 "addi r4, r1, 44\n" // &FPRegs[0]
79 "bl _PPC32CompilationCallbackC\n"
82 void PPC32CompilationCallback() {
83 assert(0 && "This is not a power pc, you can't execute this!");
88 extern "C" void PPC32CompilationCallbackC(unsigned *IntRegs, double *FPRegs) {
89 unsigned *CameFromStub = (unsigned*)__builtin_return_address(0+1);
90 unsigned *CameFromOrig = (unsigned*)__builtin_return_address(1+1);
91 unsigned *CCStackPtr = (unsigned*)__builtin_frame_address(0);
92 //unsigned *StubStackPtr = (unsigned*)__builtin_frame_address(1);
93 unsigned *OrigStackPtr = (unsigned*)__builtin_frame_address(2+1);
95 // Adjust pointer to the branch, not the return address.
98 void *Target = JITCompilerFunction(CameFromStub);
100 // Check to see if CameFromOrig[-1] is a 'bl' instruction, and if we can
101 // rewrite it to branch directly to the destination. If so, rewrite it so it
102 // does not need to go through the stub anymore.
103 unsigned CameFromOrigInst = CameFromOrig[-1];
104 if ((CameFromOrigInst >> 26) == 18) { // Direct call.
105 intptr_t Offset = ((intptr_t)Target-(intptr_t)CameFromOrig+4) >> 2;
106 if (Offset >= -(1 << 23) && Offset < (1 << 23)) { // In range?
107 // Clear the original target out.
108 CameFromOrigInst &= (63 << 26) | 3;
109 // Fill in the new target.
110 CameFromOrigInst |= (Offset & ((1 << 24)-1)) << 2;
112 CameFromOrig[-1] = CameFromOrigInst;
116 // Locate the start of the stub. If this is a short call, adjust backwards
117 // the short amount, otherwise the full amount.
118 bool isShortStub = (*CameFromStub >> 26) == 18;
119 CameFromStub -= isShortStub ? 2 : 6;
121 // Rewrite the stub with an unconditional branch to the target, for any users
122 // who took the address of the stub.
123 EmitBranchToAt(CameFromStub, Target, false);
125 // Change the SP so that we pop two stack frames off when we return.
126 *CCStackPtr = (intptr_t)OrigStackPtr;
128 // Put the address of the stub and the LR value that originally came into the
129 // stub in a place that is easy to get on the stack after we restore all regs.
130 CCStackPtr[2] = (intptr_t)Target;
131 CCStackPtr[1] = (intptr_t)CameFromOrig;
133 // Note, this is not a standard epilog!
134 #if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)
135 register unsigned *IRR asm ("r2") = IntRegs;
136 register double *FRR asm ("r3") = FPRegs;
137 __asm__ __volatile__ (
138 "lfd f1, 0(%0)\n" "lfd f2, 8(%0)\n" "lfd f3, 16(%0)\n"
139 "lfd f4, 24(%0)\n" "lfd f5, 32(%0)\n" "lfd f6, 40(%0)\n"
140 "lfd f7, 48(%0)\n" "lfd f8, 56(%0)\n" "lfd f9, 64(%0)\n"
141 "lfd f10, 72(%0)\n" "lfd f11, 80(%0)\n" "lfd f12, 88(%0)\n"
143 "lmw r3, 0(%1)\n" // Load all integer regs
144 "lwz r0,4(r1)\n" // Get CameFromOrig (LR into stub)
145 "mtlr r0\n" // Put it in the LR register
146 "lwz r0,8(r1)\n" // Get target function pointer
147 "mtctr r0\n" // Put it into the CTR register
148 "lwz r1,0(r1)\n" // Pop two frames off
149 "bctr\n" :: // Return to stub!
150 "b" (FRR), "b" (IRR));
156 TargetJITInfo::LazyResolverFn
157 PPC32JITInfo::getLazyResolverFunction(JITCompilerFn Fn) {
158 JITCompilerFunction = Fn;
159 return PPC32CompilationCallback;
162 void *PPC32JITInfo::emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
163 // If this is just a call to an external function, emit a branch instead of a
164 // call. The code is the same except for one bit of the last instruction.
165 if (Fn != PPC32CompilationCallback) {
166 MCE.startFunctionStub(4*4);
167 void *Addr = (void*)(intptr_t)MCE.getCurrentPCValue();
172 EmitBranchToAt(Addr, Fn, false);
173 return MCE.finishFunctionStub(0);
176 MCE.startFunctionStub(4*7);
177 MCE.emitWord(0x9421ffe0); // stwu r1,-32(r1)
178 MCE.emitWord(0x7d6802a6); // mflr r11
179 MCE.emitWord(0x91610028); // stw r11, 40(r1)
180 void *Addr = (void*)(intptr_t)MCE.getCurrentPCValue();
185 EmitBranchToAt(Addr, Fn, true/*is call*/);
186 return MCE.finishFunctionStub(0);
190 void PPC32JITInfo::relocate(void *Function, MachineRelocation *MR,
191 unsigned NumRelocs) {
192 for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
193 unsigned *RelocPos = (unsigned*)Function + MR->getMachineCodeOffset()/4;
194 intptr_t ResultPtr = (intptr_t)MR->getResultPointer();
195 switch ((PPC::RelocationType)MR->getRelocationType()) {
196 default: assert(0 && "Unknown relocation type!");
197 case PPC::reloc_pcrel_bx:
198 // PC-relative relocation for b and bl instructions.
199 ResultPtr = (ResultPtr-(intptr_t)RelocPos) >> 2;
200 assert(ResultPtr >= -(1 << 23) && ResultPtr < (1 << 23) &&
201 "Relocation out of range!");
202 *RelocPos |= (ResultPtr & ((1 << 24)-1)) << 2;
205 case PPC::reloc_absolute_ptr_high: // Pointer relocations.
206 case PPC::reloc_absolute_ptr_low: {
207 // Pointer relocations are used for the PPC external stubs and lazy
208 // resolver pointers that the Darwin ABI likes to use. Basically, the
209 // address of the global is actually stored in memory, and the address of
210 // the pointer is relocated into instructions instead of the pointer
211 // itself. Because we have to keep the mapping anyway, we just return
212 // pointers to the values in the map as our new location.
213 static std::set<void*> Pointers;
214 ResultPtr = (intptr_t)&*Pointers.insert((void*)ResultPtr).first;
217 case PPC::reloc_absolute_high: // high bits of ref -> low 16 of instr
218 case PPC::reloc_absolute_low: // low bits of ref -> low 16 of instr
219 ResultPtr += MR->getConstantVal();
221 // If this is a high-part access, get the high-part.
222 if (MR->getRelocationType() == PPC::reloc_absolute_high ||
223 MR->getRelocationType() == PPC::reloc_absolute_ptr_high) {
224 // If the low part will have a carry (really a borrow) from the low
225 // 16-bits into the high 16, add a bit to borrow from.
226 if (((int)ResultPtr << 16) < 0)
227 ResultPtr += 1 << 16;
231 // Do the addition then mask, so the addition does not overflow the 16-bit
232 // immediate section of the instruction.
233 unsigned LowBits = (*RelocPos + ResultPtr) & 65535;
234 unsigned HighBits = *RelocPos & ~65535;
235 *RelocPos = LowBits | HighBits; // Slam into low 16-bits
241 void PPC32JITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
242 EmitBranchToAt(Old, New, false);