2 * tramp-hppa.c: JIT trampoline code for hppa
4 * Copyright (c) 2007 Randolph Chung
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 #include <mono/arch/hppa/hppa-codegen.h>
30 #include <mono/metadata/appdomain.h>
31 #include <mono/metadata/marshal.h>
32 #include <mono/metadata/tabledefs.h>
35 #include "mini-hppa.h"
37 /* sizeof (MonoLMF) == 320 + HPPA_STACK_LMF_OFFSET + linkage area (64 bytes)
38 * leave some room to spare
40 #define TRAMP_STACK_SIZE 512
41 /* Method-specific trampoline code fragment size */
42 #define METHOD_TRAMPOLINE_SIZE 128
43 /* Jump-specific trampoline code fragment size */
44 #define JUMP_TRAMPOLINE_SIZE 64
47 * mono_arch_get_unbox_trampoline:
48 * @gsctx: the generic sharing context
50 * @addr: pointer to native code for @m
52 * when value type methods are called through the vtable we need to unbox the
53 * this argument. This method returns a pointer to a trampoline which does
54 * unboxing before calling the method
57 mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
60 int this_pos = hppa_r26;
61 MonoDomain *domain = mono_domain_get ();
63 if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
66 mono_domain_lock (domain);
67 start = code = mono_code_manager_reserve (domain->code_mp, 20);
68 mono_domain_unlock (domain);
70 hppa_set (code, addr, hppa_r1);
71 hppa_ldo (code, sizeof (MonoObject), this_pos, this_pos);
72 hppa_bv (code, hppa_r0, hppa_r1);
75 mono_arch_flush_icache (start, code - start);
76 g_assert ((code - start) <= 20);
81 mono_arch_patch_callsite (guint8 *method_start, guint8 *p, guint8 *addr)
83 guint32 *code = (void *)p;
84 /* Search for and patch the calling sequence
88 * CEE_CALL outputs the following sequence:
92 * bb,>=,n r1, 30, .+16
98 * XXXXXXXXXXXXXXXX <- code points here
101 /* Go back to the branching insn */
104 /* We can patch the code only if it is a direct call. In some cases
105 * we can reach here via a reg-indirect call. In that case we can't
108 if ((code[0] >> 26) == 0x39 && /* ble */
109 (code[-4] >> 26) == 0x31 && /* bb */
110 (code[-6] >> 26) == 0x08) /* ldil */ {
111 hppa_patch (&code[-6], addr);
112 mono_arch_flush_icache (&code[-6], 8);
114 printf("Can't patch callsite!\n");
119 mono_arch_patch_plt_entry (guint8 *code, guint8 *addr)
121 g_assert_not_reached ();
125 mono_arch_nullify_class_init_trampoline (guint8 *code8, gssize *regs)
127 guint32 *buf = (guint32 *)((unsigned long)code8 & ~3);
131 if (code[0] == 0x08000240) /* nop - already nullified */
133 g_assert ((code[0] >> 26) == 0x39); /* ble */
137 mono_arch_flush_icache (buf, 8);
142 mono_arch_nullify_plt_entry (guint8 *code)
144 g_assert_not_reached ();
147 #define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
150 * Stack frame description when the generic trampoline is called.
152 * --------------------
154 * -------------------
155 * incoming argument registers
156 * -------------------
158 * -------------------
161 mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
163 guint8 *buf, *code = NULL;
166 code = buf = mono_global_codeman_reserve (1024);
168 /* Trampoline is called with "method" in r20 */
169 hppa_stw (buf, hppa_r2, -20, hppa_sp);
170 hppa_copy (buf, hppa_sp, hppa_r1);
171 hppa_ldo (buf, TRAMP_STACK_SIZE, hppa_sp, hppa_sp);
173 /* Save the MonoLMF structure on the stack */
174 offset = HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, regs);
175 for (i = 0; i < 32; i++) {
176 if (HPPA_IS_SAVED_GREG (i)) {
177 hppa_stw (buf, i, offset, hppa_r1);
178 offset += sizeof(ulong);
181 hppa_copy (buf, hppa_r1, hppa_r3);
182 hppa_set (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, fregs), hppa_r1);
183 for (i = 0; i < 32; i++) {
184 if (HPPA_IS_SAVED_FREG (i)) {
185 hppa_fstdx (buf, i, hppa_r1, hppa_r3);
186 hppa_ldo (buf, sizeof(double), hppa_r1, hppa_r1);
189 /* Save the method info stored in r20 */
190 hppa_stw (buf, hppa_r20, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, method), hppa_r3);
191 hppa_stw (buf, hppa_r3, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, ebp), hppa_sp);
192 if (tramp_type == MONO_TRAMPOLINE_JUMP) {
193 hppa_stw (buf, hppa_r0, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, eip), hppa_r3);
195 hppa_stw (buf, hppa_r2, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, eip), hppa_r3);
198 /* Save the incoming arguments too, before they can trashed by the
199 * call to the magic trampoline
201 offset = HPPA_STACK_LMF_OFFSET + sizeof (MonoLMF);
202 for (i = hppa_r23; i <= hppa_r26; i++) {
203 hppa_stw (buf, i, offset, hppa_r3);
204 offset += sizeof(ulong);
206 hppa_stw (buf, hppa_r28, offset, hppa_r3);
207 offset += sizeof(ulong);
208 offset = ALIGN_TO (offset, sizeof(double));
209 hppa_ldo (buf, offset, hppa_r3, hppa_r1);
210 for (i = hppa_fr4; i <= hppa_fr7; i++) {
211 hppa_fstds (buf, i, 0, hppa_r1);
212 hppa_ldo (buf, sizeof(double), hppa_r1, hppa_r1);
215 /* Call mono_get_lmf_addr */
216 hppa_set (buf, mono_get_lmf_addr, hppa_r1);
217 hppa_depi (buf, 0, 31, 2, hppa_r1);
218 hppa_ldw (buf, 0, hppa_r1, hppa_r1);
219 hppa_ble (buf, 0, hppa_r1);
220 hppa_copy (buf, hppa_r31, hppa_r2);
222 /* r28 now points at the (MonoLMF **) for the current thread. */
224 /* new_lmf->lmf_addr = lmf_addr */
225 hppa_stw (buf, hppa_r28, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, lmf_addr), hppa_r3);
227 /* new_lmf->previous_lmf = *lmf_addr */
228 hppa_ldw (buf, 0, hppa_r28, hppa_r1);
229 hppa_stw (buf, hppa_r1, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, previous_lmf), hppa_r3);
230 /* *lmf_addr = new_lmf */
231 hppa_ldo (buf, HPPA_STACK_LMF_OFFSET, hppa_r3, hppa_r1);
232 hppa_stw (buf, hppa_r1, 0, hppa_r28);
234 /* Call mono_magic_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8* tramp) */
235 hppa_ldo (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, regs), hppa_r3, hppa_r26);
236 hppa_ldw (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, method), hppa_r3, hppa_r24);
237 if (tramp_type == MONO_TRAMPOLINE_JUMP)
238 hppa_copy (buf, hppa_r0, hppa_r25);
240 hppa_ldw (buf, -20, hppa_r3, hppa_r25);
241 /* clear the lower two (privilege) bits */
242 hppa_depi (buf, 0, 31, 2, hppa_r25);
244 hppa_copy (buf, hppa_r0, hppa_r23);
246 if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
247 hppa_set (buf, mono_class_init_trampoline, hppa_r1);
249 hppa_set (buf, mono_magic_trampoline, hppa_r1);
251 hppa_depi (buf, 0, 31, 2, hppa_r1);
252 hppa_ldw (buf, 0, hppa_r1, hppa_r1);
253 hppa_ble (buf, 0, hppa_r1);
254 hppa_copy (buf, hppa_r31, hppa_r2);
256 /* Code address is now in r28 */
259 hppa_ldw (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, previous_lmf), hppa_r3, hppa_r20);
260 hppa_ldw (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, lmf_addr), hppa_r3, hppa_r21);
261 hppa_stw (buf, hppa_r20, 0, hppa_r21);
263 hppa_copy (buf, hppa_r28, hppa_r20);
265 /* Restore arguments */
266 offset = HPPA_STACK_LMF_OFFSET + sizeof (MonoLMF);
267 for (i = hppa_r23; i <= hppa_r26; i++) {
268 hppa_ldw (buf, offset, hppa_r3, i);
269 offset += sizeof(ulong);
271 hppa_ldw (buf, offset, hppa_r3, hppa_r28);
272 offset += sizeof(ulong);
273 offset = ALIGN_TO (offset, sizeof(double));
274 hppa_ldo (buf, offset, hppa_r3, hppa_r1);
275 for (i = hppa_fr4; i <= hppa_fr7; i++) {
276 hppa_fldds (buf, 0, hppa_r1, i);
277 hppa_ldo (buf, sizeof(double), hppa_r1, hppa_r1);
280 /* Restore registers */
281 hppa_set (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, fregs), hppa_r1);
282 for (i = 0; i < 32; i++) {
283 if (HPPA_IS_SAVED_FREG (i)) {
284 hppa_flddx (buf, hppa_r1, hppa_r3, i);
285 hppa_ldo (buf, sizeof(double), hppa_r1, hppa_r1);
289 hppa_copy (buf, hppa_r3, hppa_r1);
290 offset = HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, regs);
291 for (i = 0; i < 32; i++) {
292 if (HPPA_IS_SAVED_GREG (i)) {
293 hppa_ldw (buf, offset, hppa_r1, i);
294 offset += sizeof(ulong);
297 /* Jump to the compiled code in hppa_r28 */
298 hppa_ldw (buf, -20, hppa_r1, hppa_r2);
299 hppa_bv (buf, hppa_r0, hppa_r20);
300 hppa_ldo (buf, -TRAMP_STACK_SIZE, hppa_sp, hppa_sp);
302 g_assert ((buf - code) <= 1024);
307 * mono_arch_create_class_init_trampoline:
308 * @vtable: the type to initialize
310 * Creates a trampoline function to run a type initializer.
311 * If the trampoline is called, it calls mono_runtime_class_init with the
312 * given vtable, then patches the caller code so it does not get called any
315 * Returns: a pointer to the newly created code
318 mono_arch_create_class_init_trampoline (MonoVTable *vtable)
320 guint8 *code, *buf, *tramp;
321 tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_CLASS_INIT);
322 /* This is the method-specific part of the trampoline. Its purpose is
323 to provide the generic part with the MonoMethod *method pointer. */
324 mono_domain_lock (vtable->domain);
325 code = buf = mono_code_manager_reserve (vtable->domain->code_mp, METHOD_TRAMPOLINE_SIZE);
326 mono_domain_unlock (vtable->domain);
328 hppa_stw (buf, hppa_r2, -20, hppa_sp);
329 hppa_copy (buf, hppa_r3, hppa_r1);
330 hppa_copy (buf, hppa_sp, hppa_r3);
331 hppa_stwm (buf, hppa_r1, 64, hppa_sp);
333 /* mono_class_init_trampoline (regs, code, vtable, tramp) */
334 hppa_copy (buf, hppa_r0, hppa_r26);
335 hppa_copy (buf, hppa_r2, hppa_r25);
336 hppa_set (buf, vtable, hppa_r24);
337 hppa_copy (buf, hppa_r0, hppa_r23);
339 hppa_set (buf, mono_class_init_trampoline, hppa_r1);
340 hppa_depi (buf, 0, 31, 2, hppa_r1);
341 hppa_ldw (buf, 0, hppa_r1, hppa_r1);
342 hppa_ble (buf, 0, hppa_r1);
343 hppa_copy (buf, hppa_r31, hppa_r2);
345 hppa_ldw (buf, -20, hppa_r3, hppa_r2);
346 hppa_ldo (buf, 64, hppa_r3, hppa_sp);
347 hppa_bv (buf, hppa_r0, hppa_r2);
348 hppa_ldwm (buf, -64, hppa_sp, hppa_r3);
350 /* Flush instruction cache, since we've generated code */
351 mono_arch_flush_icache (code, buf - code);
354 g_assert ((buf - code) <= METHOD_TRAMPOLINE_SIZE);
356 mono_jit_stats.method_trampolines++;
362 create_specific_tramp (MonoMethod *method, guint8* tramp, MonoDomain *domain)
367 mono_domain_lock (domain);
368 code = buf = mono_code_manager_reserve (domain->code_mp, 20);
369 mono_domain_unlock (domain);
371 /* Call trampoline, with the "method" pointer in r20 */
372 hppa_set (buf, tramp, hppa_r1);
373 hppa_ldil (buf, hppa_lsel (method), hppa_r20);
374 hppa_bv (buf, hppa_r0, hppa_r1);
375 hppa_ldo (buf, hppa_rsel (method), hppa_r20, hppa_r20);
377 /* Flush instruction cache, since we've generated code */
378 mono_arch_flush_icache (code, buf - code);
380 g_assert ((buf - code) <= 20);
382 ji = g_new0 (MonoJitInfo, 1);
384 ji->code_start = code;
385 ji->code_size = buf - code;
387 mono_jit_stats.method_trampolines++;
394 mono_arch_create_jump_trampoline (MonoMethod *method)
397 MonoDomain* domain = mono_domain_get ();
399 tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_JUMP);
400 return create_specific_tramp (method, tramp, domain);
404 * arch_create_jit_trampoline:
405 * @method: pointer to the method info
407 * Creates a trampoline function for virtual methods. If the created
408 * code is called it first starts JIT compilation of method,
409 * and then calls the newly created method. It also replaces the
410 * corresponding vtable entry (see mono_magic_trampoline).
412 * A trampoline consists of two parts: a main fragment, shared by all method
413 * trampolines, and some code specific to each method, which hard-codes a
414 * reference to that method and then calls the main fragment.
416 * The main fragment contains a call to 'arm_magic_trampoline', which performs
417 * call to the JIT compiler and substitutes the method-specific fragment with
418 * some code that directly calls the JIT-compiled method.
420 * Returns: a pointer to the newly created code
423 mono_arch_create_jit_trampoline (MonoMethod *method)
427 MonoDomain* domain = mono_domain_get ();
430 tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_JIT);
431 ji = create_specific_tramp (method, tramp, domain);
432 code_start = ji->code_start;
439 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 encoded_offset)
441 /* FIXME: implement! */
442 g_assert_not_reached ();