SparcJITInfo.cpp revision cd81d94322a39503e4a3e87b6ee03d4fcb3465fb 
1//===-- SparcJITInfo.cpp - Implement the Sparc JIT Interface --------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the JIT interfaces for the Sparc target.
11//
12//===----------------------------------------------------------------------===//
13#include "SparcJITInfo.h"
14#include "Sparc.h"
15#include "SparcRelocations.h"
16#include "llvm/ADT/SmallVector.h"
17#include "llvm/CodeGen/JITCodeEmitter.h"
18#include "llvm/Support/Memory.h"
19
20using namespace llvm;
21
22#define DEBUG_TYPE "jit"
23
24/// JITCompilerFunction - This contains the address of the JIT function used to
25/// compile a function lazily.
26static TargetJITInfo::JITCompilerFn JITCompilerFunction;
27
28extern "C" void SparcCompilationCallback();
29
30extern "C" {
31#if defined (__sparc__)
32
33#if defined(__arch64__)
34#define FRAME_PTR(X) #X "+2047"
35#else
36#define FRAME_PTR(X) #X
37#endif
38
39  asm(
40      ".text\n"
41      "\t.align 4\n"
42      "\t.global SparcCompilationCallback\n"
43      "\t.type SparcCompilationCallback, #function\n"
44      "SparcCompilationCallback:\n"
45      // Save current register window and create stack.
46      // 128 (save area) + 6*8 (for arguments) + 16*8 (for float regfile) = 304
47      "\tsave %sp, -304, %sp\n"
48      // save float regfile to the stack.
49      "\tstd %f0,  [" FRAME_PTR(%fp) "-0]\n"
50      "\tstd %f2,  [" FRAME_PTR(%fp) "-8]\n"
51      "\tstd %f4,  [" FRAME_PTR(%fp) "-16]\n"
52      "\tstd %f6,  [" FRAME_PTR(%fp) "-24]\n"
53      "\tstd %f8,  [" FRAME_PTR(%fp) "-32]\n"
54      "\tstd %f10, [" FRAME_PTR(%fp) "-40]\n"
55      "\tstd %f12, [" FRAME_PTR(%fp) "-48]\n"
56      "\tstd %f14, [" FRAME_PTR(%fp) "-56]\n"
57      "\tstd %f16, [" FRAME_PTR(%fp) "-64]\n"
58      "\tstd %f18, [" FRAME_PTR(%fp) "-72]\n"
59      "\tstd %f20, [" FRAME_PTR(%fp) "-80]\n"
60      "\tstd %f22, [" FRAME_PTR(%fp) "-88]\n"
61      "\tstd %f24, [" FRAME_PTR(%fp) "-96]\n"
62      "\tstd %f26, [" FRAME_PTR(%fp) "-104]\n"
63      "\tstd %f28, [" FRAME_PTR(%fp) "-112]\n"
64      "\tstd %f30, [" FRAME_PTR(%fp) "-120]\n"
65      // stubaddr is in %g1.
66      "\tcall SparcCompilationCallbackC\n"
67      "\t  mov %g1, %o0\n"
68      // restore float regfile from the stack.
69      "\tldd [" FRAME_PTR(%fp) "-0],   %f0\n"
70      "\tldd [" FRAME_PTR(%fp) "-8],   %f2\n"
71      "\tldd [" FRAME_PTR(%fp) "-16],  %f4\n"
72      "\tldd [" FRAME_PTR(%fp) "-24],  %f6\n"
73      "\tldd [" FRAME_PTR(%fp) "-32],  %f8\n"
74      "\tldd [" FRAME_PTR(%fp) "-40],  %f10\n"
75      "\tldd [" FRAME_PTR(%fp) "-48],  %f12\n"
76      "\tldd [" FRAME_PTR(%fp) "-56],  %f14\n"
77      "\tldd [" FRAME_PTR(%fp) "-64],  %f16\n"
78      "\tldd [" FRAME_PTR(%fp) "-72],  %f18\n"
79      "\tldd [" FRAME_PTR(%fp) "-80],  %f20\n"
80      "\tldd [" FRAME_PTR(%fp) "-88],  %f22\n"
81      "\tldd [" FRAME_PTR(%fp) "-96],  %f24\n"
82      "\tldd [" FRAME_PTR(%fp) "-104], %f26\n"
83      "\tldd [" FRAME_PTR(%fp) "-112], %f28\n"
84      "\tldd [" FRAME_PTR(%fp) "-120], %f30\n"
85      // restore original register window and
86      // copy %o0 to %g1
87      "\trestore %o0, 0, %g1\n"
88      // call the new stub
89      "\tjmp %g1\n"
90      "\t  nop\n"
91      "\t.size   SparcCompilationCallback, .-SparcCompilationCallback"
92      );
93#else
94  void SparcCompilationCallback() {
95    llvm_unreachable(
96      "Cannot call SparcCompilationCallback() on a non-sparc arch!");
97  }
98#endif
99}
100
101
102#define SETHI_INST(imm, rd)    (0x01000000 | ((rd) << 25) | ((imm) & 0x3FFFFF))
103#define JMP_INST(rs1, imm, rd) (0x80000000 | ((rd) << 25) | (0x38 << 19) \
104                                | ((rs1) << 14) | (1 << 13) | ((imm) & 0x1FFF))
105#define NOP_INST               SETHI_INST(0, 0)
106#define OR_INST_I(rs1, imm, rd) (0x80000000 | ((rd) << 25) | (0x02 << 19) \
107                                 | ((rs1) << 14) | (1 << 13) | ((imm) & 0x1FFF))
108#define OR_INST_R(rs1, rs2, rd) (0x80000000 | ((rd) << 25) | (0x02 << 19) \
109                                 | ((rs1) << 14) | (0 << 13) | ((rs2) & 0x1F))
110#define RDPC_INST(rd)           (0x80000000 | ((rd) << 25) | (0x28 << 19) \
111                                 | (5 << 14))
112#define LDX_INST(rs1, imm, rd)  (0xC0000000 | ((rd) << 25) | (0x0B << 19) \
113                                 | ((rs1) << 14) | (1 << 13) | ((imm) & 0x1FFF))
114#define SLLX_INST(rs1, imm, rd) (0x80000000 | ((rd) << 25) | (0x25 << 19) \
115                                 | ((rs1) << 14) | (3 << 12) | ((imm) & 0x3F))
116#define SUB_INST(rs1, imm, rd)  (0x80000000 | ((rd) << 25) | (0x04 << 19) \
117                                 | ((rs1) << 14) | (1 << 13) | ((imm) & 0x1FFF))
118#define XOR_INST(rs1, imm, rd)  (0x80000000 | ((rd) << 25) | (0x03 << 19) \
119                                 | ((rs1) << 14) | (1 << 13) | ((imm) & 0x1FFF))
120#define BA_INST(tgt)             (0x10800000 | ((tgt) & 0x3FFFFF))
121
122// Emit instructions to jump to Addr and store the starting address of
123// the instructions emitted in the scratch register.
124static void emitInstrForIndirectJump(intptr_t Addr,
125                                     unsigned scratch,
126                                     SmallVectorImpl<uint32_t> &Insts) {
127
128  if (isInt<13>(Addr)) {
129    // Emit: jmpl %g0+Addr, <scratch>
130    //         nop
131    Insts.push_back(JMP_INST(0, LO10(Addr), scratch));
132    Insts.push_back(NOP_INST);
133    return;
134  }
135
136  if (isUInt<32>(Addr)) {
137    // Emit: sethi %hi(Addr), scratch
138    //       jmpl scratch+%lo(Addr), scratch
139    //         sub scratch, 4, scratch
140    Insts.push_back(SETHI_INST(HI22(Addr), scratch));
141    Insts.push_back(JMP_INST(scratch, LO10(Addr), scratch));
142    Insts.push_back(SUB_INST(scratch, 4, scratch));
143    return;
144  }
145
146  if (Addr < 0 && isInt<33>(Addr)) {
147    // Emit: sethi %hix(Addr), scratch)
148    //       xor   scratch, %lox(Addr), scratch
149    //       jmpl scratch+0, scratch
150    //         sub scratch, 8, scratch
151    Insts.push_back(SETHI_INST(HIX22(Addr), scratch));
152    Insts.push_back(XOR_INST(scratch, LOX10(Addr), scratch));
153    Insts.push_back(JMP_INST(scratch, 0, scratch));
154    Insts.push_back(SUB_INST(scratch, 8, scratch));
155    return;
156  }
157
158  // Emit: rd %pc, scratch
159  //       ldx [scratch+16], scratch
160  //       jmpl scratch+0, scratch
161  //         sub scratch, 8, scratch
162  //       <Addr: 8 byte>
163  Insts.push_back(RDPC_INST(scratch));
164  Insts.push_back(LDX_INST(scratch, 16, scratch));
165  Insts.push_back(JMP_INST(scratch, 0, scratch));
166  Insts.push_back(SUB_INST(scratch, 8, scratch));
167  Insts.push_back((uint32_t)(((int64_t)Addr) >> 32) & 0xffffffff);
168  Insts.push_back((uint32_t)(Addr & 0xffffffff));
169
170  // Instruction sequence without rdpc instruction
171  // 7 instruction and 2 scratch register
172  // Emit: sethi %hh(Addr), scratch
173  //       or scratch, %hm(Addr), scratch
174  //       sllx scratch, 32, scratch
175  //       sethi %hi(Addr), scratch2
176  //       or scratch, scratch2, scratch
177  //       jmpl scratch+%lo(Addr), scratch
178  //         sub scratch, 20, scratch
179  // Insts.push_back(SETHI_INST(HH22(Addr), scratch));
180  // Insts.push_back(OR_INST_I(scratch, HM10(Addr), scratch));
181  // Insts.push_back(SLLX_INST(scratch, 32, scratch));
182  // Insts.push_back(SETHI_INST(HI22(Addr), scratch2));
183  // Insts.push_back(OR_INST_R(scratch, scratch2, scratch));
184  // Insts.push_back(JMP_INST(scratch, LO10(Addr), scratch));
185  // Insts.push_back(SUB_INST(scratch, 20, scratch));
186}
187
188extern "C" void *SparcCompilationCallbackC(intptr_t StubAddr) {
189  // Get the address of the compiled code for this function.
190  intptr_t NewVal = (intptr_t) JITCompilerFunction((void*) StubAddr);
191
192  // Rewrite the function stub so that we don't end up here every time we
193  // execute the call. We're replacing the stub instructions with code
194  // that jumps to the compiled function:
195
196  SmallVector<uint32_t, 8> Insts;
197  intptr_t diff = (NewVal - StubAddr) >> 2;
198  if (isInt<22>(diff)) {
199    // Use branch instruction to jump
200    Insts.push_back(BA_INST(diff));
201    Insts.push_back(NOP_INST);
202  } else {
203    // Otherwise, use indirect jump to the compiled function
204    emitInstrForIndirectJump(NewVal, 1, Insts);
205  }
206
207  for (unsigned i = 0, e = Insts.size(); i != e; ++i)
208    *(uint32_t *)(StubAddr + i*4) = Insts[i];
209
210  sys::Memory::InvalidateInstructionCache((void*) StubAddr, Insts.size() * 4);
211  return (void*)StubAddr;
212}
213
214
215void SparcJITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
216  llvm_unreachable("FIXME: Implement SparcJITInfo::"
217                   "replaceMachineCodeForFunction");
218}
219
220
221TargetJITInfo::StubLayout SparcJITInfo::getStubLayout() {
222  // The stub contains maximum of 4 4-byte instructions and 8 bytes for address,
223  // aligned at 32 bytes.
224  // See emitFunctionStub and emitInstrForIndirectJump for details.
225  StubLayout Result = { 4*4 + 8, 32 };
226  return Result;
227}
228
229void *SparcJITInfo::emitFunctionStub(const Function *F, void *Fn,
230                                     JITCodeEmitter &JCE)
231{
232  JCE.emitAlignment(32);
233  void *Addr = (void*) (JCE.getCurrentPCValue());
234
235  intptr_t CurrentAddr = (intptr_t)Addr;
236  intptr_t EmittedAddr;
237  SmallVector<uint32_t, 8> Insts;
238  if (Fn != (void*)(intptr_t)SparcCompilationCallback) {
239    EmittedAddr = (intptr_t)Fn;
240    intptr_t diff = (EmittedAddr - CurrentAddr) >> 2;
241    if (isInt<22>(diff)) {
242      Insts.push_back(BA_INST(diff));
243      Insts.push_back(NOP_INST);
244    }
245  } else {
246    EmittedAddr = (intptr_t)SparcCompilationCallback;
247  }
248
249  if (Insts.size() == 0)
250    emitInstrForIndirectJump(EmittedAddr, 1, Insts);
251
252
253  if (!sys::Memory::setRangeWritable(Addr, 4 * Insts.size()))
254    llvm_unreachable("ERROR: Unable to mark stub writable.");
255
256  for (unsigned i = 0, e = Insts.size(); i != e; ++i)
257    JCE.emitWordBE(Insts[i]);
258
259  sys::Memory::InvalidateInstructionCache(Addr, 4 * Insts.size());
260  if (!sys::Memory::setRangeExecutable(Addr, 4 * Insts.size()))
261    llvm_unreachable("ERROR: Unable to mark stub executable.");
262
263  return Addr;
264}
265
266
267TargetJITInfo::LazyResolverFn
268SparcJITInfo::getLazyResolverFunction(JITCompilerFn F) {
269  JITCompilerFunction = F;
270  return SparcCompilationCallback;
271}
272
273/// relocate - Before the JIT can run a block of code that has been emitted,
274/// it must rewrite the code to contain the actual addresses of any
275/// referenced global symbols.
276void SparcJITInfo::relocate(void *Function, MachineRelocation *MR,
277                            unsigned NumRelocs, unsigned char *GOTBase) {
278  for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
279    void *RelocPos = (char*) Function + MR->getMachineCodeOffset();
280    intptr_t ResultPtr = (intptr_t) MR->getResultPointer();
281
282    switch ((SP::RelocationType) MR->getRelocationType()) {
283    case SP::reloc_sparc_hi:
284      ResultPtr = (ResultPtr >> 10) & 0x3fffff;
285      break;
286
287    case SP::reloc_sparc_lo:
288      ResultPtr = (ResultPtr & 0x3ff);
289      break;
290
291    case SP::reloc_sparc_pc30:
292      ResultPtr = ((ResultPtr - (intptr_t)RelocPos) >> 2) & 0x3fffffff;
293      break;
294
295    case SP::reloc_sparc_pc22:
296      ResultPtr = ((ResultPtr - (intptr_t)RelocPos) >> 2) & 0x3fffff;
297      break;
298
299    case SP::reloc_sparc_pc19:
300      ResultPtr = ((ResultPtr - (intptr_t)RelocPos) >> 2) & 0x7ffff;
301      break;
302
303    case SP::reloc_sparc_h44:
304      ResultPtr = (ResultPtr >> 22) & 0x3fffff;
305      break;
306
307    case SP::reloc_sparc_m44:
308      ResultPtr = (ResultPtr >> 12) & 0x3ff;
309      break;
310
311    case SP::reloc_sparc_l44:
312      ResultPtr = (ResultPtr & 0xfff);
313      break;
314
315    case SP::reloc_sparc_hh:
316      ResultPtr = (((int64_t)ResultPtr) >> 42) & 0x3fffff;
317      break;
318
319    case SP::reloc_sparc_hm:
320      ResultPtr = (((int64_t)ResultPtr) >> 32) & 0x3ff;
321      break;
322
323    }
324    *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
325  }
326}
327