Nate Begeman | 6cca84e | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 1 | //===-- PPCJITInfo.cpp - Implement the JIT interfaces for the PowerPC -----===// |
Misha Brukman | b440243 | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 2 | // |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | f3ebc3f | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | b440243 | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 7 | // |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the JIT interfaces for the 32-bit PowerPC target. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Chris Lattner | 0aa794b | 2005-10-14 23:53:41 +0000 | [diff] [blame] | 14 | #include "PPCJITInfo.h" |
Chris Lattner | 6f3b954 | 2005-10-14 23:59:06 +0000 | [diff] [blame] | 15 | #include "PPCRelocations.h" |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 16 | #include "PPCTargetMachine.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 17 | #include "llvm/IR/Function.h" |
Evan Cheng | f6acb34 | 2006-07-25 20:40:54 +0000 | [diff] [blame] | 18 | #include "llvm/Support/Debug.h" |
Torok Edwin | fb8d6d5 | 2009-07-08 20:53:28 +0000 | [diff] [blame] | 19 | #include "llvm/Support/ErrorHandling.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 20 | #include "llvm/Support/Memory.h" |
Torok Edwin | fb8d6d5 | 2009-07-08 20:53:28 +0000 | [diff] [blame] | 21 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 22 | using namespace llvm; |
| 23 | |
Chandler Carruth | 84e68b2 | 2014-04-22 02:41:26 +0000 | [diff] [blame] | 24 | #define DEBUG_TYPE "jit" |
| 25 | |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 26 | static TargetJITInfo::JITCompilerFn JITCompilerFunction; |
| 27 | |
| 28 | #define BUILD_ADDIS(RD,RS,IMM16) \ |
| 29 | ((15 << 26) | ((RD) << 21) | ((RS) << 16) | ((IMM16) & 65535)) |
| 30 | #define BUILD_ORI(RD,RS,UIMM16) \ |
| 31 | ((24 << 26) | ((RS) << 21) | ((RD) << 16) | ((UIMM16) & 65535)) |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 32 | #define BUILD_ORIS(RD,RS,UIMM16) \ |
| 33 | ((25 << 26) | ((RS) << 21) | ((RD) << 16) | ((UIMM16) & 65535)) |
| 34 | #define BUILD_RLDICR(RD,RS,SH,ME) \ |
| 35 | ((30 << 26) | ((RS) << 21) | ((RD) << 16) | (((SH) & 31) << 11) | \ |
Chris Lattner | 13535c2 | 2006-12-07 23:44:07 +0000 | [diff] [blame] | 36 | (((ME) & 63) << 6) | (1 << 2) | ((((SH) >> 5) & 1) << 1)) |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 37 | #define BUILD_MTSPR(RS,SPR) \ |
| 38 | ((31 << 26) | ((RS) << 21) | ((SPR) << 16) | (467 << 1)) |
| 39 | #define BUILD_BCCTRx(BO,BI,LINK) \ |
| 40 | ((19 << 26) | ((BO) << 21) | ((BI) << 16) | (528 << 1) | ((LINK) & 1)) |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 41 | #define BUILD_B(TARGET, LINK) \ |
| 42 | ((18 << 26) | (((TARGET) & 0x00FFFFFF) << 2) | ((LINK) & 1)) |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 43 | |
| 44 | // Pseudo-ops |
| 45 | #define BUILD_LIS(RD,IMM16) BUILD_ADDIS(RD,0,IMM16) |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 46 | #define BUILD_SLDI(RD,RS,IMM6) BUILD_RLDICR(RD,RS,IMM6,63-IMM6) |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 47 | #define BUILD_MTCTR(RS) BUILD_MTSPR(RS,9) |
| 48 | #define BUILD_BCTR(LINK) BUILD_BCCTRx(20,0,LINK) |
| 49 | |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 50 | static void EmitBranchToAt(uint64_t At, uint64_t To, bool isCall, bool is64Bit){ |
| 51 | intptr_t Offset = ((intptr_t)To - (intptr_t)At) >> 2; |
| 52 | unsigned *AtI = (unsigned*)(intptr_t)At; |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 53 | |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 54 | if (Offset >= -(1 << 23) && Offset < (1 << 23)) { // In range? |
| 55 | AtI[0] = BUILD_B(Offset, isCall); // b/bl target |
| 56 | } else if (!is64Bit) { |
| 57 | AtI[0] = BUILD_LIS(12, To >> 16); // lis r12, hi16(address) |
| 58 | AtI[1] = BUILD_ORI(12, 12, To); // ori r12, r12, lo16(address) |
| 59 | AtI[2] = BUILD_MTCTR(12); // mtctr r12 |
| 60 | AtI[3] = BUILD_BCTR(isCall); // bctr/bctrl |
| 61 | } else { |
| 62 | AtI[0] = BUILD_LIS(12, To >> 48); // lis r12, hi16(address) |
| 63 | AtI[1] = BUILD_ORI(12, 12, To >> 32); // ori r12, r12, lo16(address) |
| 64 | AtI[2] = BUILD_SLDI(12, 12, 32); // sldi r12, r12, 32 |
| 65 | AtI[3] = BUILD_ORIS(12, 12, To >> 16); // oris r12, r12, hi16(address) |
| 66 | AtI[4] = BUILD_ORI(12, 12, To); // ori r12, r12, lo16(address) |
| 67 | AtI[5] = BUILD_MTCTR(12); // mtctr r12 |
| 68 | AtI[6] = BUILD_BCTR(isCall); // bctr/bctrl |
| 69 | } |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 70 | } |
| 71 | |
Chris Lattner | 078b6f2 | 2004-11-24 21:01:46 +0000 | [diff] [blame] | 72 | extern "C" void PPC32CompilationCallback(); |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 73 | extern "C" void PPC64CompilationCallback(); |
Chris Lattner | 078b6f2 | 2004-11-24 21:01:46 +0000 | [diff] [blame] | 74 | |
Bill Schmidt | 40f78a2 | 2013-07-28 03:23:32 +0000 | [diff] [blame] | 75 | // The first clause of the preprocessor directive looks wrong, but it is |
| 76 | // necessary when compiling this code on non-PowerPC hosts. |
Bill Schmidt | 2057322 | 2013-07-28 02:13:24 +0000 | [diff] [blame] | 77 | #if (!defined(__ppc__) && !defined(__powerpc__)) || defined(__powerpc64__) || defined(__ppc64__) |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 78 | void PPC32CompilationCallback() { |
| 79 | llvm_unreachable("This is not a 32bit PowerPC, you can't execute this!"); |
| 80 | } |
| 81 | #elif !defined(__ELF__) |
Chris Lattner | 078b6f2 | 2004-11-24 21:01:46 +0000 | [diff] [blame] | 82 | // CompilationCallback stub - We can't use a C function with inline assembly in |
| 83 | // it, because we the prolog/epilog inserted by GCC won't work for us. Instead, |
| 84 | // write our own wrapper, which does things our way, so we have complete control |
| 85 | // over register saving and restoring. |
| 86 | asm( |
| 87 | ".text\n" |
| 88 | ".align 2\n" |
| 89 | ".globl _PPC32CompilationCallback\n" |
| 90 | "_PPC32CompilationCallback:\n" |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 91 | // Make space for 8 ints r[3-10] and 13 doubles f[1-13] and the |
| 92 | // FIXME: need to save v[0-19] for altivec? |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 93 | // FIXME: could shrink frame |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 94 | // Set up a proper stack frame |
Jim Laskey | e95909a | 2006-12-11 18:10:54 +0000 | [diff] [blame] | 95 | // FIXME Layout |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 96 | // PowerPC32 ABI linkage - 24 bytes |
Jim Laskey | e95909a | 2006-12-11 18:10:54 +0000 | [diff] [blame] | 97 | // parameters - 32 bytes |
| 98 | // 13 double registers - 104 bytes |
| 99 | // 8 int registers - 32 bytes |
Jim Laskey | 6af2220 | 2006-12-10 13:09:42 +0000 | [diff] [blame] | 100 | "mflr r0\n" |
Jim Laskey | e95909a | 2006-12-11 18:10:54 +0000 | [diff] [blame] | 101 | "stw r0, 8(r1)\n" |
| 102 | "stwu r1, -208(r1)\n" |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 103 | // Save all int arg registers |
| 104 | "stw r10, 204(r1)\n" "stw r9, 200(r1)\n" |
| 105 | "stw r8, 196(r1)\n" "stw r7, 192(r1)\n" |
| 106 | "stw r6, 188(r1)\n" "stw r5, 184(r1)\n" |
| 107 | "stw r4, 180(r1)\n" "stw r3, 176(r1)\n" |
Chris Lattner | 078b6f2 | 2004-11-24 21:01:46 +0000 | [diff] [blame] | 108 | // Save all call-clobbered FP regs. |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 109 | "stfd f13, 168(r1)\n" "stfd f12, 160(r1)\n" |
| 110 | "stfd f11, 152(r1)\n" "stfd f10, 144(r1)\n" |
| 111 | "stfd f9, 136(r1)\n" "stfd f8, 128(r1)\n" |
| 112 | "stfd f7, 120(r1)\n" "stfd f6, 112(r1)\n" |
| 113 | "stfd f5, 104(r1)\n" "stfd f4, 96(r1)\n" |
| 114 | "stfd f3, 88(r1)\n" "stfd f2, 80(r1)\n" |
| 115 | "stfd f1, 72(r1)\n" |
| 116 | // Arguments to Compilation Callback: |
| 117 | // r3 - our lr (address of the call instruction in stub plus 4) |
| 118 | // r4 - stub's lr (address of instruction that called the stub plus 4) |
Chris Lattner | 09fecf9 | 2006-12-08 04:54:03 +0000 | [diff] [blame] | 119 | // r5 - is64Bit - always 0. |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 120 | "mr r3, r0\n" |
| 121 | "lwz r2, 208(r1)\n" // stub's frame |
| 122 | "lwz r4, 8(r2)\n" // stub's lr |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 123 | "li r5, 0\n" // 0 == 32 bit |
Rafael Espindola | 9b7d400 | 2013-02-15 14:08:43 +0000 | [diff] [blame] | 124 | "bl _LLVMPPCCompilationCallback\n" |
Nate Begeman | 01364fb | 2006-05-02 04:50:05 +0000 | [diff] [blame] | 125 | "mtctr r3\n" |
| 126 | // Restore all int arg registers |
| 127 | "lwz r10, 204(r1)\n" "lwz r9, 200(r1)\n" |
| 128 | "lwz r8, 196(r1)\n" "lwz r7, 192(r1)\n" |
| 129 | "lwz r6, 188(r1)\n" "lwz r5, 184(r1)\n" |
| 130 | "lwz r4, 180(r1)\n" "lwz r3, 176(r1)\n" |
| 131 | // Restore all FP arg registers |
| 132 | "lfd f13, 168(r1)\n" "lfd f12, 160(r1)\n" |
| 133 | "lfd f11, 152(r1)\n" "lfd f10, 144(r1)\n" |
| 134 | "lfd f9, 136(r1)\n" "lfd f8, 128(r1)\n" |
| 135 | "lfd f7, 120(r1)\n" "lfd f6, 112(r1)\n" |
| 136 | "lfd f5, 104(r1)\n" "lfd f4, 96(r1)\n" |
| 137 | "lfd f3, 88(r1)\n" "lfd f2, 80(r1)\n" |
| 138 | "lfd f1, 72(r1)\n" |
| 139 | // Pop 3 frames off the stack and branch to target |
| 140 | "lwz r1, 208(r1)\n" |
| 141 | "lwz r2, 8(r1)\n" |
| 142 | "mtlr r2\n" |
| 143 | "bctr\n" |
Chris Lattner | 078b6f2 | 2004-11-24 21:01:46 +0000 | [diff] [blame] | 144 | ); |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 145 | |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 146 | #else |
| 147 | // ELF PPC 32 support |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 148 | |
| 149 | // CompilationCallback stub - We can't use a C function with inline assembly in |
| 150 | // it, because we the prolog/epilog inserted by GCC won't work for us. Instead, |
| 151 | // write our own wrapper, which does things our way, so we have complete control |
| 152 | // over register saving and restoring. |
| 153 | asm( |
| 154 | ".text\n" |
| 155 | ".align 2\n" |
| 156 | ".globl PPC32CompilationCallback\n" |
| 157 | "PPC32CompilationCallback:\n" |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 158 | // Make space for 8 ints r[3-10] and 8 doubles f[1-8] and the |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 159 | // FIXME: need to save v[0-19] for altivec? |
| 160 | // FIXME: could shrink frame |
| 161 | // Set up a proper stack frame |
| 162 | // FIXME Layout |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 163 | // 8 double registers - 64 bytes |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 164 | // 8 int registers - 32 bytes |
| 165 | "mflr 0\n" |
| 166 | "stw 0, 4(1)\n" |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 167 | "stwu 1, -104(1)\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 168 | // Save all int arg registers |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 169 | "stw 10, 100(1)\n" "stw 9, 96(1)\n" |
| 170 | "stw 8, 92(1)\n" "stw 7, 88(1)\n" |
| 171 | "stw 6, 84(1)\n" "stw 5, 80(1)\n" |
| 172 | "stw 4, 76(1)\n" "stw 3, 72(1)\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 173 | // Save all call-clobbered FP regs. |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 174 | "stfd 8, 64(1)\n" |
| 175 | "stfd 7, 56(1)\n" "stfd 6, 48(1)\n" |
| 176 | "stfd 5, 40(1)\n" "stfd 4, 32(1)\n" |
| 177 | "stfd 3, 24(1)\n" "stfd 2, 16(1)\n" |
| 178 | "stfd 1, 8(1)\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 179 | // Arguments to Compilation Callback: |
| 180 | // r3 - our lr (address of the call instruction in stub plus 4) |
| 181 | // r4 - stub's lr (address of instruction that called the stub plus 4) |
| 182 | // r5 - is64Bit - always 0. |
| 183 | "mr 3, 0\n" |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 184 | "lwz 5, 104(1)\n" // stub's frame |
| 185 | "lwz 4, 4(5)\n" // stub's lr |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 186 | "li 5, 0\n" // 0 == 32 bit |
Rafael Espindola | 9b7d400 | 2013-02-15 14:08:43 +0000 | [diff] [blame] | 187 | "bl LLVMPPCCompilationCallback\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 188 | "mtctr 3\n" |
| 189 | // Restore all int arg registers |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 190 | "lwz 10, 100(1)\n" "lwz 9, 96(1)\n" |
| 191 | "lwz 8, 92(1)\n" "lwz 7, 88(1)\n" |
| 192 | "lwz 6, 84(1)\n" "lwz 5, 80(1)\n" |
| 193 | "lwz 4, 76(1)\n" "lwz 3, 72(1)\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 194 | // Restore all FP arg registers |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 195 | "lfd 8, 64(1)\n" |
| 196 | "lfd 7, 56(1)\n" "lfd 6, 48(1)\n" |
| 197 | "lfd 5, 40(1)\n" "lfd 4, 32(1)\n" |
| 198 | "lfd 3, 24(1)\n" "lfd 2, 16(1)\n" |
| 199 | "lfd 1, 8(1)\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 200 | // Pop 3 frames off the stack and branch to target |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 201 | "lwz 1, 104(1)\n" |
| 202 | "lwz 0, 4(1)\n" |
| 203 | "mtlr 0\n" |
Chris Lattner | 249edb8 | 2007-02-25 05:04:13 +0000 | [diff] [blame] | 204 | "bctr\n" |
| 205 | ); |
Nate Begeman | 6177606 | 2004-11-23 21:34:18 +0000 | [diff] [blame] | 206 | #endif |
| 207 | |
David Fang | 75ca7ce | 2013-07-24 07:52:16 +0000 | [diff] [blame] | 208 | #if !defined(__powerpc64__) && !defined(__ppc64__) |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 209 | void PPC64CompilationCallback() { |
| 210 | llvm_unreachable("This is not a 64bit PowerPC, you can't execute this!"); |
| 211 | } |
| 212 | #else |
| 213 | # ifdef __ELF__ |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 214 | asm( |
| 215 | ".text\n" |
| 216 | ".align 2\n" |
| 217 | ".globl PPC64CompilationCallback\n" |
Will Schmidt | 114777e | 2014-03-24 16:04:15 +0000 | [diff] [blame] | 218 | #if _CALL_ELF == 2 |
| 219 | ".type PPC64CompilationCallback,@function\n" |
| 220 | "PPC64CompilationCallback:\n" |
| 221 | #else |
Roman Divacky | e07cc04 | 2012-05-09 18:24:23 +0000 | [diff] [blame] | 222 | ".section \".opd\",\"aw\",@progbits\n" |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 223 | ".align 3\n" |
| 224 | "PPC64CompilationCallback:\n" |
| 225 | ".quad .L.PPC64CompilationCallback,.TOC.@tocbase,0\n" |
| 226 | ".size PPC64CompilationCallback,24\n" |
| 227 | ".previous\n" |
| 228 | ".align 4\n" |
| 229 | ".type PPC64CompilationCallback,@function\n" |
| 230 | ".L.PPC64CompilationCallback:\n" |
Will Schmidt | 114777e | 2014-03-24 16:04:15 +0000 | [diff] [blame] | 231 | #endif |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 232 | # else |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 233 | asm( |
| 234 | ".text\n" |
| 235 | ".align 2\n" |
| 236 | ".globl _PPC64CompilationCallback\n" |
| 237 | "_PPC64CompilationCallback:\n" |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 238 | # endif |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 239 | // Make space for 8 ints r[3-10] and 13 doubles f[1-13] and the |
| 240 | // FIXME: need to save v[0-19] for altivec? |
| 241 | // Set up a proper stack frame |
Jim Laskey | e95909a | 2006-12-11 18:10:54 +0000 | [diff] [blame] | 242 | // Layout |
| 243 | // PowerPC64 ABI linkage - 48 bytes |
| 244 | // parameters - 64 bytes |
| 245 | // 13 double registers - 104 bytes |
| 246 | // 8 int registers - 64 bytes |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 247 | "mflr 0\n" |
| 248 | "std 0, 16(1)\n" |
| 249 | "stdu 1, -280(1)\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 250 | // Save all int arg registers |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 251 | "std 10, 272(1)\n" "std 9, 264(1)\n" |
| 252 | "std 8, 256(1)\n" "std 7, 248(1)\n" |
| 253 | "std 6, 240(1)\n" "std 5, 232(1)\n" |
| 254 | "std 4, 224(1)\n" "std 3, 216(1)\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 255 | // Save all call-clobbered FP regs. |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 256 | "stfd 13, 208(1)\n" "stfd 12, 200(1)\n" |
| 257 | "stfd 11, 192(1)\n" "stfd 10, 184(1)\n" |
| 258 | "stfd 9, 176(1)\n" "stfd 8, 168(1)\n" |
| 259 | "stfd 7, 160(1)\n" "stfd 6, 152(1)\n" |
| 260 | "stfd 5, 144(1)\n" "stfd 4, 136(1)\n" |
| 261 | "stfd 3, 128(1)\n" "stfd 2, 120(1)\n" |
| 262 | "stfd 1, 112(1)\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 263 | // Arguments to Compilation Callback: |
| 264 | // r3 - our lr (address of the call instruction in stub plus 4) |
| 265 | // r4 - stub's lr (address of instruction that called the stub plus 4) |
Chris Lattner | 09fecf9 | 2006-12-08 04:54:03 +0000 | [diff] [blame] | 266 | // r5 - is64Bit - always 1. |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 267 | "mr 3, 0\n" // return address (still in r0) |
| 268 | "ld 5, 280(1)\n" // stub's frame |
| 269 | "ld 4, 16(5)\n" // stub's lr |
| 270 | "li 5, 1\n" // 1 == 64 bit |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 271 | # ifdef __ELF__ |
Rafael Espindola | 9b7d400 | 2013-02-15 14:08:43 +0000 | [diff] [blame] | 272 | "bl LLVMPPCCompilationCallback\n" |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 273 | "nop\n" |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 274 | # else |
Rafael Espindola | 9b7d400 | 2013-02-15 14:08:43 +0000 | [diff] [blame] | 275 | "bl _LLVMPPCCompilationCallback\n" |
Joerg Sonnenberger | 8e01ae8 | 2013-07-13 17:59:55 +0000 | [diff] [blame] | 276 | # endif |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 277 | "mtctr 3\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 278 | // Restore all int arg registers |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 279 | "ld 10, 272(1)\n" "ld 9, 264(1)\n" |
| 280 | "ld 8, 256(1)\n" "ld 7, 248(1)\n" |
| 281 | "ld 6, 240(1)\n" "ld 5, 232(1)\n" |
| 282 | "ld 4, 224(1)\n" "ld 3, 216(1)\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 283 | // Restore all FP arg registers |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 284 | "lfd 13, 208(1)\n" "lfd 12, 200(1)\n" |
| 285 | "lfd 11, 192(1)\n" "lfd 10, 184(1)\n" |
| 286 | "lfd 9, 176(1)\n" "lfd 8, 168(1)\n" |
| 287 | "lfd 7, 160(1)\n" "lfd 6, 152(1)\n" |
| 288 | "lfd 5, 144(1)\n" "lfd 4, 136(1)\n" |
| 289 | "lfd 3, 128(1)\n" "lfd 2, 120(1)\n" |
| 290 | "lfd 1, 112(1)\n" |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 291 | // Pop 3 frames off the stack and branch to target |
Roman Divacky | 6874b26 | 2011-06-15 15:29:47 +0000 | [diff] [blame] | 292 | "ld 1, 280(1)\n" |
| 293 | "ld 0, 16(1)\n" |
| 294 | "mtlr 0\n" |
| 295 | // XXX: any special TOC handling in the ELF case for JIT? |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 296 | "bctr\n" |
| 297 | ); |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 298 | #endif |
| 299 | |
Anton Korobeynikov | 325e926 | 2012-04-03 06:59:28 +0000 | [diff] [blame] | 300 | extern "C" { |
Benjamin Kramer | de712b7 | 2013-02-17 14:30:32 +0000 | [diff] [blame] | 301 | LLVM_LIBRARY_VISIBILITY void * |
Rafael Espindola | 91cbcbb | 2013-02-15 14:15:59 +0000 | [diff] [blame] | 302 | LLVMPPCCompilationCallback(unsigned *StubCallAddrPlus4, |
| 303 | unsigned *OrigCallAddrPlus4, |
| 304 | bool is64Bit) { |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 305 | // Adjust the pointer to the address of the call instruction in the stub |
| 306 | // emitted by emitFunctionStub, rather than the instruction after it. |
| 307 | unsigned *StubCallAddr = StubCallAddrPlus4 - 1; |
| 308 | unsigned *OrigCallAddr = OrigCallAddrPlus4 - 1; |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 309 | |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 310 | void *Target = JITCompilerFunction(StubCallAddr); |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 311 | |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 312 | // Check to see if *OrigCallAddr is a 'bl' instruction, and if we can rewrite |
| 313 | // it to branch directly to the destination. If so, rewrite it so it does not |
| 314 | // need to go through the stub anymore. |
| 315 | unsigned OrigCallInst = *OrigCallAddr; |
| 316 | if ((OrigCallInst >> 26) == 18) { // Direct call. |
| 317 | intptr_t Offset = ((intptr_t)Target - (intptr_t)OrigCallAddr) >> 2; |
| 318 | |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 319 | if (Offset >= -(1 << 23) && Offset < (1 << 23)) { // In range? |
Chris Lattner | 659d72e | 2004-11-24 18:00:02 +0000 | [diff] [blame] | 320 | // Clear the original target out. |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 321 | OrigCallInst &= (63 << 26) | 3; |
Chris Lattner | 659d72e | 2004-11-24 18:00:02 +0000 | [diff] [blame] | 322 | // Fill in the new target. |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 323 | OrigCallInst |= (Offset & ((1 << 24)-1)) << 2; |
Chris Lattner | 659d72e | 2004-11-24 18:00:02 +0000 | [diff] [blame] | 324 | // Replace the call. |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 325 | *OrigCallAddr = OrigCallInst; |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 326 | } |
| 327 | } |
Misha Brukman | b440243 | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 328 | |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 329 | // Assert that we are coming from a stub that was created with our |
| 330 | // emitFunctionStub. |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 331 | if ((*StubCallAddr >> 26) == 18) |
| 332 | StubCallAddr -= 3; |
| 333 | else { |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 334 | assert((*StubCallAddr >> 26) == 19 && "Call in stub is not indirect!"); |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 335 | StubCallAddr -= is64Bit ? 9 : 6; |
| 336 | } |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 337 | |
| 338 | // Rewrite the stub with an unconditional branch to the target, for any users |
| 339 | // who took the address of the stub. |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 340 | EmitBranchToAt((intptr_t)StubCallAddr, (intptr_t)Target, false, is64Bit); |
Jeffrey Yasskin | 3aa70b2 | 2010-01-14 23:15:26 +0000 | [diff] [blame] | 341 | sys::Memory::InvalidateInstructionCache(StubCallAddr, 7*4); |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 342 | |
Nate Begeman | 318bb96 | 2006-04-25 04:45:59 +0000 | [diff] [blame] | 343 | // Put the address of the target function to call and the address to return to |
| 344 | // after calling the target function in a place that is easy to get on the |
| 345 | // stack after we restore all regs. |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 346 | return Target; |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 347 | } |
Anton Korobeynikov | 325e926 | 2012-04-03 06:59:28 +0000 | [diff] [blame] | 348 | } |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 349 | |
| 350 | |
| 351 | |
Misha Brukman | b440243 | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 352 | TargetJITInfo::LazyResolverFn |
Nate Begeman | 6cca84e | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 353 | PPCJITInfo::getLazyResolverFunction(JITCompilerFn Fn) { |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 354 | JITCompilerFunction = Fn; |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 355 | return is64Bit ? PPC64CompilationCallback : PPC32CompilationCallback; |
Chris Lattner | 4ff1175 | 2004-11-23 06:55:05 +0000 | [diff] [blame] | 356 | } |
| 357 | |
Jeffrey Yasskin | f2ad571 | 2009-11-23 23:35:19 +0000 | [diff] [blame] | 358 | TargetJITInfo::StubLayout PPCJITInfo::getStubLayout() { |
| 359 | // The stub contains up to 10 4-byte instructions, aligned at 4 bytes: 3 |
| 360 | // instructions to save the caller's address if this is a lazy-compilation |
| 361 | // stub, plus a 1-, 4-, or 7-instruction sequence to load an arbitrary address |
| 362 | // into a register and jump through it. |
| 363 | StubLayout Result = {10*4, 4}; |
| 364 | return Result; |
| 365 | } |
| 366 | |
Rafael Espindola | 05b5a46 | 2013-07-26 22:13:57 +0000 | [diff] [blame] | 367 | #if (defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)) && \ |
| 368 | defined(__APPLE__) |
Chris Lattner | 919ad97 | 2008-01-25 16:41:09 +0000 | [diff] [blame] | 369 | extern "C" void sys_icache_invalidate(const void *Addr, size_t len); |
| 370 | #endif |
| 371 | |
Nicolas Geoffray | a7557df | 2008-04-16 20:46:05 +0000 | [diff] [blame] | 372 | void *PPCJITInfo::emitFunctionStub(const Function* F, void *Fn, |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 373 | JITCodeEmitter &JCE) { |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 374 | // If this is just a call to an external function, emit a branch instead of a |
| 375 | // call. The code is the same except for one bit of the last instruction. |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 376 | if (Fn != (void*)(intptr_t)PPC32CompilationCallback && |
| 377 | Fn != (void*)(intptr_t)PPC64CompilationCallback) { |
Jeffrey Yasskin | f2ad571 | 2009-11-23 23:35:19 +0000 | [diff] [blame] | 378 | void *Addr = (void*)JCE.getCurrentPCValue(); |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 379 | JCE.emitWordBE(0); |
| 380 | JCE.emitWordBE(0); |
| 381 | JCE.emitWordBE(0); |
| 382 | JCE.emitWordBE(0); |
| 383 | JCE.emitWordBE(0); |
| 384 | JCE.emitWordBE(0); |
| 385 | JCE.emitWordBE(0); |
Jeffrey Yasskin | f2ad571 | 2009-11-23 23:35:19 +0000 | [diff] [blame] | 386 | EmitBranchToAt((intptr_t)Addr, (intptr_t)Fn, false, is64Bit); |
| 387 | sys::Memory::InvalidateInstructionCache(Addr, 7*4); |
| 388 | return Addr; |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 389 | } |
| 390 | |
Jeffrey Yasskin | f2ad571 | 2009-11-23 23:35:19 +0000 | [diff] [blame] | 391 | void *Addr = (void*)JCE.getCurrentPCValue(); |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 392 | if (is64Bit) { |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 393 | JCE.emitWordBE(0xf821ffb1); // stdu r1,-80(r1) |
| 394 | JCE.emitWordBE(0x7d6802a6); // mflr r11 |
| 395 | JCE.emitWordBE(0xf9610060); // std r11, 96(r1) |
Eric Christopher | 54367e0 | 2014-06-12 22:19:51 +0000 | [diff] [blame^] | 396 | } else if (Subtarget.isDarwinABI()){ |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 397 | JCE.emitWordBE(0x9421ffe0); // stwu r1,-32(r1) |
| 398 | JCE.emitWordBE(0x7d6802a6); // mflr r11 |
| 399 | JCE.emitWordBE(0x91610028); // stw r11, 40(r1) |
Nicolas Geoffray | cff3e12 | 2007-05-29 16:33:18 +0000 | [diff] [blame] | 400 | } else { |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 401 | JCE.emitWordBE(0x9421ffe0); // stwu r1,-32(r1) |
| 402 | JCE.emitWordBE(0x7d6802a6); // mflr r11 |
| 403 | JCE.emitWordBE(0x91610024); // stw r11, 36(r1) |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 404 | } |
Bruno Cardoso Lopes | a194c3a | 2009-05-30 20:51:52 +0000 | [diff] [blame] | 405 | intptr_t BranchAddr = (intptr_t)JCE.getCurrentPCValue(); |
| 406 | JCE.emitWordBE(0); |
| 407 | JCE.emitWordBE(0); |
| 408 | JCE.emitWordBE(0); |
| 409 | JCE.emitWordBE(0); |
| 410 | JCE.emitWordBE(0); |
| 411 | JCE.emitWordBE(0); |
| 412 | JCE.emitWordBE(0); |
Chris Lattner | 919ad97 | 2008-01-25 16:41:09 +0000 | [diff] [blame] | 413 | EmitBranchToAt(BranchAddr, (intptr_t)Fn, true, is64Bit); |
Jeffrey Yasskin | f2ad571 | 2009-11-23 23:35:19 +0000 | [diff] [blame] | 414 | sys::Memory::InvalidateInstructionCache(Addr, 10*4); |
| 415 | return Addr; |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | |
Nate Begeman | 6cca84e | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 419 | void PPCJITInfo::relocate(void *Function, MachineRelocation *MR, |
| 420 | unsigned NumRelocs, unsigned char* GOTBase) { |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 421 | for (unsigned i = 0; i != NumRelocs; ++i, ++MR) { |
| 422 | unsigned *RelocPos = (unsigned*)Function + MR->getMachineCodeOffset()/4; |
| 423 | intptr_t ResultPtr = (intptr_t)MR->getResultPointer(); |
| 424 | switch ((PPC::RelocationType)MR->getRelocationType()) { |
Torok Edwin | fbcc663 | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 425 | default: llvm_unreachable("Unknown relocation type!"); |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 426 | case PPC::reloc_pcrel_bx: |
| 427 | // PC-relative relocation for b and bl instructions. |
| 428 | ResultPtr = (ResultPtr-(intptr_t)RelocPos) >> 2; |
| 429 | assert(ResultPtr >= -(1 << 23) && ResultPtr < (1 << 23) && |
| 430 | "Relocation out of range!"); |
| 431 | *RelocPos |= (ResultPtr & ((1 << 24)-1)) << 2; |
| 432 | break; |
Evan Cheng | 78bf107 | 2006-07-27 18:21:10 +0000 | [diff] [blame] | 433 | case PPC::reloc_pcrel_bcx: |
| 434 | // PC-relative relocation for BLT,BLE,BEQ,BGE,BGT,BNE, or other |
| 435 | // bcx instructions. |
| 436 | ResultPtr = (ResultPtr-(intptr_t)RelocPos) >> 2; |
| 437 | assert(ResultPtr >= -(1 << 13) && ResultPtr < (1 << 13) && |
| 438 | "Relocation out of range!"); |
| 439 | *RelocPos |= (ResultPtr & ((1 << 14)-1)) << 2; |
| 440 | break; |
Chris Lattner | dd51679 | 2004-11-24 22:30:08 +0000 | [diff] [blame] | 441 | case PPC::reloc_absolute_high: // high bits of ref -> low 16 of instr |
Chris Lattner | 5b17dee | 2006-07-12 21:23:20 +0000 | [diff] [blame] | 442 | case PPC::reloc_absolute_low: { // low bits of ref -> low 16 of instr |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 443 | ResultPtr += MR->getConstantVal(); |
| 444 | |
Chris Lattner | dd51679 | 2004-11-24 22:30:08 +0000 | [diff] [blame] | 445 | // If this is a high-part access, get the high-part. |
Nate Begeman | 69df613 | 2006-09-08 22:42:09 +0000 | [diff] [blame] | 446 | if (MR->getRelocationType() == PPC::reloc_absolute_high) { |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 447 | // If the low part will have a carry (really a borrow) from the low |
| 448 | // 16-bits into the high 16, add a bit to borrow from. |
| 449 | if (((int)ResultPtr << 16) < 0) |
| 450 | ResultPtr += 1 << 16; |
| 451 | ResultPtr >>= 16; |
| 452 | } |
| 453 | |
| 454 | // Do the addition then mask, so the addition does not overflow the 16-bit |
| 455 | // immediate section of the instruction. |
| 456 | unsigned LowBits = (*RelocPos + ResultPtr) & 65535; |
| 457 | unsigned HighBits = *RelocPos & ~65535; |
| 458 | *RelocPos = LowBits | HighBits; // Slam into low 16-bits |
| 459 | break; |
| 460 | } |
Chris Lattner | 5b17dee | 2006-07-12 21:23:20 +0000 | [diff] [blame] | 461 | case PPC::reloc_absolute_low_ix: { // low bits of ref -> low 14 of instr |
| 462 | ResultPtr += MR->getConstantVal(); |
| 463 | // Do the addition then mask, so the addition does not overflow the 16-bit |
| 464 | // immediate section of the instruction. |
| 465 | unsigned LowBits = (*RelocPos + ResultPtr) & 0xFFFC; |
| 466 | unsigned HighBits = *RelocPos & 0xFFFF0003; |
| 467 | *RelocPos = LowBits | HighBits; // Slam into low 14-bits. |
| 468 | break; |
| 469 | } |
| 470 | } |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 471 | } |
| 472 | } |
| 473 | |
Nate Begeman | 6cca84e | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 474 | void PPCJITInfo::replaceMachineCodeForFunction(void *Old, void *New) { |
Nate Begeman | 18f0329 | 2006-08-29 02:30:59 +0000 | [diff] [blame] | 475 | EmitBranchToAt((intptr_t)Old, (intptr_t)New, false, is64Bit); |
Jeffrey Yasskin | 3aa70b2 | 2010-01-14 23:15:26 +0000 | [diff] [blame] | 476 | sys::Memory::InvalidateInstructionCache(Old, 7*4); |
Chris Lattner | 8296c4c | 2004-11-23 06:02:06 +0000 | [diff] [blame] | 477 | } |