?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Slight soptimization for utf8/latin1 decoding
[mono-project/dkf.git] / mono / arch / hppa / tramp.c
blobe012436df29064cd145e49e24a2b2698cf473768
1 /*
2 Copyright (c) 2003 Bernie Solomon <bernard@ugsolutions.com>
3
4 Permission is hereby granted, free of charge, to any person obtaining
5 a copy of this software and associated documentation files (the
6 "Software"), to deal in the Software without restriction, including
7 without limitation the rights to use, copy, modify, merge, publish,
8 distribute, sublicense, and/or sell copies of the Software, and to
9 permit persons to whom the Software is furnished to do so, subject to
10 the following conditions:
11
12 The above copyright notice and this permission notice shall be
13 included in all copies or substantial portions of the Software.
14
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22
23
24 Trampoline generation for HPPA - currently (Oct 9th 2003) only
25 supports 64 bits - and the HP compiler.
26 */
27 #ifndef __linux__
28
29 #include "mono/interpreter/interp.h"
30 #include "mono/metadata/appdomain.h"
31 #include "mono/metadata/tabledefs.h"
32 #include "hppa-codegen.h"
33
34 #if SIZEOF_VOID_P != 8
35 #error "HPPA code only currently supports 64bit pointers"
36 #endif
37
38 // debugging flag which dumps code generated
39 static int debug_asm = 0;
40
41
42 static void flush_cache(void *address, int length)
43 {
44 #ifdef __GNUC__
45 #error "currently only supports the HP C compiler"
46 #else
47 int cache_line_size = 16;
48 ulong_t end = (ulong_t)address + length;
49 register ulong_t sid;
50 register ulong_t offset = (ulong_t) address;
51 register ulong_t r0 = 0;
52
53 _asm("LDSID", 0, offset, sid);
54 _asm("MTSP", sid, 0);
55 _asm("FDC", r0, 0, offset);
56 offset = (offset + (cache_line_size - 1)) & ~(cache_line_size - 1);
57 while (offset < end) {
58 (void)_asm("FDC", r0, 0, offset);
59 offset += cache_line_size;
60 }
61 _asm("SYNC");
62 offset = (ulong_t) address;
63 _asm("FIC", r0, 0, offset);
64 offset = (offset + (cache_line_size - 1)) & ~(cache_line_size - 1);
65 while (offset < end) {
66 (void)_asm("FIC", r0, 0, offset);
67 offset += cache_line_size;
68 }
69 _asm("SYNC");
70 // sync needs at least 7 instructions after it... this is what is used for NOP
71 _asm("OR", 0, 0, 0);
72 _asm("OR", 0, 0, 0);
73 _asm("OR", 0, 0, 0);
74 _asm("OR", 0, 0, 0);
75 _asm("OR", 0, 0, 0);
76 _asm("OR", 0, 0, 0);
77 _asm("OR", 0, 0, 0);
78 #endif
79 }
80
81 static void disassemble (guint32 *code, int n_instrs)
82 {
83 const char *tmp_file = "/tmp/mono_adb.in";
84 FILE *fp = fopen(tmp_file, "w");
85 int i;
86 for (i = 0; i < n_instrs; i++)
87 fprintf(fp, "0x%08x=i\n", code[i]);
88 fprintf(fp, "$q\n");
89 fclose(fp);
90 system("adb64 </tmp/mono_adb.in");
91 unlink(tmp_file);
92 }
93
94 #define ADD_INST(code, pc, gen_exp) \
95 do { if ((code) == NULL) (pc)++; else { gen_exp; pc++; } } while (0)
96
97 /*
98 * void func (void (*callme)(), void *retval, void *this_obj, stackval *arguments);
99 */
100
101 MonoPIFunc
102 mono_arch_create_trampoline (MonoMethodSignature *sig, gboolean string_ctor)
103 {
104 int pc, save_pc;
105 int param;
106 void **descriptor;
107 unsigned int *code = NULL;
108 unsigned int *code_start = NULL;
109 int arg_reg;
110 #define FP_ARG_REG(r) (4 + (26 - arg_reg))
111 int arg_offset;
112 int frame_size = 0;
113 int spill_offset;
114 int parameter_offset;
115 int parameter_slot;
116 int args_on_stack;
117
118 if (debug_asm) {
119 fprintf(stderr, "trampoline: # params %d has this %d exp this %d string %d, ret type %d\n",
120 sig->param_count, sig->hasthis, sig->explicit_this, string_ctor, sig->ret->type);
121 }
122
123 // everything takes 8 bytes unless it is a bigger struct
124 for (param = 0; param < sig->param_count; param++) {
125 if (sig->params[param]->byref)
126 frame_size += 8;
127 else {
128 if (sig->params[param]->type != MONO_TYPE_VALUETYPE)
129 frame_size += 8;
130 else {
131 if (sig->params [param]->data.klass->enumtype)
132 frame_size += 8;
133 else {
134 frame_size += 15; // large structs are 16 byte aligned
135 frame_size &= ~15;
136 frame_size += mono_class_native_size (sig->params [param]->data.klass, NULL);
137 frame_size += 7;
138 frame_size &= ~7;
139 }
140 }
141 }
142 }
143
144 if (sig->hasthis)
145 frame_size += 8;
146 // 16 byte alignment
147 if ((frame_size & 15) != 0)
148 frame_size += 8;
149 // minimum is 64 bytes
150 if (frame_size < 64)
151 frame_size = 64;
152
153 if (debug_asm)
154 fprintf(stderr, "outgoing frame size: %d\n", frame_size);
155
156 frame_size += 16; // for the frame marker (called routines stuff return address etc. here)
157 frame_size += 32; // spill area for r4, r5 and r27 (16 byte aligned)
158
159 spill_offset = -frame_size;
160 parameter_offset = spill_offset + 32; // spill area size is really 24
161 spill_offset += 8;
162
163 /* the rest executes twice - once to count instructions so we can
164 allocate memory in one block and once to fill it in... the count
165 should be pretty fast anyway...
166 */
167 generate:
168 pc = 0;
169 arg_reg = 26;
170 arg_offset = 0;
171 args_on_stack = 0;
172 parameter_slot = parameter_offset;
173
174 ADD_INST(code, pc, hppa_std(code, 2, -16, 30)); // STD %r2,-16(%r30)
175 ADD_INST(code, pc, hppa_std_ma(code, 3, frame_size, 30));
176 ADD_INST(code, pc, hppa_std(code, 4, spill_offset, 30));
177 ADD_INST(code, pc, hppa_std(code, 5, spill_offset + 8, 30));
178 ADD_INST(code, pc, hppa_copy(code, 29, 3)); // COPY %r29,%r3
179 ADD_INST(code, pc, hppa_std(code, 27, spill_offset + 16, 30));
180 ADD_INST(code, pc, hppa_nop(code)); // NOP
181
182 ADD_INST(code, pc, hppa_std(code, 26, -64, 29)); // STD %r26,-64(%r29) callme
183 ADD_INST(code, pc, hppa_std(code, 25, -56, 29)); // STD %r25,-56(%r29) retval
184 ADD_INST(code, pc, hppa_std(code, 24, -48, 29)); // STD %r24,-48(%r29) this_obj
185 ADD_INST(code, pc, hppa_std(code, 23, -40, 29)); // STD %r23,-40(%r29) arguments
186
187 if (sig->param_count > 0)
188 ADD_INST(code, pc, hppa_copy(code, 23, 4)); // r4 is the current pointer to the stackval array of args
189
190 if (sig->hasthis) {
191 if (sig->call_convention != MONO_CALL_THISCALL) {
192 ADD_INST(code, pc, hppa_copy(code, 24, arg_reg));
193 --arg_reg;
194 parameter_slot += 8;
195 } else {
196 fprintf(stderr, "case I didn't handle\n");
197 }
198 }
199
200 for (param = 0; param < sig->param_count; param++) {
201 int type = sig->params[param]->type;
202 if (sig->params[param]->byref) {
203 if (args_on_stack) {
204 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, 5));
205 ADD_INST(code, pc, hppa_std(code, 5, parameter_slot, 30));
206 } else {
207 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, arg_reg));
208 --arg_reg;
209 }
210 arg_offset += sizeof(stackval);
211 parameter_slot += 8;
212 continue;
213 }
214 typeswitch:
215 switch (type) {
216 case MONO_TYPE_CHAR:
217 case MONO_TYPE_BOOLEAN:
218 case MONO_TYPE_I1:
219 case MONO_TYPE_U1:
220 case MONO_TYPE_I2:
221 case MONO_TYPE_U2:
222 case MONO_TYPE_I4:
223 case MONO_TYPE_U4:
224 if (args_on_stack) {
225 ADD_INST(code, pc, hppa_ldw(code, arg_offset, 4, 5));
226 switch (type) {
227 case MONO_TYPE_I4:
228 case MONO_TYPE_U4:
229 ADD_INST(code, pc, hppa_stw(code, 5, parameter_slot + 4, 30));
230 break;
231 case MONO_TYPE_CHAR:
232 case MONO_TYPE_I2:
233 case MONO_TYPE_U2:
234 ADD_INST(code, pc, hppa_sth(code, 5, parameter_slot + 6, 30));
235 break;
236 case MONO_TYPE_BOOLEAN:
237 case MONO_TYPE_I1:
238 case MONO_TYPE_U1:
239 ADD_INST(code, pc, hppa_stb(code, 5, parameter_slot + 7, 30));
240 break;
241 }
242 } else {
243 ADD_INST(code, pc, hppa_ldw(code, arg_offset, 4, arg_reg));
244 --arg_reg;
245 }
246 arg_offset += sizeof(stackval);
247 parameter_slot += 8;
248 break;
249 case MONO_TYPE_I8:
250 case MONO_TYPE_U8:
251 case MONO_TYPE_I:
252 case MONO_TYPE_U:
253 case MONO_TYPE_STRING:
254 case MONO_TYPE_OBJECT:
255 case MONO_TYPE_CLASS:
256 case MONO_TYPE_SZARRAY:
257 case MONO_TYPE_PTR:
258 if (args_on_stack) {
259 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, 5));
260 ADD_INST(code, pc, hppa_std(code, 5, parameter_slot, 30));
261 } else {
262 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, arg_reg));
263 --arg_reg;
264 }
265 arg_offset += sizeof(stackval);
266 parameter_slot += 8;
267 break;
268 case MONO_TYPE_R8:
269 if (args_on_stack) {
270 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, 5));
271 ADD_INST(code, pc, hppa_std(code, 5, parameter_slot, 30));
272 } else {
273 ADD_INST(code, pc, hppa_fldd(code, arg_offset, 4, FP_ARG_REG(arg_reg)));
274 --arg_reg;
275 }
276 arg_offset += sizeof(stackval);
277 parameter_slot += 8;
278 break;
279 case MONO_TYPE_R4:
280 if (args_on_stack) {
281 ADD_INST(code, pc, hppa_fldd(code, arg_offset, 4, 22));
282 ADD_INST(code, pc, hppa_fcnv_dbl_sng(code, 22, 22));
283 ADD_INST(code, pc, hppa_fstw(code, 22, parameter_slot + 4, 30));
284 } else {
285 ADD_INST(code, pc, hppa_fldd(code, arg_offset, 4, FP_ARG_REG(arg_reg)));
286 ADD_INST(code, pc, hppa_fcnv_dbl_sng(code, FP_ARG_REG(arg_reg), FP_ARG_REG(arg_reg)));
287 --arg_reg;
288 }
289 arg_offset += sizeof(stackval);
290 parameter_slot += 8;
291 break;
292 case MONO_TYPE_VALUETYPE:
293 if (sig->params [param]->data.klass->enumtype) {
294 type = sig->params [param]->data.klass->enum_basetype->type;
295 goto typeswitch;
296 } else {
297 int size = mono_class_native_size (sig->params [param]->data.klass, NULL);
298 // assumes struct is 8 byte aligned whatever its size... (as interp.c guarantees at present)
299 // copies multiple of 8 bytes which may include some trailing garbage but should be safe
300 if (size <= 8) {
301 if (args_on_stack) {
302 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, 5));
303 ADD_INST(code, pc, hppa_ldd(code, 0, 5, 5));
304 ADD_INST(code, pc, hppa_std(code, 5, parameter_slot, 30));
305 } else {
306 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, arg_reg));
307 ADD_INST(code, pc, hppa_ldd(code, 0, arg_reg, arg_reg));
308 --arg_reg;
309 }
310 parameter_slot += 8;
311 } else {
312 int soffset = 0;
313 if ((parameter_slot & 15) != 0) {
314 --arg_reg;
315 if (arg_reg < 19) {
316 args_on_stack = 1;
317 }
318 parameter_slot += 8;
319 }
320 ADD_INST(code, pc, hppa_ldd(code, arg_offset, 4, 5));
321 // might generate a lot of code for very large structs... should
322 // use a loop or routine call them
323 while (size > 0) {
324 if (args_on_stack) {
325 ADD_INST(code, pc, hppa_ldd(code, soffset, 5, 31));
326 ADD_INST(code, pc, hppa_std(code, 31, parameter_slot, 30));
327 } else {
328 ADD_INST(code, pc, hppa_ldd(code, soffset, 5, arg_reg));
329 --arg_reg;
330 if (arg_reg < 19)
331 args_on_stack = 1;
332 }
333 parameter_slot += 8;
334 soffset += 8;
335 size -= 8;
336 }
337 }
338 arg_offset += sizeof(stackval);
339 break;
340 }
341 break;
342 default:
343 g_error ("mono_create_trampoline: unhandled arg type %d", type);
344 return NULL;
345 }
346
347 if (arg_reg < 19) {
348 args_on_stack = 1;
349 }
350 }
351
352 // for large return structs just pass on the buffer given to us.
353 if (sig->ret->type == MONO_TYPE_VALUETYPE && sig->ret->data.klass->enumtype == 0) {
354 int size = mono_class_native_size (sig->ret->data.klass, NULL);
355 if (size > 16) {
356 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 28));
357 ADD_INST(code, pc, hppa_ldd(code, 0, 28, 28));
358 }
359 }
360
361 ADD_INST(code, pc, hppa_nop(code)); // NOP
362 ADD_INST(code, pc, hppa_ldd(code, -64, 29, 5));
363 ADD_INST(code, pc, hppa_ldd(code, 24, 5, 27));
364 ADD_INST(code, pc, hppa_ldd(code, 16, 5, 5));
365 ADD_INST(code, pc, hppa_blve(code, 5));
366 ADD_INST(code, pc, hppa_ldo(code, parameter_offset + 64, 30, 29));
367 ADD_INST(code, pc, hppa_ldd(code, spill_offset + 16, 30, 27));
368 ADD_INST(code, pc, hppa_nop(code)); // NOP
369
370 if (string_ctor) {
371 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
372 ADD_INST(code, pc, hppa_std(code, 28, 0, 19)); // STD %r28,0(%r19)
373 }
374 else if (sig->ret->type != MONO_TYPE_VOID) {
375 int type = sig->ret->type;
376
377 rettypeswitch:
378 switch (type) {
379 case MONO_TYPE_BOOLEAN:
380 case MONO_TYPE_I1:
381 case MONO_TYPE_U1:
382 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
383 ADD_INST(code, pc, hppa_stb(code, 28, 0, 19)); // STB %r28,0(%r19)
384 break;
385 case MONO_TYPE_I4:
386 case MONO_TYPE_U4:
387 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
388 ADD_INST(code, pc, hppa_stw(code, 28, 0, 19)); // STW %r28,0(%r19)
389 break;
390 case MONO_TYPE_CHAR:
391 case MONO_TYPE_I2:
392 case MONO_TYPE_U2:
393 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
394 ADD_INST(code, pc, hppa_sth(code, 28, 0, 19)); // STH %r28,0(%r19)
395 break;
396 case MONO_TYPE_I8:
397 case MONO_TYPE_U8:
398 case MONO_TYPE_I:
399 case MONO_TYPE_U:
400 case MONO_TYPE_STRING:
401 case MONO_TYPE_OBJECT:
402 case MONO_TYPE_CLASS:
403 case MONO_TYPE_SZARRAY:
404 case MONO_TYPE_PTR:
405 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
406 ADD_INST(code, pc, hppa_std(code, 28, 0, 19)); // STD %r28,0(%r19)
407 break;
408 case MONO_TYPE_R8:
409 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
410 ADD_INST(code, pc, hppa_fstd(code, 4, 0, 19)); // FSTD %fr4,0(%r19)
411 break;
412 case MONO_TYPE_R4:
413 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19)); // LDD -56(%r3),%r19
414 ADD_INST(code, pc, hppa_fstw(code, 4, 0, 19)); // FSTW %fr4r,0(%r19)
415 break;
416 case MONO_TYPE_VALUETYPE:
417 if (sig->ret->data.klass->enumtype) {
418 type = sig->ret->data.klass->enum_basetype->type;
419 goto rettypeswitch;
420 } else {
421 int size = mono_class_native_size (sig->ret->data.klass, NULL);
422 if (size <= 16) {
423 int reg = 28;
424 int off = 0;
425 ADD_INST(code, pc, hppa_ldd(code, -56, 3, 19));
426 ADD_INST(code, pc, hppa_ldd(code, 0, 19, 19));
427 if (size > 8) {
428 ADD_INST(code, pc, hppa_std(code, 28, 0, 19));
429 size -= 8;
430 reg = 29;
431 off += 8;
432 }
433 // get rest of value right aligned in the register
434 ADD_INST(code, pc, hppa_extrdu(code, reg, 8 * size - 1, 8 * size, reg));
435 if ((size & 1) != 0) {
436 ADD_INST(code, pc, hppa_stb(code, reg, off + size - 1, 19));
437 ADD_INST(code, pc, hppa_extrdu(code, reg, 55, 56, reg));
438 size -= 1;
439 }
440 if ((size & 2) != 0) {
441 ADD_INST(code, pc, hppa_sth(code, reg, off + size - 2, 19));
442 ADD_INST(code, pc, hppa_extrdu(code, reg, 47, 48, reg));
443 size -= 2;
444 }
445 if ((size & 4) != 0)
446 ADD_INST(code, pc, hppa_stw(code, reg, off + size - 4, 19));
447 }
448 break;
449 }
450 default:
451 g_error ("mono_create_trampoline: unhandled ret type %d", type);
452 return NULL;
453 }
454 }
455
456 ADD_INST(code, pc, hppa_ldd(code, -frame_size-16, 30, 2));
457 ADD_INST(code, pc, hppa_ldd(code, spill_offset, 30, 4));
458 ADD_INST(code, pc, hppa_ldd(code, spill_offset + 8, 30, 5));
459 ADD_INST(code, pc, hppa_bve(code, 2, 0));
460 ADD_INST(code, pc, hppa_ldd_mb(code, -frame_size, 30, 3));
461
462 if (code == NULL) {
463 descriptor = (void **)g_malloc(4 * sizeof(void *) + pc * sizeof(unsigned int));
464 code = (unsigned int *)((char *)descriptor + 4 * sizeof(void *));
465 code_start = code;
466 save_pc = pc;
467 goto generate;
468 } else
469 g_assert(pc == save_pc);
470
471 if (debug_asm) {
472 fprintf(stderr, "generated: %d bytes\n", pc * 4);
473 disassemble(code_start, pc);
474 }
475
476 // must do this so we can actually execute the code we just put in memory
477 flush_cache(code_start, 4 * pc);
478
479 descriptor[0] = 0;
480 descriptor[1] = 0;
481 descriptor[2] = code_start;
482 descriptor[3] = 0;
483
484 return (MonoPIFunc)descriptor;
485 }
486
487 void *
488 mono_arch_create_method_pointer (MonoMethod *method)
489 {
490 MonoMethodSignature *sig = method->signature;
491 MonoJitInfo *ji;
492 int i;
493 int pc;
494 int param;
495 void **descriptor = NULL;
496 void **data = NULL;
497 unsigned int *code = NULL;
498 unsigned int *code_start = NULL;
499 int arg_reg = 26;
500 int arg_offset = 0;
501 int frame_size;
502 int invoke_rec_offset;
503 int stack_vals_offset;
504 int stack_val_pos;
505 int arg_val_pos;
506 int spill_offset;
507 int *vtoffsets;
508 int t;
509
510 if (debug_asm) {
511 fprintf(stderr, "mono_create_method_pointer %s: flags %d\n", method->name, method->flags);
512 fprintf(stderr, "method: # params %d has this %d exp this %d\n", sig->param_count, sig->hasthis, sig->explicit_this);
513 fprintf(stderr, "ret %d\n", sig->ret->type);
514 for (i = 0; i < sig->param_count; i++)
515 fprintf(stderr, "%d: %d\n", i, sig->params[i]->type);
516 }
517
518 // the extra stackval is for the return val if necessary
519 // the 64 is for outgoing parameters and the 16 is the frame marker.
520 // the other 16 is space for struct return vals < 16 bytes
521 frame_size = sizeof(MonoInvocation) + (sig->param_count + 1) * sizeof(stackval) + 16 + 64 + 16;
522 frame_size += 15;
523 frame_size &= ~15;
524 invoke_rec_offset = -frame_size;
525 vtoffsets = (int *)alloca(sig->param_count * sizeof(int));
526
527 t = invoke_rec_offset;
528
529 for (i = 0; i < sig->param_count; ++i)
530 if (sig->params[i]->type == MONO_TYPE_VALUETYPE &&
531 !sig->params[i]->data.klass->enumtype && !sig->params[i]->byref) {
532 int size = mono_class_native_size (sig->params[i]->data.klass, NULL);
533 size += 7;
534 size &= ~7;
535 t -= size;
536 frame_size += size;
537 vtoffsets[i] = t;
538 }
539
540 stack_vals_offset = invoke_rec_offset + sizeof(MonoInvocation);
541 stack_vals_offset += 7;
542 stack_vals_offset &= ~7;
543 frame_size += 32;
544 frame_size += 15;
545 frame_size &= ~15;
546 spill_offset = -frame_size + 8;
547
548 generate:
549 stack_val_pos = stack_vals_offset;
550 arg_val_pos = -64;
551 pc = 0;
552
553 ADD_INST(code, pc, hppa_std(code, 2, -16, 30));
554 ADD_INST(code, pc, hppa_std_ma(code, 3, frame_size, 30));
555 ADD_INST(code, pc, hppa_std(code, 4, spill_offset, 30));
556 ADD_INST(code, pc, hppa_copy(code, 29, 3));
557 ADD_INST(code, pc, hppa_std(code, 27, spill_offset + 8, 30));
558 ADD_INST(code, pc, hppa_std(code, 28, spill_offset + 16, 30));
559 ADD_INST(code, pc, hppa_nop(code));
560
561 ADD_INST(code, pc, hppa_std(code, 26, -64, 29)); // STD %r26,-64(%r29)
562 ADD_INST(code, pc, hppa_std(code, 25, -56, 29)); // STD %r25,-56(%r29)
563 ADD_INST(code, pc, hppa_std(code, 24, -48, 29)); // STD %r24,-48(%r29)
564 ADD_INST(code, pc, hppa_std(code, 23, -40, 29)); // STD %r23,-40(%r29)
565 ADD_INST(code, pc, hppa_std(code, 22, -32, 29)); // STD %r22,-32(%r29)
566 ADD_INST(code, pc, hppa_std(code, 21, -24, 29)); // STD %r21,-24(%r29)
567 ADD_INST(code, pc, hppa_std(code, 20, -16, 29)); // STD %r20,-16(%r29)
568 ADD_INST(code, pc, hppa_std(code, 19, -8, 29)); // STD %r19,-8(%r29)
569
570 ADD_INST(code, pc, hppa_std(code, 0, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, parent), 30));
571 ADD_INST(code, pc, hppa_std(code, 0, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, ex), 30));
572 ADD_INST(code, pc, hppa_std(code, 0, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, ex_handler), 30));
573 ADD_INST(code, pc, hppa_std(code, 0, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, ip), 30));
574
575 if (data != NULL)
576 data[0] = method;
577 ADD_INST(code, pc, hppa_ldd(code, 0, 27, 19));
578 ADD_INST(code, pc, hppa_std(code, 19, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, method), 30));
579
580 if (sig->hasthis) {
581 if (sig->call_convention != MONO_CALL_THISCALL) {
582 ADD_INST(code, pc, hppa_std(code, arg_reg, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, obj), 30));
583 arg_val_pos += 8;
584 } else {
585 fprintf(stderr, "case I didn't handle 2\n");
586 }
587 }
588
589 if (data != NULL)
590 data[2] = (void *)stackval_from_data;
591
592 for (i = 0; i < sig->param_count; ++i) {
593 if (data != NULL)
594 data[4 + i] = sig->params[i];
595 ADD_INST(code, pc, hppa_ldd(code, (4 + i) * 8, 27, 26)); // LDD x(%r27),%r26 == type
596 ADD_INST(code, pc, hppa_ldo(code, stack_val_pos, 30, 25)); // LDD x(%r30),%r25 == &stackval
597 if (sig->params[i]->byref) {
598 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos, 3, 24));
599 } else {
600 int type = sig->params[i]->type;
601 typeswitch:
602 switch (type) {
603 case MONO_TYPE_I8:
604 case MONO_TYPE_U8:
605 case MONO_TYPE_I:
606 case MONO_TYPE_U:
607 case MONO_TYPE_STRING:
608 case MONO_TYPE_OBJECT:
609 case MONO_TYPE_CLASS:
610 case MONO_TYPE_SZARRAY:
611 case MONO_TYPE_PTR:
612 case MONO_TYPE_R8:
613 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos, 3, 24));
614 break;
615 case MONO_TYPE_I4:
616 case MONO_TYPE_U4:
617 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos + 4, 3, 24));
618 break;
619 case MONO_TYPE_CHAR:
620 case MONO_TYPE_I2:
621 case MONO_TYPE_U2:
622 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos + 6, 3, 24));
623 break;
624 case MONO_TYPE_I1:
625 case MONO_TYPE_U1:
626 case MONO_TYPE_BOOLEAN:
627 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos + 7, 3, 24));
628 break;
629 case MONO_TYPE_VALUETYPE:
630 if (sig->params [i]->data.klass->enumtype) {
631 type = sig->params [i]->data.klass->enum_basetype->type;
632 goto typeswitch;
633 } else {
634 int size = mono_class_native_size (sig->params[i]->data.klass, NULL);
635 if (size <= 8)
636 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos, 3, 24));
637 else {
638 arg_val_pos += 15;
639 arg_val_pos &= ~15;
640 ADD_INST(code, pc, hppa_ldo(code, arg_val_pos, 3, 24));
641 }
642
643 arg_val_pos += size;
644 arg_val_pos += 7;
645 arg_val_pos &= ~7;
646 arg_val_pos -=8 ; // as it is incremented later
647
648 ADD_INST(code, pc, hppa_ldo(code, vtoffsets[i], 30, 19));
649 ADD_INST(code, pc, hppa_std(code, 19, 0, 25));
650 }
651 break;
652 default:
653 fprintf(stderr, "can not cope in create method pointer %d\n", sig->params[i]->type);
654 break;
655 }
656 }
657
658 ADD_INST(code, pc, hppa_ldo(code, sig->pinvoke, 0, 23)); // LDI sig->pinvoke,%r23
659 ADD_INST(code, pc, hppa_ldd(code, 16, 27, 19)); // LDD x(%r27),%r19 == stackval_from_data
660 ADD_INST(code, pc, hppa_ldd(code, 16, 19, 20)); // LDD 16(%r19),%r20
661 ADD_INST(code, pc, hppa_ldd(code, 24, 19, 27)); // LDD 24(%r19),%r27
662 ADD_INST(code, pc, hppa_blve(code, 20)); // BVE,L (%r20),%r2
663 ADD_INST(code, pc, hppa_ldo(code, -16, 30, 29)); // LDO -16(%r30),%r29
664 ADD_INST(code, pc, hppa_ldd(code, spill_offset + 8, 30, 27));
665
666 stack_val_pos += sizeof (stackval);
667 arg_val_pos += 8;
668 g_assert(stack_val_pos < -96);
669 }
670
671 ADD_INST(code, pc, hppa_ldo(code, stack_vals_offset, 30, 19));
672 ADD_INST(code, pc, hppa_std(code, 19, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, stack_args), 30));
673 ADD_INST(code, pc, hppa_ldo(code, stack_val_pos, 30, 19));
674 ADD_INST(code, pc, hppa_std(code, 19, invoke_rec_offset + G_STRUCT_OFFSET (MonoInvocation, retval), 30));
675
676 if (sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->data.klass->enumtype) {
677 int size = mono_class_native_size (sig->ret->data.klass, NULL);
678 // for large return structs pass on the pointer given us by our caller.
679 if (size > 16)
680 ADD_INST(code, pc, hppa_ldd(code, spill_offset + 16, 30, 28));
681 else // use space left on stack for the return value
682 ADD_INST(code, pc, hppa_ldo(code, stack_val_pos + sizeof(stackval), 30, 28));
683 ADD_INST(code, pc, hppa_std(code, 28, stack_val_pos, 30));
684 }
685
686 ADD_INST(code, pc, hppa_ldo(code, invoke_rec_offset, 30, 26)); // address of invocation
687
688 if (data != NULL)
689 data[1] = (void *)ves_exec_method;
690 ADD_INST(code, pc, hppa_ldd(code, 8, 27, 19)); // LDD 8(%r27),%r19
691 ADD_INST(code, pc, hppa_ldd(code, 16, 19, 20)); // LDD 16(%r19),%r20
692 ADD_INST(code, pc, hppa_ldd(code, 24, 19, 27)); // LDD 24(%r19),%r27
693 ADD_INST(code, pc, hppa_blve(code, 20)); // BVE,L (%r20),%r2
694 ADD_INST(code, pc, hppa_ldo(code, -16, 30, 29)); // LDO -16(%r30),%r29
695 ADD_INST(code, pc, hppa_ldd(code, spill_offset + 8, 30, 27));
696 if (sig->ret->byref) {
697 fprintf(stderr, "can'ty cope with ret byref\n");
698 } else {
699 int simpletype = sig->ret->type;
700 enum_retvalue:
701 switch (simpletype) {
702 case MONO_TYPE_VOID:
703 break;
704 case MONO_TYPE_BOOLEAN:
705 case MONO_TYPE_I1:
706 case MONO_TYPE_U1:
707 case MONO_TYPE_CHAR:
708 case MONO_TYPE_I2:
709 case MONO_TYPE_U2:
710 case MONO_TYPE_I4:
711 case MONO_TYPE_U4:
712 ADD_INST(code, pc, hppa_ldw(code, stack_val_pos, 30, 28)); // LDW x(%r30),%r28
713 break;
714 case MONO_TYPE_I8:
715 case MONO_TYPE_U8:
716 case MONO_TYPE_I:
717 case MONO_TYPE_U:
718 case MONO_TYPE_STRING:
719 case MONO_TYPE_OBJECT:
720 case MONO_TYPE_CLASS:
721 case MONO_TYPE_SZARRAY:
722 case MONO_TYPE_PTR:
723 ADD_INST(code, pc, hppa_ldd(code, stack_val_pos, 30, 28)); // LDD x(%r30),%r28
724 break;
725 case MONO_TYPE_R8:
726 ADD_INST(code, pc, hppa_fldd(code, stack_val_pos, 30, 4)); // FLDD x(%r30),%fr4
727 break;
728 case MONO_TYPE_VALUETYPE:
729 if (sig->ret->data.klass->enumtype) {
730 simpletype = sig->ret->data.klass->enum_basetype->type;
731 goto enum_retvalue;
732 } else {
733 int size = mono_class_native_size (sig->ret->data.klass, NULL);
734 if (size <= 16) {
735 ADD_INST(code, pc, hppa_ldd(code, stack_val_pos, 30, 28));
736 if (size > 8)
737 ADD_INST(code, pc, hppa_ldd(code, 8, 28, 29));
738 ADD_INST(code, pc, hppa_ldd(code, 0, 28, 28));
739 }
740 }
741 break;
742 default:
743 fprintf(stderr, "can't cope with ret type %d\n", simpletype);
744 return NULL;
745 }
746 }
747
748 ADD_INST(code, pc, hppa_ldd(code, -frame_size-16, 30, 2));
749 ADD_INST(code, pc, hppa_ldd(code, spill_offset, 30, 4));
750 ADD_INST(code, pc, hppa_bve(code, 2, 0));
751 ADD_INST(code, pc, hppa_ldd_mb(code, -frame_size, 30, 3));
752 if (code == NULL) {
753 descriptor = (void **)malloc((8 + sig->param_count) * sizeof(void *) + sizeof(unsigned int) * pc);
754 data = descriptor + 4;
755 code = (unsigned int *)(data + 4 + sig->param_count);
756 code_start = code;
757 goto generate;
758 }
759
760 if (debug_asm) {
761 fprintf(stderr, "generated: %d bytes\n", pc * 4);
762 disassemble(code_start, pc);
763 }
764
765 flush_cache(code_start, 4 * pc);
766
767 descriptor[0] = 0;
768 descriptor[1] = 0;
769 descriptor[2] = code_start;
770 descriptor[3] = data;
771
772 ji = g_new0 (MonoJitInfo, 1);
773 ji->method = method;
774 ji->code_size = 4; // does this matter?
775 ji->code_start = descriptor;
776
777 mono_jit_info_table_add (mono_get_root_domain (), ji);
778
779 return ji->code_start;
780 }
781 #endif