[sockets] Fixed reading blocking flag
[mono.git] / mono / mini / tramp-ia64.c
1 /*
2  * tramp-ia64.c: JIT trampoline code for ia64
3  *
4  * Authors:
5  *   Zoltan Varga (vargaz@gmail.com)
6  *
7  * (C) 2001 Ximian, Inc.
8  */
9
10 #include <config.h>
11 #include <glib.h>
12
13 #include <mono/metadata/appdomain.h>
14 #include <mono/metadata/marshal.h>
15 #include <mono/metadata/tabledefs.h>
16 #include <mono/metadata/mono-debug-debugger.h>
17 #include <mono/arch/ia64/ia64-codegen.h>
18
19 #include "mini.h"
20 #include "mini-ia64.h"
21
22 #define GP_SCRATCH_REG 31
23 #define GP_SCRATCH_REG2 30
24
25 /*
26  * mono_arch_get_unbox_trampoline:
27  * @m: method pointer
28  * @addr: pointer to native code for @m
29  *
30  * when value type methods are called through the vtable we need to unbox the
31  * this argument. This method returns a pointer to a trampoline which does
32  * unboxing before calling the method
33  */
34 gpointer
35 mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
36 {
37         guint8 *buf;
38         gpointer func_addr, func_gp;
39         Ia64CodegenState code;
40         int this_reg = 0;
41         gpointer *desc;
42         MonoDomain *domain = mono_domain_get ();
43
44         /* FIXME: Optimize this */
45
46         func_addr = ((gpointer*)addr) [0];
47         func_gp = ((gpointer*)addr) [1];
48
49         buf = mono_domain_code_reserve (domain, 256);
50
51         /* Since the this reg is a stacked register, its a bit hard to access it */
52         ia64_codegen_init (code, buf);
53         ia64_alloc (code, 40, 8, 1, 0, 0);
54         ia64_adds_imm (code, 32 + this_reg, sizeof (MonoObject), 32 + this_reg);
55         ia64_mov_to_ar_i (code, IA64_PFS, 40);  
56         ia64_movl (code, GP_SCRATCH_REG, func_addr);
57         ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG);
58         ia64_br_cond_reg (code, IA64_B6);
59         ia64_codegen_close (code);
60
61         g_assert (code.buf - buf < 256);
62
63         mono_arch_flush_icache (buf, code.buf - buf);
64
65         /* FIXME: */
66         desc = g_malloc0 (sizeof (gpointer) * 2);
67         desc [0] = buf;
68         desc [1] = func_gp;
69
70         return desc;
71 }
72
73 void
74 mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr)
75 {
76         guint8 *callsite_begin;
77         guint64 *callsite = (guint64*)(gpointer)(code - 16);
78         guint64 *next_bundle;
79         guint64 ins, instructions [3];
80         guint64 buf [16];
81         Ia64CodegenState gen;
82         gpointer func = ((gpointer*)(gpointer)addr)[0];
83
84         while ((ia64_bundle_template (callsite) != IA64_TEMPLATE_MLX) &&
85                    (ia64_bundle_template (callsite) != IA64_TEMPLATE_MLXS))
86                 callsite -= 2;
87         callsite_begin = (guint8*)callsite;
88
89         next_bundle = callsite + 2;
90         ins = ia64_bundle_ins1 (next_bundle);
91         if (ia64_ins_opcode (ins) == 5) {
92                 /* ld8_inc_imm -> indirect call through a function pointer */
93                 g_assert (ia64_ins_r1 (ins) == GP_SCRATCH_REG2);
94                 g_assert (ia64_ins_r3 (ins) == GP_SCRATCH_REG);
95                 return;
96         }
97
98         /* Patch the code generated by emit_call */
99
100         instructions [0] = ia64_bundle_ins1 (callsite);
101         instructions [1] = ia64_bundle_ins2 (callsite);
102         instructions [2] = ia64_bundle_ins3 (callsite);
103
104         ia64_codegen_init (gen, (guint8*)buf);
105         ia64_movl (gen, GP_SCRATCH_REG, func);
106         instructions [1] = gen.instructions [0];
107         instructions [2] = gen.instructions [1];
108
109         ia64_codegen_init (gen, (guint8*)buf);
110         ia64_emit_bundle_template (&gen, ia64_bundle_template (callsite), instructions [0], instructions [1], instructions [2]);
111         ia64_codegen_close (gen);
112
113         /* This might not be safe, but not all itanium processors support st16 */
114         callsite [0] = buf [0];
115         callsite [1] = buf [1];
116
117         mono_arch_flush_icache (callsite_begin, code - callsite_begin);
118 }
119
120 void
121 mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
122 {
123         g_assert_not_reached ();
124 }
125
126 void
127 mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
128 {
129         guint8 *callsite_begin;
130         guint64 *callsite = (guint64*)(gpointer)(code - 16);
131         guint64 instructions [3];
132         guint64 buf [16];
133         Ia64CodegenState gen;
134
135         while ((ia64_bundle_template (callsite) != IA64_TEMPLATE_MLX) &&
136                    (ia64_bundle_template (callsite) != IA64_TEMPLATE_MLXS))
137                 callsite -= 2;
138         callsite_begin = (guint8*)callsite;
139
140         /* Replace the code generated by emit_call with a sets of nops */
141
142         /* The first bundle might have other instructions in it */
143         instructions [0] = ia64_bundle_ins1 (callsite);
144         instructions [1] = IA64_NOP_X;
145         instructions [2] = IA64_NOP_X;
146
147         ia64_codegen_init (gen, (guint8*)buf);
148         ia64_emit_bundle_template (&gen, ia64_bundle_template (callsite), instructions [0], instructions [1], instructions [2]);
149         ia64_codegen_close (gen);
150
151         /* This might not be safe, but not all itanium processors support st16 */
152         callsite [0] = buf [0];
153         callsite [1] = buf [1];
154
155         callsite += 2;
156
157         /* The other bundles can be full replaced with nops */
158
159         ia64_codegen_init (gen, (guint8*)buf);
160         ia64_emit_bundle_template (&gen, IA64_TEMPLATE_MII, IA64_NOP_M, IA64_NOP_I, IA64_NOP_I);
161         ia64_codegen_close (gen);
162
163         while ((guint8*)callsite < code) {
164                 callsite [0] = buf [0];
165                 callsite [1] = buf [1];
166                 callsite += 2;
167         }
168
169         mono_arch_flush_icache (callsite_begin, code - callsite_begin);
170 }
171
172 void
173 mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
174 {
175         g_assert_not_reached ();
176 }
177
178 guchar*
179 mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
180 {
181         guint8 *buf, *tramp;
182         int i, offset, saved_regs_offset, saved_fpregs_offset, last_offset, framesize;
183         int in0, local0, out0, l0, l1, l2, l3, l4, l5, l6, l7, l8, o0, o1, o2, o3;
184         gboolean has_caller;
185         Ia64CodegenState code;
186         unw_dyn_info_t *di;
187         unw_dyn_region_info_t *r_pro;
188
189         g_assert (!aot);
190         if (info)
191                 *info = NULL;
192
193         /* 
194          * Since jump trampolines are not patched, this trampoline is executed every
195          * time a call is made to a jump trampoline. So we try to keep things faster
196          * in that case.
197          */
198         if (tramp_type == MONO_TRAMPOLINE_JUMP)
199                 has_caller = FALSE;
200         else
201                 has_caller = TRUE;
202
203         buf = mono_global_codeman_reserve (2048);
204
205         ia64_codegen_init (code, buf);
206
207         /* Stacked Registers */
208         in0 = 32;
209         local0 = in0 + 8;
210         out0 = local0 + 16;
211         l0 = 40;
212         l1 = 41;
213         l2 = 42;
214         l3 = 43;
215         l4 = 44;
216         l5 = 45; /* saved ar.pfs */
217         l6 = 46; /* arg */
218         l7 = 47; /* code */
219         l8 = 48; /* saved sp */
220         o0 = out0 + 0; /* regs */
221         o1 = out0 + 1; /* code */
222         o2 = out0 + 2; /* arg */
223         o3 = out0 + 3; /* tramp */
224
225         framesize = (128 * 8) + 1024;
226         framesize = (framesize + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
227
228         /*
229          * Allocate a new register+memory stack frame.
230          * 8 input registers (the max used by the ABI)
231          * 16 locals
232          * 4 output (number of parameters passed to trampoline)
233          */
234         ia64_unw_save_reg (code, UNW_IA64_AR_PFS, UNW_IA64_GR + l5);
235         ia64_alloc (code, l5, local0 - in0, out0 - local0, 4, 0);
236         ia64_unw_save_reg (code, UNW_IA64_SP, UNW_IA64_GR + l8);
237         ia64_mov (code, l8, IA64_SP);
238         ia64_adds_imm (code, IA64_SP, (-framesize), IA64_SP);
239
240         offset = 16; /* scratch area */
241
242         /* Save the argument received from the specific trampoline */
243         ia64_mov (code, l6, GP_SCRATCH_REG);
244
245         /* Save the calling address */
246         ia64_unw_save_reg (code, UNW_IA64_RP, UNW_IA64_GR + local0 + 7);
247         ia64_mov_from_br (code, l7, IA64_B0);
248
249         /* Create unwind info for the prolog */
250         ia64_begin_bundle (code);
251         r_pro = mono_ia64_create_unwind_region (&code);
252
253         /* Save registers */
254         /* Not needed for jump trampolines */
255         if (tramp_type != MONO_TRAMPOLINE_JUMP) {
256                 saved_regs_offset = offset;
257                 offset += 128 * 8;
258                 /* 
259                  * Only the registers which are needed for computing vtable slots need
260                  * to be saved.
261                  */
262                 last_offset = -1;
263                 for (i = 0; i < 64; ++i)
264                         if ((1 << i) & MONO_ARCH_CALLEE_REGS) {
265                                 if (last_offset != i * 8)
266                                         ia64_adds_imm (code, l1, saved_regs_offset + (i * 8), IA64_SP);
267                                 ia64_st8_spill_inc_imm_hint (code, l1, i, 8, 0);
268                                 last_offset = (i + 1) * 8;
269                         }
270         }
271
272         /* Save fp registers */
273         saved_fpregs_offset = offset;
274         offset += 8 * 8;
275         ia64_adds_imm (code, l1, saved_fpregs_offset, IA64_SP);
276         for (i = 0; i < 8; ++i)
277                 ia64_stfd_inc_imm_hint (code, l1, i + 8, 8, 0);
278
279         g_assert (offset < framesize);
280
281         /* Arg1 is the pointer to the saved registers */
282         ia64_adds_imm (code, o0, saved_regs_offset, IA64_SP);
283
284         /* Arg2 is the address of the calling code */
285         if (has_caller)
286                 ia64_mov (code, o1, l7);
287         else
288                 ia64_mov (code, o1, 0);
289
290         /* Arg3 is the method/vtable ptr */
291         ia64_mov (code, o2, l6);
292
293         /* Arg4 is the trampoline address */
294         /* FIXME: */
295         ia64_mov (code, o3, 0);
296
297         tramp = (guint8*)mono_get_trampoline_func (tramp_type);
298
299         /* Call the trampoline using an indirect call */
300         ia64_movl (code, l0, tramp);
301         ia64_ld8_inc_imm (code, l1, l0, 8);
302         ia64_mov_to_br (code, IA64_B6, l1);
303         ia64_ld8 (code, IA64_GP, l0);
304         ia64_br_call_reg (code, 0, IA64_B6);
305
306         /* Check for thread interruption */
307         /* This is not perf critical code so no need to check the interrupt flag */
308         ia64_mov (code, l2, IA64_R8);
309
310         tramp = (guint8*)mono_thread_force_interruption_checkpoint;
311         ia64_movl (code, l0, tramp);
312         ia64_ld8_inc_imm (code, l1, l0, 8);
313         ia64_mov_to_br (code, IA64_B6, l1);
314         ia64_ld8 (code, IA64_GP, l0);
315         ia64_br_call_reg (code, 0, IA64_B6);
316
317         ia64_mov (code, IA64_R8, l2);
318
319         /* Restore fp regs */
320         ia64_adds_imm (code, l1, saved_fpregs_offset, IA64_SP);
321         for (i = 0; i < 8; ++i)
322                 ia64_ldfd_inc_imm (code, i + 8, l1, 8);
323
324         /* FIXME: Handle NATs in fp regs / scratch regs */
325
326         if (tramp_type != MONO_TRAMPOLINE_CLASS_INIT) {
327                 /* Load method address from function descriptor */
328                 ia64_ld8 (code, l0, IA64_R8);
329                 ia64_mov_to_br (code, IA64_B6, l0);
330         }
331
332         /* Clean up register/memory stack frame */
333         ia64_adds_imm (code, IA64_SP, framesize, IA64_SP);
334         ia64_mov_to_ar_i (code, IA64_PFS, l5);
335
336         if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) {
337                 ia64_mov_ret_to_br (code, IA64_B0, l7);
338                 ia64_br_ret_reg (code, IA64_B0);
339         }
340         else {
341                 /* Call the compiled method */
342                 ia64_mov_to_br (code, IA64_B0, l7);
343                 ia64_br_cond_reg (code, IA64_B6);
344         }
345
346         ia64_codegen_close (code);
347
348         g_assert ((code.buf - buf) <= 2048);
349
350         /* FIXME: emit unwind info for epilog */
351         di = g_malloc0 (sizeof (unw_dyn_info_t));
352         di->start_ip = (unw_word_t) buf;
353         di->end_ip = (unw_word_t) code.buf;
354         di->gp = 0;
355         di->format = UNW_INFO_FORMAT_DYNAMIC;
356         di->u.pi.name_ptr = (unw_word_t)"ia64_generic_trampoline";
357         di->u.pi.regions = r_pro;
358
359         _U_dyn_register (di);
360
361         mono_arch_flush_icache (buf, code.buf - buf);
362
363         return buf;
364 }
365
366 #define TRAMPOLINE_SIZE 128
367
368 gpointer
369 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
370 {
371         guint8 *buf, *tramp;
372         gint64 disp;
373         Ia64CodegenState code;
374
375         tramp = mono_get_trampoline_code (tramp_type);
376
377         buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE);
378
379         /* FIXME: Optimize this */
380
381         ia64_codegen_init (code, buf);
382
383         ia64_movl (code, GP_SCRATCH_REG, arg1);
384
385         ia64_begin_bundle (code);
386         disp = (tramp - code.buf) >> 4;
387         if (ia64_is_imm21 (disp)) {
388                 ia64_br_cond (code, disp);
389         }
390         else {
391                 ia64_movl (code, GP_SCRATCH_REG2, tramp);
392                 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
393                 ia64_br_cond_reg (code, IA64_B6);
394         }
395
396         ia64_codegen_close (code);
397
398         g_assert (code.buf - buf <= TRAMPOLINE_SIZE);
399
400         mono_arch_flush_icache (buf, code.buf - buf);
401
402         if (code_len)
403                 *code_len = code.buf - buf;
404
405         return buf;
406 }
407
408 void
409 mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg)
410 {
411         NOT_IMPLEMENTED;
412 }
413
414 gpointer
415 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
416 {
417         /* FIXME: implement! */
418         g_assert_not_reached ();
419         return NULL;
420 }