1 //===- MipsJITInfo.cpp - Implement the JIT interfaces for the Mips target -===//
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 Mips target.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #define DEBUG_TYPE "jit"
15 #include "MipsJITInfo.h"
16 #include "MipsInstrInfo.h"
17 #include "MipsRelocations.h"
18 #include "MipsSubtarget.h"
19 #include "llvm/Function.h"
20 #include "llvm/CodeGen/JITCodeEmitter.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "llvm/Support/Memory.h"
25 #include <cstdlib>
26 using namespace llvm;
27
28
replaceMachineCodeForFunction(void * Old,void * New)29 void MipsJITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
30 report_fatal_error("MipsJITInfo::replaceMachineCodeForFunction");
31 }
32
33 /// JITCompilerFunction - This contains the address of the JIT function used to
34 /// compile a function lazily.
35 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
36
37 // Get the ASMPREFIX for the current host. This is often '_'.
38 #ifndef __USER_LABEL_PREFIX__
39 #define __USER_LABEL_PREFIX__
40 #endif
41 #define GETASMPREFIX2(X) #X
42 #define GETASMPREFIX(X) GETASMPREFIX2(X)
43 #define ASMPREFIX GETASMPREFIX(__USER_LABEL_PREFIX__)
44
45 // CompilationCallback stub - We can't use a C function with inline assembly in
46 // it, because the prolog/epilog inserted by GCC won't work for us. Instead,
47 // write our own wrapper, which does things our way, so we have complete control
48 // over register saving and restoring. This code saves registers, calls
49 // MipsCompilationCallbackC and restores registers.
50 extern "C" {
51 #if defined (__mips__)
52 void MipsCompilationCallback();
53
54 asm(
55 ".text\n"
56 ".align 2\n"
57 ".globl " ASMPREFIX "MipsCompilationCallback\n"
58 ASMPREFIX "MipsCompilationCallback:\n"
59 ".ent " ASMPREFIX "MipsCompilationCallback\n"
60 ".frame $sp, 32, $ra\n"
61 ".set noreorder\n"
62 ".cpload $t9\n"
63
64 "addiu $sp, $sp, -64\n"
65 ".cprestore 16\n"
66
67 // Save argument registers a0, a1, a2, a3, f12, f14 since they may contain
68 // stuff for the real target function right now. We have to act as if this
69 // whole compilation callback doesn't exist as far as the caller is
70 // concerned. We also need to save the ra register since it contains the
71 // original return address, and t8 register since it contains the address
72 // of the end of function stub.
73 "sw $a0, 20($sp)\n"
74 "sw $a1, 24($sp)\n"
75 "sw $a2, 28($sp)\n"
76 "sw $a3, 32($sp)\n"
77 "sw $ra, 36($sp)\n"
78 "sw $t8, 40($sp)\n"
79 "sdc1 $f12, 48($sp)\n"
80 "sdc1 $f14, 56($sp)\n"
81
82 // t8 points at the end of function stub. Pass the beginning of the stub
83 // to the MipsCompilationCallbackC.
84 "addiu $a0, $t8, -16\n"
85 "jal " ASMPREFIX "MipsCompilationCallbackC\n"
86 "nop\n"
87
88 // Restore registers.
89 "lw $a0, 20($sp)\n"
90 "lw $a1, 24($sp)\n"
91 "lw $a2, 28($sp)\n"
92 "lw $a3, 32($sp)\n"
93 "lw $ra, 36($sp)\n"
94 "lw $t8, 40($sp)\n"
95 "ldc1 $f12, 48($sp)\n"
96 "ldc1 $f14, 56($sp)\n"
97 "addiu $sp, $sp, 64\n"
98
99 // Jump to the (newly modified) stub to invoke the real function.
100 "addiu $t8, $t8, -16\n"
101 "jr $t8\n"
102 "nop\n"
103
104 ".set reorder\n"
105 ".end " ASMPREFIX "MipsCompilationCallback\n"
106 );
107 #else // host != Mips
108 void MipsCompilationCallback() {
109 llvm_unreachable(
110 "Cannot call MipsCompilationCallback() on a non-Mips arch!");
111 }
112 #endif
113 }
114
115 /// MipsCompilationCallbackC - This is the target-specific function invoked
116 /// by the function stub when we did not know the real target of a call.
117 /// This function must locate the start of the stub or call site and pass
118 /// it into the JIT compiler function.
MipsCompilationCallbackC(intptr_t StubAddr)119 extern "C" void MipsCompilationCallbackC(intptr_t StubAddr) {
120 // Get the address of the compiled code for this function.
121 intptr_t NewVal = (intptr_t) JITCompilerFunction((void*) StubAddr);
122
123 // Rewrite the function stub so that we don't end up here every time we
124 // execute the call. We're replacing the first four instructions of the
125 // stub with code that jumps to the compiled function:
126 // lui $t9, %hi(NewVal)
127 // addiu $t9, $t9, %lo(NewVal)
128 // jr $t9
129 // nop
130
131 int Hi = ((unsigned)NewVal & 0xffff0000) >> 16;
132 if ((NewVal & 0x8000) != 0)
133 Hi++;
134 int Lo = (int)(NewVal & 0xffff);
135
136 *(intptr_t *)(StubAddr) = 0xf << 26 | 25 << 16 | Hi;
137 *(intptr_t *)(StubAddr + 4) = 9 << 26 | 25 << 21 | 25 << 16 | Lo;
138 *(intptr_t *)(StubAddr + 8) = 25 << 21 | 8;
139 *(intptr_t *)(StubAddr + 12) = 0;
140
141 sys::Memory::InvalidateInstructionCache((void*) StubAddr, 16);
142 }
143
getLazyResolverFunction(JITCompilerFn F)144 TargetJITInfo::LazyResolverFn MipsJITInfo::getLazyResolverFunction(
145 JITCompilerFn F) {
146 JITCompilerFunction = F;
147 return MipsCompilationCallback;
148 }
149
getStubLayout()150 TargetJITInfo::StubLayout MipsJITInfo::getStubLayout() {
151 // The stub contains 4 4-byte instructions, aligned at 4 bytes. See
152 // emitFunctionStub for details.
153 StubLayout Result = { 4*4, 4 };
154 return Result;
155 }
156
emitFunctionStub(const Function * F,void * Fn,JITCodeEmitter & JCE)157 void *MipsJITInfo::emitFunctionStub(const Function* F, void *Fn,
158 JITCodeEmitter &JCE) {
159 JCE.emitAlignment(4);
160 void *Addr = (void*) (JCE.getCurrentPCValue());
161 if (!sys::Memory::setRangeWritable(Addr, 16))
162 llvm_unreachable("ERROR: Unable to mark stub writable.");
163
164 intptr_t EmittedAddr;
165 if (Fn != (void*)(intptr_t)MipsCompilationCallback)
166 EmittedAddr = (intptr_t)Fn;
167 else
168 EmittedAddr = (intptr_t)MipsCompilationCallback;
169
170
171 int Hi = ((unsigned)EmittedAddr & 0xffff0000) >> 16;
172 if ((EmittedAddr & 0x8000) != 0)
173 Hi++;
174 int Lo = (int)(EmittedAddr & 0xffff);
175
176 // lui t9, %hi(EmittedAddr)
177 // addiu t9, t9, %lo(EmittedAddr)
178 // jalr t8, t9
179 // nop
180 JCE.emitWordLE(0xf << 26 | 25 << 16 | Hi);
181 JCE.emitWordLE(9 << 26 | 25 << 21 | 25 << 16 | Lo);
182 JCE.emitWordLE(25 << 21 | 24 << 11 | 9);
183 JCE.emitWordLE(0);
184
185 sys::Memory::InvalidateInstructionCache(Addr, 16);
186 if (!sys::Memory::setRangeExecutable(Addr, 16))
187 llvm_unreachable("ERROR: Unable to mark stub executable.");
188
189 return Addr;
190 }
191
192 /// relocate - Before the JIT can run a block of code that has been emitted,
193 /// it must rewrite the code to contain the actual addresses of any
194 /// referenced global symbols.
relocate(void * Function,MachineRelocation * MR,unsigned NumRelocs,unsigned char * GOTBase)195 void MipsJITInfo::relocate(void *Function, MachineRelocation *MR,
196 unsigned NumRelocs, unsigned char* GOTBase) {
197 for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
198
199 void *RelocPos = (char*) Function + MR->getMachineCodeOffset();
200 intptr_t ResultPtr = (intptr_t) MR->getResultPointer();
201
202 switch ((Mips::RelocationType) MR->getRelocationType()) {
203 case Mips::reloc_mips_branch:
204 ResultPtr = (((ResultPtr - (intptr_t) RelocPos) - 4) >> 2) & 0xffff;
205 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
206 break;
207
208 case Mips::reloc_mips_26:
209 ResultPtr = (ResultPtr & 0x0fffffff) >> 2;
210 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
211 break;
212
213 case Mips::reloc_mips_hi:
214 ResultPtr = ResultPtr >> 16;
215 if ((((intptr_t) (MR->getResultPointer()) & 0xffff) >> 15) == 1) {
216 ResultPtr += 1;
217 }
218 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
219 break;
220
221 case Mips::reloc_mips_lo:
222 ResultPtr = ResultPtr & 0xffff;
223 *((unsigned*) RelocPos) |= (unsigned) ResultPtr;
224 break;
225
226 default:
227 llvm_unreachable("ERROR: Unknown Mips relocation.");
228 }
229 }
230 }
231