?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update rx (mobile builds).
[mono-project.git] / mono / mini / mini-hppa.c
blobc410f07dc0c58f4c73de3017d2fa9476a37c4fd9
1 /*
2 * mini-hppa.c: HPPA backend for the Mono code generator
3 *
4 * Copyright (c) 2007 Randolph Chung
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 *
24 */
25 #include "mini.h"
26 #include <string.h>
27 #include <pthread.h>
28 #include <unistd.h>
29
30 #include <unistd.h>
31 #include <sys/mman.h>
32
33 #include <mono/metadata/appdomain.h>
34 #include <mono/metadata/debug-helpers.h>
35 #include <mono/metadata/tokentype.h>
36 #include <mono/utils/mono-math.h>
37
38 #include "mini-hppa.h"
39 #include "trace.h"
40 #include "cpu-hppa.h"
41
42 #define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
43 #define SIGNAL_STACK_SIZE (64 * 1024)
44
45 #define DEBUG(a) // a
46 #define DEBUG_FUNC_ENTER() // printf("Entering %s\n", __FUNCTION__)
47 #define DEBUG_FUNC_EXIT() // printf("Exiting %s\n", __FUNCTION__)
48
49 static const guchar
50 branch_b0_table [] = {
51 TRUE, /* OP_HPPA_BEQ */
52 FALSE, /* OP_HPPA_BGE */
53 FALSE, /* OP_HPPA_BGT */
54 TRUE, /* OP_HPPA_BLE */
55 TRUE, /* OP_HPPA_BLT */
56 FALSE, /* OP_HPPA_BNE */
57 FALSE, /* OP_HPPA_BGE_UN */
58 FALSE, /* OP_HPPA_BGT_UN */
59 TRUE, /* OP_HPPA_BLE_UN */
60 TRUE, /* OP_HPPA_BLT_UN */
61 };
62
63 static const guchar
64 branch_b1_table [] = {
65 HPPA_CMP_COND_EQ, /* OP_HPPA_BEQ */
66 HPPA_CMP_COND_SLT, /* OP_HPPA_BGE */
67 HPPA_CMP_COND_SLE, /* OP_HPPA_BGT */
68 HPPA_CMP_COND_SLE, /* OP_HPPA_BLE */
69 HPPA_CMP_COND_SLT, /* OP_HPPA_BLT */
70 HPPA_CMP_COND_EQ, /* OP_HPPA_BNE_UN */
71 HPPA_CMP_COND_ULT, /* OP_HPPA_BGE_UN */
72 HPPA_CMP_COND_ULE, /* OP_HPPA_BGT_UN */
73 HPPA_CMP_COND_ULE, /* OP_HPPA_BLE_UN */
74 HPPA_CMP_COND_ULT, /* OP_HPPA_BLT_UN */
75 };
76
77 /* Note that these are inverted from the OP_xxx, because we nullify
78 * the branch if the condition is met
79 */
80 static const guchar
81 float_branch_table [] = {
82 26, /* OP_FBEQ */
83 11, /* OP_FBGE */
84 15, /* OP_FBGT */
85 19, /* OP_FBLE */
86 23, /* OP_FBLT */
87 4, /* OP_FBNE_UN */
88 8, /* OP_FBGE_UN */
89 13, /* OP_FBGT_UN */
90 17, /* OP_FBLE_UN */
91 20, /* OP_FBLT_UN */
92 };
93
94 static const guchar
95 float_ceq_table [] = {
96 26, /* OP_FCEQ */
97 15, /* OP_FCGT */
98 13, /* OP_FCGT_UN */
99 23, /* OP_FCLT */
100 21, /* OP_FCLT_UN */
101 };
102
103 /*
104 * Branches have short (14 or 17 bit) targets on HPPA. To make longer jumps,
105 * we will need to rely on stubs - basically we create stub structures in
106 * the epilogue that uses a long branch to the destination, and any short
107 * jumps inside a method that cannot reach the destination directly will
108 * branch first to the stub.
109 */
110 typedef struct MonoOvfJump {
111 union {
112 MonoBasicBlock *bb;
113 const char *exception;
114 } data;
115 guint32 ip_offset;
116 } MonoOvfJump;
117
118 /* Create a literal 0.0 double for FNEG */
119 double hppa_zero = 0;
120
121 const char*
122 mono_arch_regname (int reg)
123 {
124 static const char * rnames[] = {
125 "hppa_r0", "hppa_r1", "hppa_rp", "hppa_r3", "hppa_r4",
126 "hppa_r5", "hppa_r6", "hppa_r7", "hppa_r8", "hppa_r9",
127 "hppa_r10", "hppa_r11", "hppa_r12", "hppa_r13", "hppa_r14",
128 "hppa_r15", "hppa_r16", "hppa_r17", "hppa_r18", "hppa_r19",
129 "hppa_r20", "hppa_r21", "hppa_r22", "hppa_r23", "hppa_r24",
130 "hppa_r25", "hppa_r26", "hppa_r27", "hppa_r28", "hppa_r29",
131 "hppa_sp", "hppa_r31"
132 };
133 if (reg >= 0 && reg < MONO_MAX_IREGS)
134 return rnames [reg];
135 return "unknown";
136 }
137
138 const char*
139 mono_arch_fregname (int reg)
140 {
141 static const char *rnames [] = {
142 "hppa_fr0", "hppa_fr1", "hppa_fr2", "hppa_fr3", "hppa_fr4",
143 "hppa_fr5", "hppa_fr6", "hppa_fr7", "hppa_fr8", "hppa_fr9",
144 "hppa_fr10", "hppa_fr11", "hppa_fr12", "hppa_fr13", "hppa_fr14",
145 "hppa_fr15", "hppa_fr16", "hppa_fr17", "hppa_fr18", "hppa_fr19",
146 "hppa_fr20", "hppa_fr21", "hppa_fr22", "hppa_fr23", "hppa_fr24",
147 "hppa_fr25", "hppa_fr26", "hppa_fr27", "hppa_fr28", "hppa_fr29",
148 "hppa_fr30", "hppa_fr31",
149 };
150
151 if (reg >= 0 && reg < MONO_MAX_FREGS)
152 return rnames [reg];
153 else
154 return "unknown";
155 }
156
157 /*
158 * Initialize the cpu to execute managed code.
159 */
160 void
161 mono_arch_cpu_init (void)
162 {
163 guint32 dummy;
164 mono_arch_cpu_optimizations(&dummy);
165 }
166
167 /*
168 * Initialize architecture specific code.
169 */
170 void
171 mono_arch_init (void)
172 {
173 }
174
175 /*
176 * Cleanup architecture specific code.
177 */
178 void
179 mono_arch_cleanup (void)
180 {
181 }
182
183 /*
184 * This function returns the optimizations supported on this cpu.
185 */
186 guint32
187 mono_arch_cpu_optimizations (guint32 *exclude_mask)
188 {
189 guint32 opts = 0;
190 *exclude_mask = 0;
191 return opts;
192 }
193
194 /*
195 * This function test for all SIMD functions supported.
196 *
197 * Returns a bitmask corresponding to all supported versions.
198 *
199 */
200 guint32
201 mono_arch_cpu_enumerate_simd_versions (void)
202 {
203 /* SIMD is currently unimplemented */
204 return 0;
205 }
206
207 void
208 mono_arch_flush_icache (guint8 *code, gint size)
209 {
210 guint8* p = (guint8*)((guint32)code & ~(0x3f));
211 guint8* end = (guint8*)((guint32)code + size);
212 while (p < end) {
213 __asm__ __volatile__ ("fdc %%r0(%%sr3, %0)\n"
214 "sync\n"
215 "fic %%r0(%%sr3, %0)\n"
216 "sync\n"
217 : : "r"(p));
218 p += 32; /* can be 64 on pa20 cpus */
219 }
220 }
221
222 void
223 mono_arch_flush_register_windows (void)
224 {
225 /* No register windows on hppa */
226 }
227
228 typedef enum {
229 ArgInIReg,
230 ArgInIRegPair,
231 ArgInFReg,
232 ArgInDReg,
233 ArgOnStack,
234 } ArgStorage;
235
236 typedef struct {
237 gint16 offset;
238 gint16 size;
239 guint8 type;
240 gint8 reg;
241 ArgStorage storage;
242 } ArgInfo;
243
244 typedef struct {
245 int nargs;
246 guint32 stack_usage;
247 int struct_return;
248 ArgInfo ret;
249 ArgInfo sig_cookie;
250 ArgInfo args [1];
251 } CallInfo;
252
253 #define PARAM_REGS 4
254 #define ARGS_OFFSET 36
255
256 static void
257 add_parameter (CallInfo *cinfo, ArgInfo *ainfo, MonoType *type)
258 {
259 int is_fp = (type->type == MONO_TYPE_R4 || type->type == MONO_TYPE_R8);
260 int ofs, align;
261
262 DEBUG_FUNC_ENTER ();
263 ainfo->reg = -1;
264 ainfo->size = mono_type_size (type, &align);
265 ainfo->type = type->type;
266
267 if (ainfo->size <= 4) {
268 cinfo->stack_usage += 4;
269 ainfo->offset = cinfo->stack_usage - (4 - ainfo->size);
270 }
271 else if (ainfo->size <= 8)
272 {
273 cinfo->stack_usage += 8;
274 cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, 8);
275 ainfo->offset = cinfo->stack_usage - (8 - ainfo->size);
276 }
277 else
278 {
279 cinfo->stack_usage += ainfo->size;
280 cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, align);
281 ainfo->offset = cinfo->stack_usage;
282 }
283
284 ofs = (ALIGN_TO (ainfo->offset, 4) - ARGS_OFFSET) / 4;
285 if (ofs < PARAM_REGS) {
286 if (!is_fp) {
287 if (ainfo->size <= 4)
288 ainfo->storage = ArgInIReg;
289 else
290 ainfo->storage = ArgInIRegPair;
291 ainfo->reg = hppa_r26 - ofs;
292 } else if (type->type == MONO_TYPE_R4) {
293 ainfo->storage = ArgInFReg;
294 ainfo->reg = hppa_fr4 + ofs;
295 } else { /* type->type == MONO_TYPE_R8 */
296 ainfo->storage = ArgInDReg;
297 ainfo->reg = hppa_fr4 + ofs;
298 }
299 }
300 else {
301 /* frame pointer based offset */
302 ainfo->reg = hppa_r3;
303 ainfo->storage = ArgOnStack;
304 }
305
306 /* All offsets are negative relative to the frame pointer */
307 ainfo->offset = -ainfo->offset;
308
309 DEBUG_FUNC_EXIT ();
310 }
311
312 static void
313 analyze_return (CallInfo *cinfo, MonoMethodSignature *sig)
314 {
315 MonoType *type;
316 int align;
317 int size;
318
319 type = sig->ret;
320 size = mono_type_size (type, &align);
321
322 /* ref: mono_type_to_stind */
323 cinfo->ret.type = type->type;
324 if (type->byref) {
325 cinfo->ret.storage = ArgInIReg;
326 cinfo->ret.reg = hppa_r28;
327 } else {
328 handle_enum:
329 switch (type->type) {
330 case MONO_TYPE_VOID:
331 break;
332 case MONO_TYPE_BOOLEAN:
333 case MONO_TYPE_I1:
334 case MONO_TYPE_U1:
335 case MONO_TYPE_I2:
336 case MONO_TYPE_U2:
337 case MONO_TYPE_CHAR:
338 case MONO_TYPE_I4:
339 case MONO_TYPE_U4:
340 case MONO_TYPE_I:
341 case MONO_TYPE_U:
342 case MONO_TYPE_PTR:
343 case MONO_TYPE_FNPTR:
344 case MONO_TYPE_CLASS:
345 case MONO_TYPE_STRING:
346 case MONO_TYPE_OBJECT:
347 case MONO_TYPE_SZARRAY:
348 case MONO_TYPE_ARRAY:
349 cinfo->ret.storage = ArgInIReg;
350 cinfo->ret.reg = hppa_r28;
351 break;
352 case MONO_TYPE_U8:
353 case MONO_TYPE_I8:
354 cinfo->ret.storage = ArgInIRegPair;
355 cinfo->ret.reg = hppa_r28;
356 break;
357 case MONO_TYPE_R4:
358 cinfo->ret.storage = ArgInFReg;
359 cinfo->ret.reg = hppa_fr4;
360 break;
361 case MONO_TYPE_R8:
362 cinfo->ret.storage = ArgInDReg;
363 cinfo->ret.reg = hppa_fr4;
364 break;
365 case MONO_TYPE_GENERICINST:
366 type = &type->data.generic_class->container_class->byval_arg;
367 goto handle_enum;
368
369 case MONO_TYPE_VALUETYPE:
370 if (type->data.klass->enumtype) {
371 type = mono_class_enum_basetype (type->data.klass);
372 goto handle_enum;
373 }
374 /* Fall through */
375 case MONO_TYPE_TYPEDBYREF:
376 cinfo->struct_return = 1;
377 /* cinfo->ret.storage tells us how the ABI expects
378 * the parameter to be returned
379 */
380 if (size <= 4) {
381 cinfo->ret.storage = ArgInIReg;
382 cinfo->ret.reg = hppa_r28;
383 } else if (size <= 8) {
384 cinfo->ret.storage = ArgInIRegPair;
385 cinfo->ret.reg = hppa_r28;
386 } else {
387 cinfo->ret.storage = ArgOnStack;
388 cinfo->ret.reg = hppa_sp;
389 }
390
391 /* We always allocate stack space for this because the
392 * arch-indep code expects us to
393 */
394 cinfo->stack_usage += size;
395 cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, align);
396 cinfo->ret.offset = -cinfo->stack_usage;
397 break;
398
399 default:
400 g_error ("Can't handle as return value 0x%x", sig->ret->type);
401 }
402 }
403 }
404
405 /*
406 * get_call_info:
407 *
408 * Obtain information about a call according to the calling convention.
409 */
410 static CallInfo*
411 get_call_info (MonoMethodSignature *sig, gboolean is_pinvoke)
412 {
413 guint32 i;
414 int n = sig->hasthis + sig->param_count;
415 CallInfo *cinfo;
416 MonoType *type;
417 MonoType ptrtype;
418 int dummy;
419
420 ptrtype.type = MONO_TYPE_PTR;
421
422 DEBUG_FUNC_ENTER();
423 cinfo = g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
424
425 /* The area below ARGS_OFFSET is the linkage area... */
426 cinfo->stack_usage = ARGS_OFFSET - 4;
427 /* -4, because the first argument will allocate the area it needs */
428
429 /* this */
430 if (sig->hasthis) {
431 add_parameter (cinfo, cinfo->args + 0, &ptrtype);
432 DEBUG (printf ("param <this>: assigned to reg %s offset %d\n", mono_arch_regname (cinfo->args[0].reg), cinfo->args[0].offset));
433 }
434
435 /* TODO: What to do with varargs? */
436
437 for (i = 0; i < sig->param_count; ++i) {
438 ArgInfo *ainfo = &cinfo->args [sig->hasthis + i];
439 if (sig->params [i]->byref)
440 type = &ptrtype;
441 else
442 type = mono_type_get_underlying_type (sig->params [i]);
443 add_parameter (cinfo, ainfo, type);
444
445 DEBUG (printf ("param %d: type %d size %d assigned to reg %s offset %d\n", i, type->type, mono_type_size (type, &dummy), mono_arch_regname (ainfo->reg), ainfo->offset));
446 }
447
448 analyze_return (cinfo, sig);
449
450 DEBUG_FUNC_EXIT();
451 return cinfo;
452 }
453
454 GList *
455 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
456 {
457 GList *vars = NULL;
458 int i;
459
460 DEBUG_FUNC_ENTER();
461 for (i = 0; i < cfg->num_varinfo; i++) {
462 MonoInst *ins = cfg->varinfo [i];
463 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
464
465 /* unused vars */
466 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
467 continue;
468
469 if ((ins->flags & (MONO_INST_IS_DEAD|MONO_INST_VOLATILE|MONO_INST_INDIRECT)) ||
470 (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
471 continue;
472
473 if (mono_is_regsize_var (ins->inst_vtype)) {
474 g_assert (MONO_VARINFO (cfg, i)->reg == -1);
475 g_assert (i == vmv->idx);
476 vars = mono_varlist_insert_sorted (cfg, vars, vmv, FALSE);
477 }
478 }
479 DEBUG_FUNC_EXIT();
480
481 return vars;
482 }
483
484 GList *
485 mono_arch_get_global_int_regs (MonoCompile *cfg)
486 {
487 GList *regs = NULL;
488 int i;
489
490 /* r3 is sometimes used as our frame pointer, so don't allocate it
491 * r19 is the GOT pointer, don't allocate it either
492 */
493
494 DEBUG_FUNC_ENTER();
495 for (i = 4; i <= 18; i++)
496 regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
497 DEBUG_FUNC_EXIT();
498
499 return regs;
500 }
501
502 /*
503 * mono_arch_regalloc_cost:
504 *
505 * Return the cost, in number of memory references, of the action of
506 * allocating the variable VMV into a register during global register
507 * allocation.
508 */
509 guint32
510 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
511 {
512 /* FIXME */
513 return 0;
514 }
515
516 /*
517 * Set var information according to the calling convention.
518 * The locals var stuff should most likely be split in another method.
519 *
520 * updates m->stack_offset based on the amount of stack space needed for
521 * local vars
522 */
523 void
524 mono_arch_allocate_vars (MonoCompile *m)
525 {
526 MonoMethodSignature *sig;
527 MonoMethodHeader *header;
528 MonoInst *inst;
529 int i, offset, size, align, curinst;
530 guint32 stack_ptr;
531 guint rettype;
532 CallInfo *cinfo;
533
534 DEBUG_FUNC_ENTER();
535 m->flags |= MONO_CFG_HAS_SPILLUP;
536
537 header = m->header;
538
539 sig = mono_method_signature (m->method);
540 DEBUG (printf ("Allocating locals - incoming params:\n"));
541 cinfo = get_call_info (sig, FALSE);
542
543 /*
544 * We use the ABI calling conventions for managed code as well.
545 */
546 if (m->flags & MONO_CFG_HAS_ALLOCA) {
547 stack_ptr = hppa_r4;
548 m->used_int_regs |= 1 << hppa_r4;
549 } else {
550 stack_ptr = hppa_sp;
551 }
552
553 /* Before this function is called, we would have looked at all
554 * calls from this method and figured out how much space is needed
555 * for the param area.
556 *
557 * Locals are allocated backwards, right before the param area
558 */
559 /* TODO: in some cases we don't need the frame pointer... */
560 m->frame_reg = hppa_r3;
561 offset = m->param_area;
562
563 /* Return values can be passed back either in four ways:
564 * r28 is used for data <= 4 bytes (32-bit ABI)
565 * r28/r29 are used for data >4 && <= 8 bytes
566 * fr4 is used for floating point data
567 * data larger than 8 bytes is returned on the stack pointed to
568 * by r28
569 *
570 * This code needs to be in sync with how CEE_RET is handled
571 * in mono_method_to_ir (). In some cases when we return small
572 * structs, the ABI specifies that they should be returned in
573 * registers, but the code in mono_method_to_ir () always emits
574 * a memcpy for valuetype returns, so we need to make sure we
575 * allocate space on the stack for this copy.
576 */
577 if (cinfo->struct_return) {
578 /* this is used to stash the incoming r28 pointer */
579 offset += sizeof (gpointer);
580 m->ret->opcode = OP_REGOFFSET;
581 m->ret->inst_basereg = stack_ptr;
582 m->ret->inst_offset = -offset;
583 } else if (sig->ret->type != MONO_TYPE_VOID) {
584 m->ret->opcode = OP_REGVAR;
585 m->ret->inst_c0 = cinfo->ret.reg;
586 }
587
588 curinst = m->locals_start;
589 for (i = curinst; i < m->num_varinfo; ++i) {
590 inst = m->varinfo [i];
591
592 if (inst->opcode == OP_REGVAR) {
593 DEBUG (printf ("allocating local %d to %s\n", i, mono_arch_regname (inst->dreg)));
594 continue;
595 }
596
597 if (inst->flags & MONO_INST_IS_DEAD)
598 continue;
599
600 /* inst->backend.is_pinvoke indicates native sized value types, this is used by the
601 * pinvoke wrappers when they call functions returning structure */
602 if (inst->backend.is_pinvoke && MONO_TYPE_ISSTRUCT (inst->inst_vtype) && inst->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
603 size = mono_class_native_size (inst->inst_vtype->data.klass, &align);
604 else
605 size = mini_type_stack_size (cfg->generic_sharing_context, inst->inst_vtype, &align);
606
607 /*
608 * This is needed since structures containing doubles must be doubleword
609 * aligned.
610 * FIXME: Do this only if needed.
611 */
612 if (MONO_TYPE_ISSTRUCT (inst->inst_vtype))
613 align = 8;
614
615 /*
616 * variables are accessed as negative offsets from hppa_sp
617 */
618 inst->opcode = OP_REGOFFSET;
619 inst->inst_basereg = stack_ptr;
620 offset += size;
621 offset = ALIGN_TO (offset, align);
622 inst->inst_offset = -offset;
623
624 DEBUG (printf ("allocating local %d (size = %d) to [%s - %d]\n", i, size, mono_arch_regname (inst->inst_basereg), -inst->inst_offset));
625 }
626
627 if (sig->call_convention == MONO_CALL_VARARG) {
628 /* TODO */
629 }
630
631 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
632 ArgInfo *ainfo = &cinfo->args [i];
633 inst = m->args [i];
634 if (inst->opcode != OP_REGVAR) {
635 switch (ainfo->storage) {
636 case ArgInIReg:
637 case ArgInIRegPair:
638 case ArgInFReg:
639 case ArgInDReg:
640 /* Currently mono requests all incoming registers
641 * be assigned to a stack location :-(
642 */
643 #if 0
644 if (!(inst->flags & (MONO_INST_VOLATILE | MONO_INST_INDIRECT))) {
645 inst->opcode = OP_REGVAR;
646 inst->dreg = ainfo->reg;
647 DEBUG (printf ("param %d in register %s\n", i, mono_arch_regname (inst->dreg)));
648 break;
649 }
650 #endif
651 /* fallthrough */
652 case ArgOnStack:
653 inst->opcode = OP_REGOFFSET;
654 inst->inst_basereg = hppa_r3;
655 inst->inst_offset = ainfo->offset;
656 DEBUG (printf ("param %d stored on stack [%s - %d]\n", i, mono_arch_regname (hppa_r3), -inst->inst_offset));
657 break;
658 }
659 }
660 }
661
662 m->stack_offset = offset; /* Includes cfg->param_area */
663
664 g_free (cinfo);
665 DEBUG_FUNC_EXIT();
666 }
667
668 /*
669 * take the arguments and generate the arch-specific
670 * instructions to properly call the function in call.
671 * This includes pushing, moving arguments to the right register
672 * etc.
673 *
674 * sets call->stack_usage and cfg->param_area
675 */
676 MonoCallInst*
677 mono_arch_call_opcode (MonoCompile *cfg, MonoBasicBlock* bb, MonoCallInst *call, int is_virtual)
678 {
679 MonoInst *arg, *in;
680 MonoMethodSignature *sig;
681 int i, n;
682 CallInfo *cinfo;
683 ArgInfo *ainfo;
684
685 DEBUG_FUNC_ENTER();
686 DEBUG (printf ("is_virtual = %d\n", is_virtual));
687
688 sig = call->signature;
689 n = sig->param_count + sig->hasthis;
690
691 DEBUG (printf ("Calling method with %d parameters\n", n));
692
693 cinfo = get_call_info (sig, sig->pinvoke);
694
695 // DEBUG
696 g_assert (sig->call_convention != MONO_CALL_VARARG);
697
698 for (i = 0; i < n; ++i) {
699 ainfo = &cinfo->args [i];
700
701 if ((sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
702 /* TODO */
703 }
704
705 if (is_virtual && i == 0) {
706 /* the argument will be attached to the call instruction */
707 in = call->args [i];
708 call->used_iregs |= 1 << ainfo->reg;
709 } else {
710 MONO_INST_NEW (cfg, arg, OP_OUTARG);
711 in = call->args [i];
712 arg->cil_code = in->cil_code;
713 arg->inst_left = in;
714 arg->inst_call = call;
715 arg->type = in->type;
716
717 /* prepend, we'll need to reverse them later */
718 arg->next = call->out_args;
719 call->out_args = arg;
720
721 switch (ainfo->storage) {
722 case ArgInIReg:
723 case ArgInIRegPair: {
724 MonoHPPAArgInfo *ai = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoHPPAArgInfo));
725 ai->reg = ainfo->reg;
726 ai->size = ainfo->size;
727 ai->offset = ainfo->offset;
728 ai->pass_in_reg = 1;
729 arg->backend.data = ai;
730
731 call->used_iregs |= 1 << ainfo->reg;
732 if (ainfo->storage == ArgInIRegPair)
733 call->used_iregs |= 1 << (ainfo->reg + 1);
734 if (ainfo->type == MONO_TYPE_VALUETYPE)
735 arg->opcode = OP_OUTARG_VT;
736 break;
737 }
738 case ArgOnStack: {
739 MonoHPPAArgInfo *ai = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoHPPAArgInfo));
740 ai->reg = hppa_sp;
741 ai->size = ainfo->size;
742 ai->offset = ainfo->offset;
743 ai->pass_in_reg = 0;
744 arg->backend.data = ai;
745 if (ainfo->type == MONO_TYPE_VALUETYPE)
746 arg->opcode = OP_OUTARG_VT;
747 else
748 arg->opcode = OP_OUTARG_MEMBASE;
749 call->used_iregs |= 1 << ainfo->reg;
750 break;
751 }
752 case ArgInFReg:
753 arg->backend.reg3 = ainfo->reg;
754 arg->opcode = OP_OUTARG_R4;
755 call->used_fregs |= 1 << ainfo->reg;
756 break;
757 case ArgInDReg:
758 arg->backend.reg3 = ainfo->reg;
759 arg->opcode = OP_OUTARG_R8;
760 call->used_fregs |= 1 << ainfo->reg;
761 break;
762 default:
763 NOT_IMPLEMENTED;
764 }
765 }
766 }
767
768 /*
769 * Reverse the call->out_args list.
770 */
771 {
772 MonoInst *prev = NULL, *list = call->out_args, *next;
773 while (list) {
774 next = list->next;
775 list->next = prev;
776 prev = list;
777 list = next;
778 }
779 call->out_args = prev;
780 }
781 call->stack_usage = cinfo->stack_usage;
782 cfg->param_area = MAX (cfg->param_area, call->stack_usage);
783 cfg->param_area = ALIGN_TO (cfg->param_area, MONO_ARCH_FRAME_ALIGNMENT);
784
785 cfg->flags |= MONO_CFG_HAS_CALLS;
786
787 g_free (cinfo);
788
789 DEBUG_FUNC_EXIT();
790 return call;
791 }
792
793 void
794 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
795 {
796 }
797
798 void
799 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
800 {
801 DEBUG_FUNC_ENTER();
802 DEBUG_FUNC_EXIT();
803 }
804
805 static void
806 insert_after_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *to_insert)
807 {
808 if (ins == NULL) {
809 ins = bb->code;
810 bb->code = to_insert;
811 to_insert->next = ins;
812 } else {
813 to_insert->next = ins->next;
814 ins->next = to_insert;
815 }
816 }
817
818 #define NEW_INS(cfg,dest,op) do { \
819 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
820 (dest)->opcode = (op); \
821 insert_after_ins (bb, last_ins, (dest)); \
822 } while (0)
823
824 static int
825 map_to_reg_reg_op (int op)
826 {
827 switch (op) {
828 case OP_ADD_IMM:
829 return CEE_ADD;
830 case OP_SUB_IMM:
831 return CEE_SUB;
832 case OP_AND_IMM:
833 return CEE_AND;
834 case OP_COMPARE_IMM:
835 return OP_COMPARE;
836 case OP_ADDCC_IMM:
837 return OP_ADDCC;
838 case OP_ADC_IMM:
839 return OP_ADC;
840 case OP_SUBCC_IMM:
841 return OP_SUBCC;
842 case OP_SBB_IMM:
843 return OP_SBB;
844 case OP_OR_IMM:
845 return CEE_OR;
846 case OP_XOR_IMM:
847 return CEE_XOR;
848 case OP_MUL_IMM:
849 return CEE_MUL;
850 case OP_LOAD_MEMBASE:
851 return OP_LOAD_MEMINDEX;
852 case OP_LOADI4_MEMBASE:
853 return OP_LOADI4_MEMINDEX;
854 case OP_LOADU4_MEMBASE:
855 return OP_LOADU4_MEMINDEX;
856 case OP_LOADU1_MEMBASE:
857 return OP_LOADU1_MEMINDEX;
858 case OP_LOADI2_MEMBASE:
859 return OP_LOADI2_MEMINDEX;
860 case OP_LOADU2_MEMBASE:
861 return OP_LOADU2_MEMINDEX;
862 case OP_LOADI1_MEMBASE:
863 return OP_LOADI1_MEMINDEX;
864 case OP_LOADR4_MEMBASE:
865 return OP_LOADR4_MEMINDEX;
866 case OP_LOADR8_MEMBASE:
867 return OP_LOADR8_MEMINDEX;
868 case OP_STOREI1_MEMBASE_REG:
869 return OP_STOREI1_MEMINDEX;
870 case OP_STOREI2_MEMBASE_REG:
871 return OP_STOREI2_MEMINDEX;
872 case OP_STOREI4_MEMBASE_REG:
873 return OP_STOREI4_MEMINDEX;
874 case OP_STORE_MEMBASE_REG:
875 return OP_STORE_MEMINDEX;
876 case OP_STORER4_MEMBASE_REG:
877 return OP_STORER4_MEMINDEX;
878 case OP_STORER8_MEMBASE_REG:
879 return OP_STORER8_MEMINDEX;
880 case OP_STORE_MEMBASE_IMM:
881 return OP_STORE_MEMBASE_REG;
882 case OP_STOREI1_MEMBASE_IMM:
883 return OP_STOREI1_MEMBASE_REG;
884 case OP_STOREI2_MEMBASE_IMM:
885 return OP_STOREI2_MEMBASE_REG;
886 case OP_STOREI4_MEMBASE_IMM:
887 return OP_STOREI4_MEMBASE_REG;
888 }
889 g_assert_not_reached ();
890 }
891
892 /*
893 * Remove from the instruction list the instructions that can't be
894 * represented with very simple instructions with no register
895 * requirements.
896 */
897 void
898 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
899 {
900 MonoInst *ins, *next, *temp, *last_ins = NULL;
901 int imm;
902
903 MONO_BB_FOR_EACH_INS (bb, ins) {
904 loop_start:
905 switch (ins->opcode) {
906 case OP_ADD_IMM:
907 case OP_ADDCC_IMM:
908 if (!hppa_check_bits (ins->inst_imm, 11)) {
909 NEW_INS (cfg, temp, OP_ICONST);
910 temp->inst_c0 = ins->inst_imm;
911 temp->dreg = mono_alloc_ireg (cfg);
912 ins->sreg2 = temp->dreg;
913 ins->opcode = map_to_reg_reg_op (ins->opcode);
914 }
915 break;
916 case OP_SUB_IMM:
917 case OP_SUBCC_IMM:
918 if (!hppa_check_bits (ins->inst_imm, 11)) {
919 NEW_INS (cfg, temp, OP_ICONST);
920 temp->inst_c0 = ins->inst_imm;
921 temp->dreg = mono_alloc_ireg (cfg);
922 ins->sreg2 = temp->dreg;
923 ins->opcode = map_to_reg_reg_op (ins->opcode);
924 }
925 break;
926
927 case OP_MUL_IMM:
928 if (ins->inst_imm == 1) {
929 ins->opcode = OP_MOVE;
930 break;
931 }
932 if (ins->inst_imm == 0) {
933 ins->opcode = OP_ICONST;
934 ins->inst_c0 = 0;
935 break;
936 }
937 imm = mono_is_power_of_two (ins->inst_imm);
938 if (imm > 0) {
939 ins->opcode = OP_SHL_IMM;
940 ins->inst_imm = imm;
941 break;
942 }
943 else {
944 int tmp = mono_alloc_ireg (cfg);
945 NEW_INS (cfg, temp, OP_ICONST);
946 temp->inst_c0 = ins->inst_c0;
947 temp->dreg = tmp;
948
949 ins->opcode = CEE_MUL;
950 ins->sreg2 = tmp;
951 /* Need to rewrite the CEE_MUL too... */
952 goto loop_start;
953 }
954 break;
955
956 case CEE_MUL: {
957 int freg1 = mono_alloc_freg (cfg);
958 int freg2 = mono_alloc_freg (cfg);
959
960 NEW_INS(cfg, temp, OP_STORE_MEMBASE_REG);
961 temp->sreg1 = ins->sreg1;
962 temp->inst_destbasereg = hppa_sp;
963 temp->inst_offset = -16;
964
965 NEW_INS(cfg, temp, OP_LOADR4_MEMBASE);
966 temp->dreg = freg1;
967 temp->inst_basereg = hppa_sp;
968 temp->inst_offset = -16;
969
970 NEW_INS(cfg, temp, OP_STORE_MEMBASE_REG);
971 temp->sreg1 = ins->sreg2;
972 temp->inst_destbasereg = hppa_sp;
973 temp->inst_offset = -16;
974
975 NEW_INS(cfg, temp, OP_LOADR4_MEMBASE);
976 temp->dreg = freg2;
977 temp->inst_basereg = hppa_sp;
978 temp->inst_offset = -16;
979
980 NEW_INS (cfg, temp, OP_HPPA_XMPYU);
981 temp->dreg = freg2;
982 temp->sreg1 = freg1;
983 temp->sreg2 = freg2;
984
985 NEW_INS(cfg, temp, OP_HPPA_STORER4_RIGHT);
986 temp->sreg1 = freg2;
987 temp->inst_destbasereg = hppa_sp;
988 temp->inst_offset = -16;
989
990 ins->opcode = OP_LOAD_MEMBASE;
991 ins->inst_basereg = hppa_sp;
992 ins->inst_offset = -16;
993 }
994 break;
995
996 default:
997 break;
998 }
999 last_ins = ins;
1000 }
1001 bb->last_ins = last_ins;
1002 bb->max_vreg = cfg->next_vreg;
1003
1004 }
1005
1006 void
1007 hppa_patch (guint32 *code, const gpointer target)
1008 {
1009 guint32 ins = *code;
1010 gint32 val = (gint32)target;
1011 gint32 disp = (val - (gint32)code - 8) >> 2;
1012 int reg1, reg2;
1013
1014 DEBUG (printf ("patching 0x%08x (0x%08x) to point to 0x%08x (disp = %d)\n", code, ins, val, disp));
1015
1016 switch (*code >> 26) {
1017 case 0x08: /* ldil, next insn can be a ldo, ldw, or ble */
1018 *code = *code & ~0x1fffff;
1019 *code = *code | hppa_op_imm21 (hppa_lsel (val));
1020 code++;
1021
1022 if ((*code >> 26) == 0x0D) { /* ldo */
1023 *code = *code & ~0x3fff;
1024 *code = *code | hppa_op_imm14 (hppa_rsel (val));
1025 } else if ((*code >> 26) == 0x12) { /* ldw */
1026 *code = *code & ~0x3fff;
1027 *code = *code | hppa_op_imm14 (hppa_rsel (val));
1028 } else if ((*code >> 26) == 0x39) { /* ble */
1029 *code = *code & ~0x1f1ffd;
1030 *code = *code | hppa_op_imm17 (hppa_rsel (val));
1031 }
1032
1033 break;
1034
1035 case 0x3A: /* bl */
1036 if (disp == 0) {
1037 hppa_nop (code);
1038 break;
1039 }
1040 if (!hppa_check_bits (disp, 17))
1041 goto jump_overflow;
1042 reg1 = (*code >> 21) & 0x1f;
1043 *code = (*code & ~0x1f1ffd) | hppa_op_imm17(disp);
1044 break;
1045
1046 case 0x20: /* combt */
1047 case 0x22: /* combf */
1048 if (!hppa_check_bits (disp >> 2, 12))
1049 goto jump_overflow;
1050 *code = (*code & ~0x1ffd) | hppa_op_imm12(disp);
1051 break;
1052
1053 default:
1054 g_warning ("Unpatched opcode %x\n", *code >> 26);
1055 }
1056
1057 return;
1058
1059 jump_overflow:
1060 g_warning ("cannot branch to target, insn is %08x, displacement is %d\n", (int)*code, (int)disp);
1061 g_assert_not_reached ();
1062 }
1063
1064 static guint32 *
1065 emit_float_to_int (MonoCompile *cfg, guint32 *code, int dreg, int sreg, int size, gboolean is_signed)
1066 {
1067 /* sreg is a float, dreg is an integer reg. */
1068 hppa_fcnvfxt (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, sreg, sreg);
1069 hppa_fstws (code, sreg, 0, -16, hppa_sp);
1070 hppa_ldw (code, -16, hppa_sp, dreg);
1071 if (!is_signed) {
1072 if (size == 1)
1073 hppa_extru (code, dreg, 31, 8, dreg);
1074 else if (size == 2)
1075 hppa_extru (code, dreg, 31, 16, dreg);
1076 } else {
1077 if (size == 1)
1078 hppa_extrs (code, dreg, 31, 8, dreg);
1079 else if (size == 2)
1080 hppa_extrs (code, dreg, 31, 16, dreg);
1081 }
1082 return code;
1083 }
1084
1085 /* Clobbers r1, r20, r21 */
1086 static guint32 *
1087 emit_memcpy (guint32 *code, int doff, int dreg, int soff, int sreg, int size)
1088 {
1089 /* r20 is the destination */
1090 hppa_set (code, doff, hppa_r20);
1091 hppa_add (code, hppa_r20, dreg, hppa_r20);
1092
1093 /* r21 is the source */
1094 hppa_set (code, soff, hppa_r21);
1095 hppa_add (code, hppa_r21, sreg, hppa_r21);
1096
1097 while (size >= 4) {
1098 hppa_ldw (code, 0, hppa_r21, hppa_r1);
1099 hppa_stw (code, hppa_r1, 0, hppa_r20);
1100 hppa_ldo (code, 4, hppa_r21, hppa_r21);
1101 hppa_ldo (code, 4, hppa_r20, hppa_r20);
1102 size -= 4;
1103 }
1104 while (size >= 2) {
1105 hppa_ldh (code, 0, hppa_r21, hppa_r1);
1106 hppa_sth (code, hppa_r1, 0, hppa_r20);
1107 hppa_ldo (code, 2, hppa_r21, hppa_r21);
1108 hppa_ldo (code, 2, hppa_r20, hppa_r20);
1109 size -= 2;
1110 }
1111 while (size > 0) {
1112 hppa_ldb (code, 0, hppa_r21, hppa_r1);
1113 hppa_stb (code, hppa_r1, 0, hppa_r20);
1114 hppa_ldo (code, 1, hppa_r21, hppa_r21);
1115 hppa_ldo (code, 1, hppa_r20, hppa_r20);
1116 size -= 1;
1117 }
1118
1119 return code;
1120 }
1121
1122 /*
1123 * mono_arch_get_vcall_slot_addr:
1124 *
1125 * Determine the vtable slot used by a virtual call.
1126 */
1127 gpointer*
1128 mono_arch_get_vcall_slot_addr (guint8 *code8, mgreg_t *regs)
1129 {
1130 guint32 *code = (guint32*)((unsigned long)code8 & ~3);
1131
1132 DEBUG_FUNC_ENTER();
1133
1134 code -= 2;
1135 /* This is the special virtual call token */
1136 if (code [-1] != 0x34000eee) /* ldo 0x777(r0),r0 */
1137 return NULL;
1138
1139 if ((code [0] >> 26) == 0x39 && /* ble */
1140 (code [-2] >> 26) == 0x12) { /* ldw */
1141 guint32 ldw = code [-2];
1142 guint32 reg = (ldw >> 21) & 0x1f;
1143 gint32 disp = ((ldw & 1) ? (-1 << 13) : 0) | ((ldw & 0x3fff) >> 1);
1144 /* FIXME: we are not guaranteed that reg is saved in the LMF.
1145 * In fact, it probably isn't, since it is allocated as a
1146 * callee register. Right now just return an address; this
1147 * is sufficient for non-AOT operation
1148 */
1149 // return (gpointer)((guint8*)regs [reg] + disp);
1150 return code;
1151 }
1152 else
1153 g_assert_not_reached ();
1154
1155 DEBUG_FUNC_EXIT();
1156 }
1157
1158 /* ins->dreg = *(ins->inst_desgbasereg + ins->inst_offset) */
1159 #define EMIT_LOAD_MEMBASE(ins, op) do { \
1160 if (!hppa_check_bits (ins->inst_offset, 14)) { \
1161 hppa_set (code, ins->inst_offset, hppa_r1); \
1162 hppa_ ## op ## x (code, hppa_r1, ins->inst_basereg, ins->dreg); \
1163 } \
1164 else { \
1165 hppa_ ## op (code, ins->inst_offset, ins->inst_basereg, ins->dreg); \
1166 } \
1167 } while (0)
1168
1169 #define EMIT_COND_BRANCH_FLAGS(ins,r1,r2,b0,b1) do {\
1170 if (b0) \
1171 hppa_combf (code, r1, r2, b1, 2); \
1172 else \
1173 hppa_combt (code, r1, r2, b1, 2); \
1174 hppa_nop (code); \
1175 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \
1176 hppa_bl (code, 0, hppa_r0); \
1177 hppa_nop (code); \
1178 } while (0)
1179
1180 #define EMIT_COND_BRANCH(ins,r1,r2,cond) EMIT_COND_BRANCH_FLAGS(ins, r1, r2, branch_b0_table [(cond)], branch_b1_table [(cond)])
1181
1182 #define EMIT_FLOAT_COND_BRANCH_FLAGS(ins,r1,r2,b0) do {\
1183 hppa_fcmp (code, HPPA_FP_FMT_DBL, b0, r1, r2); \
1184 hppa_ftest (code, 0); \
1185 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \
1186 hppa_bl (code, 8, hppa_r0); \
1187 hppa_nop (code); \
1188 } while (0)
1189
1190 #define EMIT_FLOAT_COND_BRANCH(ins,r1,r2,cond) EMIT_FLOAT_COND_BRANCH_FLAGS(ins, r1, r2, float_branch_table [cond])
1191
1192 #define EMIT_COND_SYSTEM_EXCEPTION_FLAGS(r1,r2,b0,b1,exc_name) \
1193 do { \
1194 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump)); \
1195 ovfj->data.exception = (exc_name); \
1196 ovfj->ip_offset = (guint8*)code - cfg->native_code; \
1197 hppa_bl (code, 8, hppa_r2); \
1198 hppa_depi (code, 0, 31, 2, hppa_r2); \
1199 hppa_ldo (code, 8, hppa_r2, hppa_r2); \
1200 if (b0) \
1201 hppa_combf (code, r1, r2, b1, 2); \
1202 else \
1203 hppa_combt (code, r1, r2, b1, 2); \
1204 hppa_nop (code); \
1205 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj); \
1206 hppa_bl (code, 0, hppa_r0); \
1207 hppa_nop (code); \
1208 } while (0)
1209
1210 #define EMIT_COND_SYSTEM_EXCEPTION(r1,r2,cond,exc_name) EMIT_COND_SYSTEM_EXCEPTION_FLAGS(r1, r2, branch_b0_table [(cond)], branch_b1_table [(cond)], (exc_name))
1211
1212 /* TODO: MEM_INDEX_REG - cannot be r1 */
1213 #define MEM_INDEX_REG hppa_r31
1214 /* *(ins->inst_destbasereg + ins->inst_offset) = ins->inst_imm */
1215 #define EMIT_STORE_MEMBASE_IMM(ins, op) do { \
1216 guint32 sreg; \
1217 if (ins->inst_imm == 0) \
1218 sreg = hppa_r0; \
1219 else { \
1220 hppa_set (code, ins->inst_imm, hppa_r1); \
1221 sreg = hppa_r1; \
1222 } \
1223 if (!hppa_check_bits (ins->inst_offset, 14)) { \
1224 hppa_set (code, ins->inst_offset, MEM_INDEX_REG); \
1225 hppa_addl (code, ins->inst_destbasereg, MEM_INDEX_REG, MEM_INDEX_REG); \
1226 hppa_ ## op (code, sreg, 0, MEM_INDEX_REG); \
1227 } \
1228 else { \
1229 hppa_ ## op (code, sreg, ins->inst_offset, ins->inst_destbasereg); \
1230 } \
1231 } while (0)
1232
1233 /* *(ins->inst_destbasereg + ins->inst_offset) = ins->sreg1 */
1234 #define EMIT_STORE_MEMBASE_REG(ins, op) do { \
1235 if (!hppa_check_bits (ins->inst_offset, 14)) { \
1236 hppa_set (code, ins->inst_offset, MEM_INDEX_REG); \
1237 hppa_addl (code, ins->inst_destbasereg, MEM_INDEX_REG, MEM_INDEX_REG); \
1238 hppa_ ## op (code, ins->sreg1, 0, MEM_INDEX_REG); \
1239 } \
1240 else { \
1241 hppa_ ## op (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); \
1242 } \
1243 } while (0)
1244
1245 void
1246 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
1247 {
1248 MonoInst *ins;
1249 MonoCallInst *call;
1250 guint offset;
1251 guint32 *code = (guint32*)(cfg->native_code + cfg->code_len);
1252 MonoInst *last_ins = NULL;
1253 int max_len, cpos;
1254 const char *spec;
1255
1256 DEBUG_FUNC_ENTER();
1257
1258 if (cfg->verbose_level > 2)
1259 g_print ("[%s::%s] Basic block %d starting at offset 0x%x\n", cfg->method->klass->name, cfg->method->name, bb->block_num, bb->native_offset);
1260
1261 cpos = bb->max_offset;
1262
1263 if (cfg->prof_options & MONO_PROFILE_COVERAGE) {
1264 NOT_IMPLEMENTED;
1265 }
1266
1267 MONO_BB_FOR_EACH_INS (bb, ins) {
1268 guint8* code_start;
1269
1270 offset = (guint8*)code - cfg->native_code;
1271
1272 spec = ins_get_spec (ins->opcode);
1273
1274 max_len = ((guint8 *)spec) [MONO_INST_LEN];
1275
1276 if (offset > (cfg->code_size - max_len - 16)) {
1277 cfg->code_size *= 2;
1278 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
1279 code = (guint32*)(cfg->native_code + offset);
1280 cfg->stat_code_reallocs++;
1281 }
1282 code_start = (guint8*)code;
1283 // if (ins->cil_code)
1284 // g_print ("cil code\n");
1285 mono_debug_record_line_number (cfg, ins, offset);
1286
1287 switch (ins->opcode) {
1288 case OP_RELAXED_NOP:
1289 break;
1290 case OP_STOREI1_MEMBASE_IMM:
1291 EMIT_STORE_MEMBASE_IMM (ins, stb);
1292 break;
1293 case OP_STOREI2_MEMBASE_IMM:
1294 EMIT_STORE_MEMBASE_IMM (ins, sth);
1295 break;
1296 case OP_STORE_MEMBASE_IMM:
1297 case OP_STOREI4_MEMBASE_IMM:
1298 EMIT_STORE_MEMBASE_IMM (ins, stw);
1299 break;
1300 case OP_STOREI1_MEMBASE_REG:
1301 EMIT_STORE_MEMBASE_REG (ins, stb);
1302 break;
1303 case OP_STOREI2_MEMBASE_REG:
1304 EMIT_STORE_MEMBASE_REG (ins, sth);
1305 break;
1306 case OP_STORE_MEMBASE_REG:
1307 case OP_STOREI4_MEMBASE_REG:
1308 EMIT_STORE_MEMBASE_REG (ins, stw);
1309 break;
1310 case OP_LOADU1_MEMBASE:
1311 EMIT_LOAD_MEMBASE (ins, ldb);
1312 break;
1313 case OP_LOADI1_MEMBASE:
1314 EMIT_LOAD_MEMBASE (ins, ldb);
1315 hppa_extrs (code, ins->dreg, 31, 8, ins->dreg);
1316 break;
1317 case OP_LOADU2_MEMBASE:
1318 EMIT_LOAD_MEMBASE (ins, ldh);
1319 break;
1320 case OP_LOADI2_MEMBASE:
1321 EMIT_LOAD_MEMBASE (ins, ldh);
1322 hppa_extrs (code, ins->dreg, 31, 16, ins->dreg);
1323 break;
1324 case OP_LOAD_MEMBASE:
1325 case OP_LOADI4_MEMBASE:
1326 case OP_LOADU4_MEMBASE:
1327 EMIT_LOAD_MEMBASE (ins, ldw);
1328 break;
1329 case CEE_CONV_I1:
1330 hppa_extrs (code, ins->sreg1, 31, 8, ins->dreg);
1331 break;
1332 case CEE_CONV_I2:
1333 hppa_extrs (code, ins->sreg1, 31, 16, ins->dreg);
1334 break;
1335 case CEE_CONV_U1:
1336 hppa_extru (code, ins->sreg1, 31, 8, ins->dreg);
1337 break;
1338 case CEE_CONV_U2:
1339 hppa_extru (code, ins->sreg1, 31, 16, ins->dreg);
1340 break;
1341 case CEE_CONV_U:
1342 case CEE_CONV_I4:
1343 case CEE_CONV_U4:
1344 case OP_MOVE:
1345 if (ins->sreg1 != ins->dreg)
1346 hppa_copy (code, ins->sreg1, ins->dreg);
1347 break;
1348 case OP_SETLRET:
1349 hppa_copy (code, ins->sreg1 + 1, ins->dreg);
1350 hppa_copy (code, ins->sreg1, ins->dreg + 1);
1351 break;
1352
1353 case OP_BREAK:
1354 /* break 4,8 - this is what gdb normally uses... */
1355 *code++ = 0x00010004;
1356 break;
1357 case OP_ADDCC:
1358 case CEE_ADD:
1359 hppa_add (code, ins->sreg1, ins->sreg2, ins->dreg);
1360 break;
1361 case OP_ADC:
1362 hppa_addc (code, ins->sreg1, ins->sreg2, ins->dreg);
1363 break;
1364 case OP_ADDCC_IMM:
1365 case OP_ADD_IMM:
1366 hppa_addi (code, ins->inst_imm, ins->sreg1, ins->dreg);
1367 break;
1368 case OP_ADC_IMM:
1369 hppa_set (code, ins->inst_imm, hppa_r1);
1370 hppa_addc (code, ins->sreg1, hppa_r1, ins->dreg);
1371 break;
1372 case OP_HPPA_ADD_OVF: {
1373 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1374 hppa_bl (code, 8, hppa_r2);
1375 hppa_depi (code, 0, 31, 2, hppa_r2);
1376 hppa_ldo (code, 12, hppa_r2, hppa_r2);
1377
1378 if (ins->backend.reg3 == CEE_ADD_OVF)
1379 hppa_add_cond (code, HPPA_ADD_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1380 else
1381 hppa_add_cond (code, HPPA_ADD_COND_NUV, ins->sreg1, ins->sreg2, ins->dreg);
1382
1383 ovfj->data.exception = "OverflowException";
1384 ovfj->ip_offset = (guint8*)code - cfg->native_code;
1385 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1386 hppa_bl_n (code, 8, hppa_r0);
1387 break;
1388 }
1389 case OP_HPPA_ADDC_OVF: {
1390 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1391 hppa_bl (code, 8, hppa_r2);
1392 hppa_depi (code, 0, 31, 2, hppa_r2);
1393 hppa_ldo (code, 12, hppa_r2, hppa_r2);
1394
1395 if (ins->backend.reg3 == OP_LADD_OVF)
1396 hppa_addc_cond (code, HPPA_ADD_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1397 else
1398 hppa_addc_cond (code, HPPA_ADD_COND_NUV, ins->sreg1, ins->sreg2, ins->dreg);
1399
1400 ovfj->data.exception = "OverflowException";
1401 ovfj->ip_offset = (guint8*)code - cfg->native_code;
1402 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1403 hppa_bl_n (code, 8, hppa_r0);
1404 break;
1405 }
1406 case OP_SUBCC:
1407 case CEE_SUB:
1408 hppa_sub (code, ins->sreg1, ins->sreg2, ins->dreg);
1409 break;
1410 case OP_SUBCC_IMM:
1411 case OP_SUB_IMM:
1412 hppa_addi (code, -ins->inst_imm, ins->sreg1, ins->dreg);
1413 break;
1414 case OP_SBB:
1415 hppa_subb (code, ins->sreg1, ins->sreg2, ins->dreg);
1416 break;
1417 case OP_SBB_IMM:
1418 hppa_set (code, ins->inst_imm, hppa_r1);
1419 hppa_subb (code, ins->sreg1, hppa_r1, ins->dreg);
1420 break;
1421 case OP_HPPA_SUB_OVF: {
1422 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1423 hppa_bl (code, 8, hppa_r2);
1424 hppa_depi (code, 0, 31, 2, hppa_r2);
1425 hppa_ldo (code, 12, hppa_r2, hppa_r2);
1426 hppa_sub_cond (code, HPPA_SUB_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1427 ovfj->data.exception = "OverflowException";
1428 ovfj->ip_offset = (guint8*)code - cfg->native_code;
1429 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1430 hppa_bl_n (code, 8, hppa_r0);
1431 break;
1432 }
1433 case OP_HPPA_SUBB_OVF: {
1434 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1435 hppa_bl (code, 8, hppa_r2);
1436 hppa_depi (code, 0, 31, 2, hppa_r2);
1437 hppa_ldo (code, 12, hppa_r2, hppa_r2);
1438
1439 hppa_subb_cond (code, HPPA_SUB_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1440 ovfj->data.exception = "OverflowException";
1441 ovfj->ip_offset = (guint8*)code - cfg->native_code;
1442 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1443 hppa_bl_n (code, 8, hppa_r0);
1444 break;
1445 }
1446
1447 case CEE_AND:
1448 hppa_and (code, ins->sreg1, ins->sreg2, ins->dreg);
1449 break;
1450 case OP_AND_IMM:
1451 hppa_set (code, ins->inst_imm, hppa_r1);
1452 hppa_and (code, ins->sreg1, hppa_r1, ins->dreg);
1453 break;
1454
1455 case CEE_OR:
1456 hppa_or (code, ins->sreg1, ins->sreg2, ins->dreg);
1457 break;
1458
1459 case OP_OR_IMM:
1460 hppa_set (code, ins->inst_imm, hppa_r1);
1461 hppa_or (code, ins->sreg1, hppa_r1, ins->dreg);
1462 break;
1463
1464 case CEE_XOR:
1465 hppa_xor (code, ins->sreg1, ins->sreg2, ins->dreg);
1466 break;
1467 case OP_XOR_IMM:
1468 hppa_set (code, ins->inst_imm, hppa_r1);
1469 hppa_xor (code, ins->sreg1, hppa_r1, ins->dreg);
1470 break;
1471 case CEE_SHL:
1472 if (ins->sreg1 != ins->dreg) {
1473 hppa_shl (code, ins->sreg1, ins->sreg2, ins->dreg);
1474 }
1475 else {
1476 hppa_copy (code, ins->sreg1, hppa_r1);
1477 hppa_shl (code, hppa_r1, ins->sreg2, ins->dreg);
1478 }
1479 break;
1480 case OP_SHL_IMM:
1481 case OP_ISHL_IMM:
1482 g_assert (ins->inst_imm < 32);
1483 if (ins->sreg1 != ins->dreg) {
1484 hppa_zdep (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1485 }
1486 else {
1487 hppa_copy (code, ins->sreg1, hppa_r1);
1488 hppa_zdep (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1489 }
1490 break;
1491 case CEE_SHR:
1492 if (ins->sreg1 != ins->dreg) {
1493 hppa_shr (code, ins->sreg1, ins->sreg2, ins->dreg);
1494 }
1495 else {
1496 hppa_copy (code, ins->sreg1, hppa_r1);
1497 hppa_shr (code, hppa_r1, ins->sreg2, ins->dreg);
1498 }
1499 break;
1500 case OP_SHR_IMM:
1501 g_assert (ins->inst_imm < 32);
1502 if (ins->sreg1 != ins->dreg) {
1503 hppa_extrs (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1504 }
1505 else {
1506 hppa_copy (code, ins->sreg1, hppa_r1);
1507 hppa_extrs (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1508 }
1509 break;
1510 case OP_SHR_UN_IMM:
1511 g_assert (ins->inst_imm < 32);
1512 if (ins->sreg1 != ins->dreg) {
1513 hppa_extru (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1514 }
1515 else {
1516 hppa_copy (code, ins->sreg1, hppa_r1);
1517 hppa_extru (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1518 }
1519 break;
1520 case CEE_SHR_UN:
1521 if (ins->sreg1 != ins->dreg) {
1522 hppa_lshr (code, ins->sreg1, ins->sreg2, ins->dreg);
1523 }
1524 else {
1525 hppa_copy (code, ins->sreg1, hppa_r1);
1526 hppa_lshr (code, hppa_r1, ins->sreg2, ins->dreg);
1527 }
1528 break;
1529 case CEE_NOT:
1530 hppa_not (code, ins->sreg1, ins->dreg);
1531 break;
1532 case CEE_NEG:
1533 hppa_subi (code, 0, ins->sreg1, ins->dreg);
1534 break;
1535
1536 case CEE_MUL:
1537 case OP_MUL_IMM:
1538 /* Should have been rewritten using xmpyu */
1539 g_assert_not_reached ();
1540
1541 case OP_ICONST:
1542 if ((ins->inst_c0 > 0 && ins->inst_c0 >= (1 << 13)) ||
1543 (ins->inst_c0 < 0 && ins->inst_c0 < -(1 << 13))) {
1544 hppa_ldil (code, hppa_lsel (ins->inst_c0), ins->dreg);
1545 hppa_ldo (code, hppa_rsel (ins->inst_c0), ins->dreg, ins->dreg);
1546 } else {
1547 hppa_ldo (code, ins->inst_c0, hppa_r0, ins->dreg);
1548 }
1549 break;
1550 case OP_AOTCONST:
1551 g_assert_not_reached ();
1552 /*
1553 mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
1554 hppa_set_template (code, ins->dreg);
1555 */
1556 g_warning ("unimplemented opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
1557 NOT_IMPLEMENTED;
1558 break;
1559 case OP_FMOVE:
1560 if (ins->sreg1 != ins->dreg)
1561 hppa_fcpy (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->dreg);
1562 break;
1563
1564 case OP_HPPA_OUTARG_R4CONST:
1565 hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1566 hppa_fldwx (code, hppa_r0, hppa_r1, ins->dreg, 0);
1567 break;
1568
1569 case OP_HPPA_OUTARG_REGOFFSET:
1570 hppa_ldo (code, ins->inst_offset, ins->inst_basereg, ins->dreg);
1571 break;
1572
1573 case OP_JMP:
1574 /*
1575 * Keep in sync with mono_arch_emit_epilog
1576 */
1577 g_assert (!cfg->method->save_lmf);
1578 mono_add_patch_info (cfg, (guint8*) code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, ins->inst_p0);
1579 hppa_bl (code, 8, hppa_r0);
1580 break;
1581 case OP_CHECK_THIS:
1582 /* ensure ins->sreg1 is not NULL */
1583 hppa_ldw (code, 0, ins->sreg1, hppa_r1);
1584 break;
1585 case OP_ARGLIST:
1586 break;
1587 case OP_FCALL:
1588 case OP_LCALL:
1589 case OP_VCALL:
1590 case OP_VOIDCALL:
1591 case OP_CALL:
1592 call = (MonoCallInst*)ins;
1593 if (ins->flags & MONO_INST_HAS_METHOD)
1594 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_METHOD, call->method);
1595 else
1596 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, call->fptr);
1597 hppa_ldil (code, 0, hppa_r1);
1598 hppa_ldo (code, 0, hppa_r1, hppa_r1);
1599 /*
1600 * We may have loaded an actual function address, or
1601 * it might be a plabel. Check to see if the plabel
1602 * bit is set, and load the actual fptr from it if
1603 * needed
1604 */
1605 hppa_bb_n (code, HPPA_BIT_COND_MSB_CLR, hppa_r1, 30, 2);
1606 hppa_depi (code, 0, 31, 2, hppa_r1);
1607 hppa_ldw (code, 4, hppa_r1, hppa_r19);
1608 hppa_ldw (code, 0, hppa_r1, hppa_r1);
1609 hppa_ble (code, 0, hppa_r1);
1610 hppa_copy (code, hppa_r31, hppa_r2);
1611 if (call->signature->ret->type == MONO_TYPE_R4)
1612 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr4, hppa_fr4);
1613 break;
1614 case OP_FCALL_REG:
1615 case OP_LCALL_REG:
1616 case OP_VCALL_REG:
1617 case OP_VOIDCALL_REG:
1618 case OP_CALL_REG:
1619 call = (MonoCallInst*)ins;
1620 g_assert (!call->virtual);
1621 hppa_copy (code, ins->sreg1, hppa_r1);
1622 hppa_bb_n (code, HPPA_BIT_COND_MSB_CLR, hppa_r1, 30, 2);
1623 hppa_depi (code, 0, 31, 2, hppa_r1);
1624 hppa_ldw (code, 4, hppa_r1, hppa_r19);
1625 hppa_ldw (code, 0, hppa_r1, hppa_r1);
1626 hppa_ble (code, 0, hppa_r1);
1627 hppa_copy (code, hppa_r31, hppa_r2);
1628 if (call->signature->ret->type == MONO_TYPE_R4)
1629 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr4, hppa_fr4);
1630 break;
1631 case OP_FCALL_MEMBASE:
1632 case OP_LCALL_MEMBASE:
1633 case OP_VCALL_MEMBASE:
1634 case OP_VOIDCALL_MEMBASE:
1635 case OP_CALL_MEMBASE:
1636 call = (MonoCallInst*)ins;
1637 /* jump to ins->inst_sreg1 + ins->inst_offset */
1638 hppa_ldw (code, ins->inst_offset, ins->sreg1, hppa_r1);
1639
1640 /* For virtual calls, emit a special token that can
1641 * be used by get_vcall_slot_addr
1642 */
1643 if (call->virtual)
1644 hppa_ldo (code, 0x777, hppa_r0, hppa_r0);
1645 hppa_ble (code, 0, hppa_r1);
1646 hppa_copy (code, hppa_r31, hppa_r2);
1647 break;
1648 case OP_LOCALLOC: {
1649 guint32 size_reg;
1650
1651 /* Keep alignment */
1652 hppa_ldo (code, MONO_ARCH_LOCALLOC_ALIGNMENT - 1, ins->sreg1, ins->dreg);
1653 hppa_depi (code, 0, 31, 6, ins->dreg);
1654 hppa_copy (code, hppa_sp, hppa_r1);
1655 hppa_addl (code, ins->dreg, hppa_sp, hppa_sp);
1656 hppa_copy (code, hppa_r1, ins->dreg);
1657
1658 if (ins->flags & MONO_INST_INIT) {
1659 hppa_stw (code, hppa_r0, 0, hppa_r1);
1660 hppa_combt (code, hppa_r1, hppa_sp, HPPA_CMP_COND_ULT, -3);
1661 hppa_ldo (code, 4, hppa_r1, hppa_r1);
1662 }
1663 break;
1664 }
1665
1666 case OP_THROW:
1667 hppa_copy (code, ins->sreg1, hppa_r26);
1668 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
1669 (gpointer)"mono_arch_throw_exception");
1670 hppa_ldil (code, 0, hppa_r1);
1671 hppa_ldo (code, 0, hppa_r1, hppa_r1);
1672 hppa_ble (code, 0, hppa_r1);
1673 hppa_copy (code, hppa_r31, hppa_r2);
1674 /* should never return */
1675 *code++ = 0xffeeddcc;
1676 break;
1677 case OP_RETHROW:
1678 hppa_copy (code, ins->sreg1, hppa_r26);
1679 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
1680 (gpointer)"mono_arch_rethrow_exception");
1681 hppa_ldil (code, 0, hppa_r1);
1682 hppa_ldo (code, 0, hppa_r1, hppa_r1);
1683 hppa_ble (code, 0, hppa_r1);
1684 hppa_copy (code, hppa_r31, hppa_r2);
1685 /* should never return */
1686 *code++ = 0xffeeddcc;
1687 break;
1688 case OP_START_HANDLER:
1689 if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1690 hppa_stw (code, hppa_r2, ins->inst_left->inst_offset, ins->inst_left->inst_basereg);
1691 else {
1692 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1693 hppa_addl (code, ins->inst_left->inst_basereg, hppa_r1, hppa_r1);
1694 hppa_stw (code, hppa_r2, 0, hppa_r1);
1695 }
1696 break;
1697 case OP_ENDFILTER:
1698 if (ins->sreg1 != hppa_r26)
1699 hppa_copy (code, ins->sreg1, hppa_r26);
1700 if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1701 hppa_ldw (code, ins->inst_left->inst_offset, ins->inst_left->inst_basereg, hppa_r2);
1702 else {
1703 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1704 hppa_ldwx (code, hppa_r1, ins->inst_left->inst_basereg, hppa_r2);
1705 }
1706 hppa_bv (code, hppa_r0, hppa_r2);
1707 hppa_nop (code);
1708 break;
1709 case OP_ENDFINALLY:
1710 if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1711 hppa_ldw (code, ins->inst_left->inst_offset, ins->inst_left->inst_basereg, hppa_r1);
1712 else {
1713 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1714 hppa_ldwx (code, hppa_r1, ins->inst_left->inst_basereg, hppa_r1);
1715 }
1716 hppa_bv (code, hppa_r0, hppa_r1);
1717 hppa_nop (code);
1718 break;
1719 case OP_CALL_HANDLER:
1720 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_target_bb);
1721 hppa_bl (code, 0, hppa_r2);
1722 hppa_nop (code);
1723 break;
1724 case OP_LABEL:
1725 ins->inst_c0 = (guint8*)code - cfg->native_code;
1726 break;
1727 case OP_BR: {
1728 guint32 target;
1729 DEBUG (printf ("target: %p, next: %p, curr: %p, last: %p\n", ins->inst_target_bb, bb->next_bb, ins, bb->last_ins));
1730 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_BB, ins->inst_target_bb);
1731 hppa_bl (code, 8, hppa_r0);
1732 /* TODO: if the branch is too long, we may need to
1733 * use a long-branch sequence:
1734 * hppa_ldil (code, 0, hppa_r1);
1735 * hppa_ldo (code, 0, hppa_r1, hppa_r1);
1736 * hppa_bv (code, hppa_r0, hppa_r1);
1737 */
1738 hppa_nop (code);
1739 break;
1740 }
1741 case OP_BR_REG:
1742 hppa_bv (code, hppa_r0, ins->sreg1);
1743 hppa_nop(code);
1744 break;
1745
1746 case OP_SWITCH: {
1747 int i;
1748
1749 max_len += 8 * GPOINTER_TO_INT (ins->klass);
1750 if (offset > (cfg->code_size - max_len - 16)) {
1751 cfg->code_size += max_len;
1752 cfg->code_size *= 2;
1753 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
1754 code = cfg->native_code + offset;
1755 code_start = (guint8*)code;
1756 }
1757 hppa_blr (code, ins->sreg1, hppa_r0);
1758 hppa_nop (code);
1759 for (i = 0; i < GPOINTER_TO_INT (ins->klass); ++i) {
1760 *code++ = 0xdeadbeef;
1761 *code++ = 0xdeadbeef;
1762 }
1763 break;
1764 }
1765
1766 /* comclr is cool :-) */
1767 case OP_HPPA_CEQ:
1768 hppa_comclr_cond (code, HPPA_SUB_COND_NE, ins->sreg1, ins->sreg2, ins->dreg);
1769 hppa_ldo (code, 1, hppa_r0, ins->dreg);
1770 break;
1771
1772 case OP_HPPA_CLT:
1773 hppa_comclr_cond (code, HPPA_SUB_COND_SGE, ins->sreg1, ins->sreg2, ins->dreg);
1774 hppa_ldo (code, 1, hppa_r0, ins->dreg);
1775 break;
1776
1777 case OP_HPPA_CLT_UN:
1778 hppa_comclr_cond (code, HPPA_SUB_COND_UGE, ins->sreg1, ins->sreg2, ins->dreg);
1779 hppa_ldo (code, 1, hppa_r0, ins->dreg);
1780 break;
1781
1782 case OP_HPPA_CGT:
1783 hppa_comclr_cond (code, HPPA_SUB_COND_SLE, ins->sreg1, ins->sreg2, ins->dreg);
1784 hppa_ldo (code, 1, hppa_r0, ins->dreg);
1785 break;
1786
1787 case OP_HPPA_CGT_UN:
1788 hppa_comclr_cond (code, HPPA_SUB_COND_ULE, ins->sreg1, ins->sreg2, ins->dreg);
1789 hppa_ldo (code, 1, hppa_r0, ins->dreg);
1790 break;
1791
1792 case OP_CEQ:
1793 case OP_CLT:
1794 case OP_CLT_UN:
1795 case OP_CGT:
1796 case OP_CGT_UN:
1797 case OP_COND_EXC_EQ:
1798 case OP_COND_EXC_NE_UN:
1799 case OP_COND_EXC_LT:
1800 case OP_COND_EXC_LT_UN:
1801 case OP_COND_EXC_GT:
1802 case OP_COND_EXC_GT_UN:
1803 case OP_COND_EXC_GE:
1804 case OP_COND_EXC_GE_UN:
1805 case OP_COND_EXC_LE:
1806 case OP_COND_EXC_LE_UN:
1807 case OP_COND_EXC_OV:
1808 case OP_COND_EXC_NO:
1809 case OP_COND_EXC_C:
1810 case OP_COND_EXC_NC:
1811 case OP_COND_EXC_IOV:
1812 case OP_COND_EXC_IC:
1813 case CEE_BEQ:
1814 case CEE_BNE_UN:
1815 case CEE_BLT:
1816 case CEE_BLT_UN:
1817 case CEE_BGT:
1818 case CEE_BGT_UN:
1819 case CEE_BGE:
1820 case CEE_BGE_UN:
1821 case CEE_BLE:
1822 case CEE_BLE_UN:
1823 case OP_COMPARE:
1824 case OP_LCOMPARE:
1825 case OP_ICOMPARE:
1826 case OP_COMPARE_IMM:
1827 case OP_ICOMPARE_IMM:
1828 g_warning ("got opcode %s in %s(), should be reduced\n", mono_inst_name (ins->opcode), __FUNCTION__);
1829 g_assert_not_reached ();
1830 break;
1831
1832 case OP_HPPA_BEQ:
1833 case OP_HPPA_BNE:
1834 case OP_HPPA_BLT:
1835 case OP_HPPA_BLT_UN:
1836 case OP_HPPA_BGT:
1837 case OP_HPPA_BGT_UN:
1838 case OP_HPPA_BGE:
1839 case OP_HPPA_BGE_UN:
1840 case OP_HPPA_BLE:
1841 case OP_HPPA_BLE_UN:
1842 EMIT_COND_BRANCH (ins, ins->sreg1, ins->sreg2, ins->opcode - OP_HPPA_BEQ);
1843 break;
1844
1845 case OP_HPPA_COND_EXC_EQ:
1846 case OP_HPPA_COND_EXC_GE:
1847 case OP_HPPA_COND_EXC_GT:
1848 case OP_HPPA_COND_EXC_LE:
1849 case OP_HPPA_COND_EXC_LT:
1850 case OP_HPPA_COND_EXC_NE_UN:
1851 case OP_HPPA_COND_EXC_GE_UN:
1852 case OP_HPPA_COND_EXC_GT_UN:
1853 case OP_HPPA_COND_EXC_LE_UN:
1854 case OP_HPPA_COND_EXC_LT_UN:
1855 EMIT_COND_SYSTEM_EXCEPTION (ins->sreg1, ins->sreg2, ins->opcode - OP_HPPA_COND_EXC_EQ, ins->inst_p1);
1856 break;
1857
1858 case OP_HPPA_COND_EXC_OV:
1859 case OP_HPPA_COND_EXC_NO:
1860 case OP_HPPA_COND_EXC_C:
1861 case OP_HPPA_COND_EXC_NC:
1862 NOT_IMPLEMENTED;
1863
1864 /* floating point opcodes */
1865 case OP_R8CONST:
1866 hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1867 hppa_flddx (code, hppa_r0, hppa_r1, ins->dreg);
1868 break;
1869 case OP_R4CONST:
1870 hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1871 hppa_fldwx (code, hppa_r0, hppa_r1, hppa_fr31, 0);
1872 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1873 break;
1874 case OP_STORER8_MEMBASE_REG:
1875 hppa_set (code, ins->inst_offset, hppa_r1);
1876 hppa_fstdx (code, ins->sreg1, hppa_r1, ins->inst_destbasereg);
1877 break;
1878 case OP_LOADR8_MEMBASE:
1879 hppa_set (code, ins->inst_offset, hppa_r1);
1880 hppa_flddx (code, hppa_r1, ins->inst_basereg, ins->dreg);
1881 break;
1882 case OP_STORER4_MEMBASE_REG:
1883 hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, hppa_fr31);
1884 if (hppa_check_bits (ins->inst_offset, 5)) {
1885 hppa_fstws (code, hppa_fr31, 0, ins->inst_offset, ins->inst_destbasereg);
1886 } else {
1887 hppa_set (code, ins->inst_offset, hppa_r1);
1888 hppa_fstwx (code, hppa_fr31, 0, hppa_r1, ins->inst_destbasereg);
1889 }
1890 break;
1891 case OP_HPPA_STORER4_LEFT:
1892 case OP_HPPA_STORER4_RIGHT:
1893 if (hppa_check_bits (ins->inst_offset, 5)) {
1894 hppa_fstws (code, ins->sreg1, (ins->opcode == OP_HPPA_STORER4_RIGHT), ins->inst_offset, ins->inst_destbasereg);
1895 } else {
1896 hppa_set (code, ins->inst_offset, hppa_r1);
1897 hppa_fstwx (code, ins->sreg1, (ins->opcode == OP_HPPA_STORER4_RIGHT), hppa_r1, ins->inst_destbasereg);
1898 }
1899 break;
1900 case OP_LOADR4_MEMBASE:
1901 if (hppa_check_bits (ins->inst_offset, 5)) {
1902 hppa_fldws (code, ins->inst_offset, ins->inst_basereg, hppa_fr31, 0);
1903 } else {
1904 hppa_set (code, ins->inst_offset, hppa_r1);
1905 hppa_fldwx (code, hppa_r1, ins->inst_basereg, hppa_fr31, 0);
1906 }
1907 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1908 break;
1909 case OP_HPPA_LOADR4_LEFT:
1910 case OP_HPPA_LOADR4_RIGHT:
1911 if (hppa_check_bits (ins->inst_offset, 5)) {
1912 hppa_fldws (code, ins->inst_offset, ins->inst_basereg, ins->dreg, (ins->opcode == OP_HPPA_LOADR4_RIGHT));
1913 } else {
1914 hppa_set (code, ins->inst_offset, hppa_r1);
1915 hppa_fldwx (code, hppa_r1, ins->inst_basereg, ins->dreg, (ins->opcode == OP_HPPA_LOADR4_RIGHT));
1916 }
1917 break;
1918
1919 case CEE_CONV_R4:
1920 hppa_stw (code, ins->sreg1, -16, hppa_sp);
1921 hppa_fldws (code, -16, hppa_sp, hppa_fr31, 0);
1922 hppa_fcnvxf (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_SGL, hppa_fr31, ins->dreg);
1923 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, ins->dreg, ins->dreg);
1924 break;
1925
1926 case OP_FCONV_TO_R4:
1927 /* reduce precision */
1928 hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, ins->dreg);
1929 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, ins->dreg, ins->dreg);
1930 break;
1931
1932 case OP_HPPA_SETF4REG:
1933 hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, ins->dreg);
1934 break;
1935 case CEE_CONV_R8:
1936 hppa_stw (code, ins->sreg1, -16, hppa_sp);
1937 hppa_fldws (code, -16, hppa_sp, hppa_fr31, 0);
1938 hppa_fcnvxf (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1939 break;
1940
1941 case OP_FCONV_TO_I1:
1942 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, TRUE);
1943 break;
1944 case OP_FCONV_TO_U1:
1945 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, FALSE);
1946 break;
1947 case OP_FCONV_TO_I2:
1948 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, TRUE);
1949 break;
1950 case OP_FCONV_TO_U2:
1951 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, FALSE);
1952 break;
1953 case OP_FCONV_TO_I4:
1954 case OP_FCONV_TO_I:
1955 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, TRUE);
1956 break;
1957 case OP_FCONV_TO_U4:
1958 case OP_FCONV_TO_U:
1959 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
1960 break;
1961
1962 case OP_FCONV_TO_I8:
1963 case OP_FCONV_TO_U8:
1964 g_assert_not_reached ();
1965 /* Implemented as helper calls */
1966 break;
1967 case OP_LCONV_TO_R_UN:
1968 g_assert_not_reached ();
1969 /* Implemented as helper calls */
1970 break;
1971
1972 case OP_LCONV_TO_OVF_I:
1973 NOT_IMPLEMENTED;
1974 break;
1975
1976 case OP_FADD:
1977 hppa_fadd (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1978 break;
1979 case OP_FSUB:
1980 hppa_fsub (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1981 break;
1982 case OP_FMUL:
1983 hppa_fmul (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1984 break;
1985 case OP_FDIV:
1986 hppa_fdiv (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1987 break;
1988 case OP_FREM:
1989 NOT_IMPLEMENTED;
1990 break;
1991
1992 case OP_FCOMPARE:
1993 g_assert_not_reached();
1994 break;
1995
1996 case OP_FCEQ:
1997 case OP_FCLT:
1998 case OP_FCLT_UN:
1999 case OP_FCGT:
2000 case OP_FCGT_UN:
2001 hppa_fcmp (code, HPPA_FP_FMT_DBL, float_ceq_table [ins->opcode - OP_FCEQ], ins->sreg1, ins->sreg2);
2002 hppa_ftest (code, 0);
2003 hppa_bl (code, 12, hppa_r0);
2004 hppa_ldo (code, 1, hppa_r0, ins->dreg);
2005 hppa_ldo (code, 0, hppa_r0, ins->dreg);
2006 break;
2007
2008 case OP_FBEQ:
2009 case OP_FBLT:
2010 case OP_FBGT:
2011 case OP_FBGE:
2012 case OP_FBLE:
2013 case OP_FBNE_UN:
2014 case OP_FBLT_UN:
2015 case OP_FBGT_UN:
2016 case OP_FBGE_UN:
2017 case OP_FBLE_UN:
2018 EMIT_FLOAT_COND_BRANCH (ins, ins->sreg1, ins->sreg2, ins->opcode - OP_FBEQ);
2019 break;
2020
2021 case OP_CKFINITE:
2022 case OP_MEMORY_BARRIER:
2023 break;
2024
2025 case OP_HPPA_XMPYU:
2026 hppa_xmpyu (code, ins->sreg1, ins->sreg2, ins->dreg);
2027 break;
2028
2029 default:
2030 g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
2031 g_assert_not_reached ();
2032 }
2033
2034 if ((((guint8*)code) - code_start) > max_len) {
2035 g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %d)",
2036 mono_inst_name (ins->opcode), max_len, ((guint8*)code) - code_start);
2037 g_assert_not_reached ();
2038 }
2039
2040 cpos += max_len;
2041
2042 last_ins = ins;
2043 }
2044
2045 cfg->code_len = (guint8*)code - cfg->native_code;
2046 DEBUG_FUNC_EXIT();
2047 }
2048
2049 void
2050 mono_arch_register_lowlevel_calls (void)
2051 {
2052 }
2053
2054 void
2055 mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, MonoCodeManager *dyn_code_mp, gboolean run_cctors)
2056 {
2057 MonoJumpInfo *patch_info;
2058
2059 DEBUG_FUNC_ENTER();
2060 /* FIXME: Move part of this to arch independent code */
2061 for (patch_info = ji; patch_info; patch_info = patch_info->next) {
2062 unsigned char *ip = patch_info->ip.i + code;
2063 gpointer target;
2064
2065 target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
2066 DEBUG (printf ("patch_info->type = %d, target = %p\n", patch_info->type, target));
2067
2068 switch (patch_info->type) {
2069 case MONO_PATCH_INFO_NONE:
2070 case MONO_PATCH_INFO_BB_OVF:
2071 case MONO_PATCH_INFO_EXC_OVF:
2072 continue;
2073
2074 case MONO_PATCH_INFO_IP:
2075 hppa_patch ((guint32 *)ip, ip);
2076 continue;
2077
2078 case MONO_PATCH_INFO_CLASS_INIT: {
2079 break;
2080 }
2081 case MONO_PATCH_INFO_METHOD_JUMP: {
2082 break;
2083 }
2084 case MONO_PATCH_INFO_SWITCH: {
2085 int i;
2086 gpointer *table = (gpointer *)target;
2087 ip += 8;
2088 for (i = 0; i < patch_info->data.table->table_size; i++) {
2089 DEBUG (printf ("Patching switch table, table[%d] = %p\n", i, table[i]));
2090 hppa_ldil (ip, hppa_lsel (table [i]), hppa_r1);
2091 hppa_be_n (ip, hppa_rsel (table [i]), hppa_r1);
2092 }
2093 continue;
2094 }
2095 default:
2096 break;
2097 }
2098 hppa_patch ((guint32 *)ip, target);
2099 }
2100
2101 DEBUG_FUNC_EXIT();
2102 }
2103
2104 void*
2105 mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
2106 {
2107 guint32 *code = (guint32*)p;
2108
2109 DEBUG_FUNC_ENTER();
2110
2111 hppa_set (code, cfg->method, hppa_r26);
2112 hppa_copy (code, hppa_r0, hppa_r25); /* NULL sp for now */
2113 hppa_set (code, func, hppa_r1);
2114 hppa_depi (code, 0, 31, 2, hppa_r1);
2115 hppa_ldw (code, 0, hppa_r1, hppa_r1);
2116 hppa_ble (code, 0, hppa_r1);
2117 hppa_copy (code, hppa_r31, hppa_r2);
2118
2119 DEBUG_FUNC_EXIT();
2120 return code;
2121 }
2122
2123 enum {
2124 SAVE_NONE,
2125 SAVE_STRUCT,
2126 SAVE_ONE,
2127 SAVE_TWO,
2128 SAVE_FP
2129 };
2130
2131 void*
2132 mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers)
2133 {
2134 guint32 *code = (guint32*)p;
2135 DEBUG_FUNC_ENTER();
2136 #if 0
2137 int save_mode = SAVE_NONE;
2138 MonoMethod *method = cfg->method;
2139
2140 switch (mono_type_get_underlying_type (mono_method_signature (method)->ret)->type) {
2141 case MONO_TYPE_VOID:
2142 /* special case string .ctor icall */
2143 if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
2144 save_mode = SAVE_ONE;
2145 else
2146 save_mode = SAVE_NONE;
2147 break;
2148 case MONO_TYPE_I8:
2149 case MONO_TYPE_U8:
2150 #ifdef SPARCV9
2151 save_mode = SAVE_ONE;
2152 #else
2153 save_mode = SAVE_TWO;
2154 #endif
2155 break;
2156 case MONO_TYPE_R4:
2157 case MONO_TYPE_R8:
2158 save_mode = SAVE_FP;
2159 break;
2160 case MONO_TYPE_VALUETYPE:
2161 save_mode = SAVE_STRUCT;
2162 break;
2163 default:
2164 save_mode = SAVE_ONE;
2165 break;
2166 }
2167
2168 /* Save the result to the stack and also put it into the output registers */
2169
2170 switch (save_mode) {
2171 case SAVE_TWO:
2172 /* V8 only */
2173 sparc_st_imm (code, sparc_i0, sparc_fp, 68);
2174 sparc_st_imm (code, sparc_i0, sparc_fp, 72);
2175 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2176 sparc_mov_reg_reg (code, sparc_i1, sparc_o2);
2177 break;
2178 case SAVE_ONE:
2179 sparc_sti_imm (code, sparc_i0, sparc_fp, ARGS_OFFSET);
2180 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2181 break;
2182 case SAVE_FP:
2183 #ifdef SPARCV9
2184 sparc_stdf_imm (code, sparc_f0, sparc_fp, ARGS_OFFSET);
2185 #else
2186 sparc_stdf_imm (code, sparc_f0, sparc_fp, 72);
2187 sparc_ld_imm (code, sparc_fp, 72, sparc_o1);
2188 sparc_ld_imm (code, sparc_fp, 72 + 4, sparc_o2);
2189 #endif
2190 break;
2191 case SAVE_STRUCT:
2192 #ifdef SPARCV9
2193 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2194 #else
2195 sparc_ld_imm (code, sparc_fp, 64, sparc_o1);
2196 #endif
2197 break;
2198 case SAVE_NONE:
2199 default:
2200 break;
2201 }
2202
2203 sparc_set (code, cfg->method, sparc_o0);
2204
2205 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_ABS, func);
2206 EMIT_CALL ();
2207
2208 /* Restore result */
2209
2210 switch (save_mode) {
2211 case SAVE_TWO:
2212 sparc_ld_imm (code, sparc_fp, 68, sparc_i0);
2213 sparc_ld_imm (code, sparc_fp, 72, sparc_i0);
2214 break;
2215 case SAVE_ONE:
2216 sparc_ldi_imm (code, sparc_fp, ARGS_OFFSET, sparc_i0);
2217 break;
2218 case SAVE_FP:
2219 sparc_lddf_imm (code, sparc_fp, ARGS_OFFSET, sparc_f0);
2220 break;
2221 case SAVE_NONE:
2222 default:
2223 break;
2224 }
2225 #endif
2226 DEBUG_FUNC_EXIT();
2227 return code;
2228 }
2229
2230 /*
2231 * The HPPA stack frame should look like this:
2232 *
2233 * ---------------------
2234 * incoming params area
2235 * ---------------------
2236 * linkage area size = ARGS_OFFSET
2237 * --------------------- fp = psp
2238 * HPPA_STACK_LMF_OFFSET
2239 * ---------------------
2240 * MonoLMF structure or saved registers
2241 * -------------------
2242 * locals size = cfg->stack_offset - cfg->param_area
2243 * ---------------------
2244 * params area size = cfg->param_area - ARGS_OFFSET (aligned)
2245 * ---------------------
2246 * callee linkage area size = ARGS_OFFSET
2247 * --------------------- sp
2248 */
2249 guint8 *
2250 mono_arch_emit_prolog (MonoCompile *cfg)
2251 {
2252 MonoMethod *method = cfg->method;
2253 MonoBasicBlock *bb;
2254 MonoMethodSignature *sig;
2255 MonoInst *inst;
2256 int alloc_size, pos, max_offset, i;
2257 guint8 *code;
2258 CallInfo *cinfo;
2259 int tracing = 0;
2260 int lmf_offset = 0;
2261
2262 DEBUG_FUNC_ENTER();
2263 if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
2264 tracing = 1;
2265
2266 sig = mono_method_signature (method);
2267 cfg->code_size = 512 + sig->param_count * 20;
2268 code = cfg->native_code = g_malloc (cfg->code_size);
2269
2270 /* TODO: enable tail call optimization */
2271 if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
2272 hppa_stw (code, hppa_r2, -20, hppa_sp);
2273 }
2274
2275 /* locals area */
2276 pos = HPPA_STACK_LMF_OFFSET;
2277
2278 /* figure out how much space we need for spilling */
2279 if (!method->save_lmf) {
2280 /* spill callee-save registers */
2281 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2282 for (i = 0; i < 32; i++) {
2283 if ((1 << i) & mask)
2284 pos += sizeof (gulong);
2285 }
2286 } else {
2287 lmf_offset = pos;
2288 pos += sizeof (MonoLMF);
2289 }
2290
2291 alloc_size = ALIGN_TO (pos + cfg->stack_offset, MONO_ARCH_FRAME_ALIGNMENT);
2292 g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT - 1)) == 0);
2293
2294 cfg->stack_usage = alloc_size;
2295
2296 if (alloc_size) {
2297 hppa_copy (code, hppa_r3, hppa_r1);
2298 hppa_copy (code, hppa_sp, hppa_r3);
2299 if (hppa_check_bits (alloc_size, 14))
2300 hppa_stwm (code, hppa_r1, alloc_size, hppa_sp);
2301 else {
2302 hppa_stwm (code, hppa_r1, 8100, hppa_sp);
2303 hppa_addil (code, hppa_lsel (alloc_size - 8100), hppa_sp);
2304 hppa_ldo (code, hppa_rsel (alloc_size - 8100), hppa_r1, hppa_sp);
2305 }
2306 }
2307
2308 /* compute max_offset in order to use short forward jumps
2309 * we always do it on hppa because the immediate displacement
2310 * for jumps is small
2311 */
2312 max_offset = 0;
2313 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
2314 MonoInst *ins = bb->code;
2315 bb->max_offset = max_offset;
2316
2317 if (cfg->prof_options & MONO_PROFILE_COVERAGE)
2318 max_offset += 6;
2319
2320 MONO_BB_FOR_EACH_INS (bb, ins)
2321 max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
2322 }
2323
2324 DEBUG (printf ("Incoming arguments: \n"));
2325 cinfo = get_call_info (sig, sig->pinvoke);
2326
2327 /* We do this first so that we don't have to worry about the LMF-
2328 * saving code clobbering r28
2329 */
2330 if (cinfo->struct_return)
2331 hppa_stw (code, hppa_r28, cfg->ret->inst_offset, hppa_sp);
2332
2333 /* Save the LMF or the spilled registers */
2334 pos = HPPA_STACK_LMF_OFFSET;
2335 if (!method->save_lmf) {
2336 /* spill callee-save registers */
2337 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2338 for (i = 0; i < 32; i++) {
2339 if ((1 << i) & mask) {
2340 if (i == hppa_r3) {
2341 hppa_ldw (code, 0, hppa_r3, hppa_r1);
2342 hppa_stw (code, hppa_r1, pos, hppa_r3);
2343 } else
2344 hppa_stw (code, i, pos, hppa_r3);
2345 pos += sizeof (gulong);
2346 }
2347 }
2348 } else {
2349 int ofs = lmf_offset + G_STRUCT_OFFSET (MonoLMF, regs);
2350 int reg;
2351
2352 hppa_ldw (code, 0, hppa_r3, hppa_r1);
2353 hppa_stw (code, hppa_r1, ofs, hppa_r3);
2354 ofs += sizeof (gulong);
2355 for (reg = 4; reg < 32; reg++) {
2356 if (HPPA_IS_SAVED_GREG (reg)) {
2357 hppa_stw (code, reg, ofs, hppa_r3);
2358 ofs += sizeof (gulong);
2359 }
2360 }
2361 /* We shouldn't need to save the FP regs.... */
2362 ofs = ALIGN_TO (ofs, sizeof(double));
2363 hppa_set (code, ofs, hppa_r1);
2364 for (reg = 0; reg < 32; reg++) {
2365 if (HPPA_IS_SAVED_FREG (reg)) {
2366 hppa_fstdx (code, reg, hppa_r1, hppa_r3);
2367 hppa_ldo (code, sizeof(double), hppa_r1, hppa_r1);
2368 }
2369 }
2370
2371 /* We also spill the arguments onto the stack, because
2372 * the call to hppa_get_lmf_addr below can clobber them
2373 *
2374 * This goes in the param area that is always allocated
2375 */
2376 ofs = -36;
2377 for (reg = hppa_r26; reg >= hppa_r23; reg--) {
2378 hppa_stw (code, reg, ofs, hppa_sp);
2379 ofs -= 4;
2380 }
2381 }
2382
2383 if (cfg->flags & MONO_CFG_HAS_ALLOCA)
2384 hppa_copy (code, hppa_r30, hppa_r4);
2385
2386 if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
2387 hppa_set (code, cfg->domain, hppa_r26);
2388 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, (gpointer)"mono_jit_thread_attach");
2389 hppa_ldil (code, 0, hppa_r1);
2390 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2391 hppa_depi (code, 0, 31, 2, hppa_r1);
2392 hppa_ldw (code, 0, hppa_r1, hppa_r1);
2393 hppa_ble (code, 0, hppa_r1);
2394 hppa_copy (code, hppa_r31, hppa_r2);
2395 }
2396
2397 if (method->save_lmf) {
2398 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
2399 (gpointer)"mono_get_lmf_addr");
2400 hppa_ldil (code, 0, hppa_r1);
2401 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2402 hppa_depi (code, 0, 31, 2, hppa_r1);
2403 hppa_ldw (code, 0, hppa_r1, hppa_r1);
2404 hppa_ble (code, 0, hppa_r1);
2405 hppa_copy (code, hppa_r31, hppa_r2);
2406
2407 /* lmf_offset is the offset from the previous stack pointer,
2408 * The pointer to the struct is put in hppa_r22 (new_lmf).
2409 * The callee-saved registers are already in the MonoLMF
2410 * structure
2411 */
2412
2413 /* hppa_r22 = new_lmf (on the stack) */
2414 hppa_ldo (code, lmf_offset, hppa_r3, hppa_r22);
2415 /* lmf_offset is the offset from the previous stack pointer,
2416 */
2417 hppa_stw (code, hppa_r28, G_STRUCT_OFFSET(MonoLMF, lmf_addr), hppa_r22);
2418 /* new_lmf->previous_lmf = *lmf_addr */
2419 hppa_ldw (code, 0, hppa_r28, hppa_r1);
2420 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r22);
2421 /* *(lmf_addr) = r22 */
2422 hppa_stw (code, hppa_r22, 0, hppa_r28);
2423 hppa_set (code, method, hppa_r1);
2424 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, method), hppa_r22);
2425 hppa_stw (code, hppa_sp, G_STRUCT_OFFSET(MonoLMF, ebp), hppa_r22);
2426 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_IP, NULL);
2427 hppa_ldil (code, 0, hppa_r1);
2428 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2429 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, eip), hppa_r22);
2430
2431 /* Now reload the arguments from the stack */
2432 hppa_ldw (code, -36, hppa_sp, hppa_r26);
2433 hppa_ldw (code, -40, hppa_sp, hppa_r25);
2434 hppa_ldw (code, -44, hppa_sp, hppa_r24);
2435 hppa_ldw (code, -48, hppa_sp, hppa_r23);
2436 }
2437
2438 /* load arguments allocated to register from the stack */
2439 pos = 0;
2440
2441 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
2442 ArgInfo *ainfo = cinfo->args + i;
2443 inst = cfg->args [pos];
2444
2445 if (inst->opcode == OP_REGVAR) {
2446 /* Want the argument in a register */
2447 switch (ainfo->storage) {
2448 case ArgInIReg:
2449 if (ainfo->reg != inst->dreg)
2450 hppa_copy (code, ainfo->reg, inst->dreg);
2451 DEBUG (printf ("Argument %d assigned to register %s\n", pos, mono_arch_regname (inst->dreg)));
2452 break;
2453
2454 case ArgInIRegPair:
2455 if (ainfo->reg != inst->dreg) {
2456 hppa_copy (code, ainfo->reg, inst->dreg);
2457 hppa_copy (code, ainfo->reg + 1, inst->dreg + 1);
2458 }
2459 DEBUG (printf ("Argument %d assigned to register %s, %s\n", pos, mono_arch_regname (inst->dreg), mono_arch_regname (inst->dreg + 1)));
2460 break;
2461
2462 case ArgInFReg:
2463 if (ainfo->reg != inst->dreg)
2464 hppa_fcpy (code, HPPA_FP_FMT_SGL, ainfo->reg, inst->dreg);
2465 DEBUG (printf ("Argument %d assigned to single register %s\n", pos, mono_arch_fregname (inst->dreg)));
2466 break;
2467
2468 case ArgInDReg:
2469 if (ainfo->reg != inst->dreg)
2470 hppa_fcpy (code, HPPA_FP_FMT_DBL, ainfo->reg, inst->dreg);
2471 DEBUG (printf ("Argument %d assigned to double register %s\n", pos, mono_arch_fregname (inst->dreg)));
2472 break;
2473
2474 case ArgOnStack:
2475 switch (ainfo->size) {
2476 case 1:
2477 hppa_ldb (code, ainfo->offset, hppa_r3, inst->dreg);
2478 break;
2479 case 2:
2480 hppa_ldh (code, ainfo->offset, hppa_r3, inst->dreg);
2481 break;
2482 case 4:
2483 hppa_ldw (code, ainfo->offset, hppa_r3, inst->dreg);
2484 break;
2485 default:
2486 g_assert_not_reached ();
2487 }
2488
2489
2490 DEBUG (printf ("Argument %d loaded from the stack [%s - %d]\n", pos, mono_arch_regname (hppa_r3), -ainfo->offset));
2491 break;
2492
2493 default:
2494 g_assert_not_reached ();
2495 }
2496 }
2497 else {
2498 /* Want the argument on the stack */
2499 switch (ainfo->storage)
2500 {
2501 case ArgInIReg: {
2502 int off, reg;
2503 DEBUG (printf ("Argument %d stored from register %s to stack [%s + %d]\n", pos, mono_arch_regname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2504 if (hppa_check_bits (inst->inst_offset, 14)) {
2505 off = inst->inst_offset;
2506 reg = inst->inst_basereg;
2507 }
2508 else {
2509 hppa_set (code, inst->inst_offset, hppa_r1);
2510 hppa_add (code, hppa_r1, inst->inst_basereg, hppa_r1);
2511 off = 0;
2512 reg = hppa_r1;
2513 }
2514 switch (ainfo->size)
2515 {
2516 case 1:
2517 hppa_stb (code, ainfo->reg, off, reg);
2518 break;
2519 case 2:
2520 hppa_sth (code, ainfo->reg, off, reg);
2521 break;
2522 case 4:
2523 hppa_stw (code, ainfo->reg, off, reg);
2524 break;
2525 default:
2526 g_assert_not_reached ();
2527 }
2528 break;
2529 }
2530 case ArgInIRegPair:
2531 DEBUG (printf ("Argument %d stored from register (%s,%s) to stack [%s + %d]\n", pos, mono_arch_regname (ainfo->reg), mono_arch_regname (ainfo->reg+1), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2532 if (hppa_check_bits (inst->inst_offset + 4, 14)) {
2533 hppa_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
2534 hppa_stw (code, ainfo->reg + 1, inst->inst_offset + 4, inst->inst_basereg);
2535 }
2536 else {
2537 hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2538 hppa_stw (code, ainfo->reg, 0, hppa_r1);
2539 hppa_stw (code, ainfo->reg + 1, 4, hppa_r1);
2540 }
2541 break;
2542
2543 case ArgInFReg:
2544 DEBUG (printf ("Argument %d (float) stored from register %s to stack [%s + %d]\n", pos, mono_arch_fregname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2545 hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2546 hppa_fstwx (code, ainfo->reg, 0, hppa_r0, hppa_r1);
2547 break;
2548
2549 case ArgInDReg:
2550 DEBUG (printf ("Argument %d (double) stored from register %s to stack [%s + %d]\n", pos, mono_arch_fregname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2551 hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2552 hppa_fstdx (code, ainfo->reg, hppa_r0, hppa_r1);
2553 break;
2554
2555 case ArgOnStack:
2556 DEBUG (printf ("Argument %d copied from [%s - %d] to [%s + %d] (size=%d)\n", pos, mono_arch_regname (hppa_r3), -ainfo->offset, mono_arch_regname (inst->inst_basereg), inst->inst_offset, ainfo->size));
2557 if (inst->inst_offset != ainfo->offset ||
2558 inst->inst_basereg != hppa_r3)
2559 code = emit_memcpy (code, inst->inst_offset, inst->inst_basereg, ainfo->offset, hppa_r3, ainfo->size);
2560 break;
2561
2562 default:
2563 g_assert_not_reached ();
2564 }
2565 }
2566
2567 pos++;
2568 }
2569
2570
2571 if (tracing)
2572 code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
2573
2574 if (getenv("HPPA_BREAK")) {
2575 *(guint32*)code = 0x00010004;
2576 code += 4;
2577 }
2578
2579 cfg->code_len = code - cfg->native_code;
2580 g_assert (cfg->code_len < cfg->code_size);
2581 g_free (cinfo);
2582
2583 DEBUG_FUNC_EXIT();
2584 return code;
2585 }
2586
2587
2588 void
2589 mono_arch_emit_epilog (MonoCompile *cfg)
2590 {
2591 MonoMethod *method = cfg->method;
2592 MonoMethodSignature *sig;
2593 guint32 *code;
2594 int max_epilog_size = 16 + 20 * 4;
2595 int pos;
2596
2597 DEBUG_FUNC_ENTER();
2598 sig = mono_method_signature (cfg->method);
2599 if (cfg->method->save_lmf)
2600 max_epilog_size += 128;
2601
2602 if (mono_jit_trace_calls != NULL)
2603 max_epilog_size += 50;
2604
2605 if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
2606 max_epilog_size += 50;
2607
2608 while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
2609 cfg->code_size *= 2;
2610 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2611 cfg->stat_code_reallocs++;
2612 }
2613
2614 code = (guint32*)(cfg->native_code + cfg->code_len);
2615
2616 if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
2617 code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
2618
2619 pos = HPPA_STACK_LMF_OFFSET;
2620 if (cfg->method->save_lmf) {
2621 int reg;
2622 hppa_ldo (code, pos, hppa_r3, hppa_r22);
2623 hppa_ldw (code, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r22, hppa_r21);
2624 hppa_ldw (code, G_STRUCT_OFFSET(MonoLMF, lmf_addr), hppa_r22, hppa_r20);
2625 hppa_stw (code, hppa_r21, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r20);
2626
2627 pos += G_STRUCT_OFFSET(MonoLMF, regs) + sizeof (gulong);
2628 /* We skip the restore of r3 here, it is restored from the
2629 * stack anyway. This makes the code a bit easier.
2630 */
2631 for (reg = 4; reg < 31; reg++) {
2632 if (HPPA_IS_SAVED_GREG (reg)) {
2633 hppa_ldw (code, pos, hppa_r3, reg);
2634 pos += sizeof(gulong);
2635 }
2636 }
2637
2638 pos = ALIGN_TO (pos, sizeof (double));
2639 hppa_set (code, pos, hppa_r1);
2640 for (reg = 0; reg < 31; reg++) {
2641 if (HPPA_IS_SAVED_FREG (reg)) {
2642 hppa_flddx (code, hppa_r1, hppa_r3, reg);
2643 hppa_ldo (code, sizeof (double), hppa_r1, hppa_r1);
2644 pos += sizeof (double);
2645 }
2646 }
2647 } else {
2648 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2649 int i;
2650 for (i = 0; i < 32; i++) {
2651 if (i == hppa_r3)
2652 continue;
2653 if ((1 << i) & mask) {
2654 hppa_ldw (code, pos, hppa_r3, i);
2655 pos += sizeof (gulong);
2656 }
2657 }
2658 }
2659
2660 if (sig->ret->type != MONO_TYPE_VOID &&
2661 mono_type_to_stind (sig->ret) == CEE_STOBJ) {
2662 CallInfo *cinfo = get_call_info (sig, sig->pinvoke);
2663
2664 switch (cinfo->ret.storage) {
2665 case ArgInIReg:
2666 hppa_ldw (code, cfg->ret->inst_offset, hppa_sp, hppa_r28);
2667 hppa_ldw (code, 0, hppa_r28, hppa_r28);
2668 break;
2669 case ArgInIRegPair:
2670 hppa_ldw (code, cfg->ret->inst_offset, hppa_sp, hppa_r28);
2671 hppa_ldw (code, 4, hppa_r28, hppa_r29);
2672 hppa_ldw (code, 0, hppa_r28, hppa_r28);
2673 break;
2674 case ArgOnStack:
2675 /* Nothing to do */
2676 break;
2677 default:
2678 g_assert_not_reached ();
2679 }
2680 g_free (cinfo);
2681 }
2682
2683 if (1 || cfg->flags & MONO_CFG_HAS_CALLS)
2684 hppa_ldw (code, -20, hppa_r3, hppa_r2);
2685 hppa_ldo (code, 64, hppa_r3, hppa_sp);
2686 hppa_bv (code, hppa_r0, hppa_r2);
2687 hppa_ldwm (code, -64, hppa_sp, hppa_r3);
2688
2689 cfg->code_len = (guint8*)code - cfg->native_code;
2690
2691 g_assert (cfg->code_len < cfg->code_size);
2692 DEBUG_FUNC_EXIT();
2693 }
2694
2695 /* remove once throw_exception_by_name is eliminated */
2696 static int
2697 exception_id_by_name (const char *name)
2698 {
2699 if (strcmp (name, "IndexOutOfRangeException") == 0)
2700 return MONO_EXC_INDEX_OUT_OF_RANGE;
2701 if (strcmp (name, "OverflowException") == 0)
2702 return MONO_EXC_OVERFLOW;
2703 if (strcmp (name, "ArithmeticException") == 0)
2704 return MONO_EXC_ARITHMETIC;
2705 if (strcmp (name, "DivideByZeroException") == 0)
2706 return MONO_EXC_DIVIDE_BY_ZERO;
2707 if (strcmp (name, "InvalidCastException") == 0)
2708 return MONO_EXC_INVALID_CAST;
2709 if (strcmp (name, "NullReferenceException") == 0)
2710 return MONO_EXC_NULL_REF;
2711 if (strcmp (name, "ArrayTypeMismatchException") == 0)
2712 return MONO_EXC_ARRAY_TYPE_MISMATCH;
2713 g_error ("Unknown intrinsic exception %s\n", name);
2714 return 0;
2715 }
2716
2717 void
2718 mono_arch_emit_exceptions (MonoCompile *cfg)
2719 {
2720 MonoJumpInfo *patch_info;
2721 int i;
2722 guint8 *code;
2723 const guint8* exc_throw_pos [MONO_EXC_INTRINS_NUM] = {NULL};
2724 guint8 exc_throw_found [MONO_EXC_INTRINS_NUM] = {0};
2725 int max_epilog_size = 50;
2726
2727 DEBUG_FUNC_ENTER();
2728
2729 /* count the number of exception infos */
2730
2731 /*
2732 * make sure we have enough space for exceptions
2733 */
2734 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
2735 switch (patch_info->type) {
2736 case MONO_PATCH_INFO_BB_OVF:
2737 g_assert_not_reached ();
2738 break;
2739
2740 case MONO_PATCH_INFO_EXC_OVF: {
2741 const MonoOvfJump *ovfj = patch_info->data.target;
2742 max_epilog_size += 8;
2743 i = exception_id_by_name (ovfj->data.exception);
2744 if (!exc_throw_found [i]) {
2745 max_epilog_size += 24;
2746 exc_throw_found [i] = TRUE;
2747 }
2748 break;
2749 }
2750
2751 case MONO_PATCH_INFO_EXC:
2752 i = exception_id_by_name (patch_info->data.target);
2753 if (!exc_throw_found [i]) {
2754 max_epilog_size += 24;
2755 exc_throw_found [i] = TRUE;
2756 }
2757 break;
2758
2759 default:
2760 break;
2761 }
2762 }
2763
2764 while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
2765 cfg->code_size *= 2;
2766 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2767 cfg->stat_code_reallocs++;
2768 }
2769
2770 code = cfg->native_code + cfg->code_len;
2771
2772 /* add code to raise exceptions */
2773 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
2774 switch (patch_info->type) {
2775 case MONO_PATCH_INFO_BB_OVF: {
2776 /* TODO */
2777 break;
2778 }
2779 case MONO_PATCH_INFO_EXC_OVF: {
2780 const MonoOvfJump *ovfj = patch_info->data.target;
2781 MonoJumpInfo *newji;
2782 unsigned char *ip = patch_info->ip.i + cfg->native_code;
2783 unsigned char *stub = code;
2784
2785 /* Patch original call, point it at the stub */
2786 hppa_patch ((guint32 *)ip, code);
2787
2788 /* Write the stub */
2789 /* SUBTLE: this has to be PIC, because the code block
2790 * can be relocated
2791 */
2792 hppa_bl_n (code, 8, hppa_r0);
2793 hppa_nop (code);
2794
2795 /* Add a patch info to patch the stub to point to the exception code */
2796 newji = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfo));
2797 newji->type = MONO_PATCH_INFO_EXC;
2798 newji->ip.i = stub - cfg->native_code;
2799 newji->data.target = ovfj->data.exception;
2800 newji->next = patch_info->next;
2801 patch_info->next = newji;
2802 break;
2803 }
2804 case MONO_PATCH_INFO_EXC: {
2805 unsigned char *ip = patch_info->ip.i + cfg->native_code;
2806 i = exception_id_by_name (patch_info->data.target);
2807 if (exc_throw_pos [i]) {
2808 hppa_patch ((guint32 *)ip, exc_throw_pos [i]);
2809 patch_info->type = MONO_PATCH_INFO_NONE;
2810 break;
2811 } else {
2812 exc_throw_pos [i] = code;
2813 }
2814 hppa_patch ((guint32 *)ip, code);
2815 hppa_set (code, patch_info->data.target, hppa_r26);
2816 patch_info->type = MONO_PATCH_INFO_INTERNAL_METHOD;
2817 patch_info->data.name = "mono_arch_throw_exception_by_name";
2818 patch_info->ip.i = code - cfg->native_code;
2819
2820 /* Assume the caller has set r2, we can't set it
2821 * here based on ip, because the caller may
2822 * be relocated (also the "ip" may be from an overflow
2823 * stub)
2824 */
2825 hppa_ldil (code, 0, hppa_r1);
2826 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2827 hppa_bv (code, hppa_r0, hppa_r1);
2828 hppa_nop (code);
2829 break;
2830 }
2831 default:
2832 /* do nothing */
2833 break;
2834 }
2835 }
2836
2837 cfg->code_len = code - cfg->native_code;
2838
2839 g_assert (cfg->code_len < cfg->code_size);
2840 DEBUG_FUNC_EXIT();
2841 }
2842
2843 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2844
2845 #error "--with-sigaltstack=yes not supported on hppa"
2846
2847 #endif
2848
2849 void
2850 mono_arch_finish_init (void)
2851 {
2852 }
2853
2854 void
2855 mono_arch_free_jit_tls_data (MonoJitTlsData *tls)
2856 {
2857 }
2858
2859 void
2860 mono_arch_emit_this_vret_args (MonoCompile *cfg, MonoCallInst *inst, int this_reg, int this_type, int vt_reg)
2861 {
2862 /* add the this argument */
2863 if (this_reg != -1) {
2864 MonoInst *this;
2865 MONO_INST_NEW (cfg, this, OP_MOVE);
2866 this->type = this_type;
2867 this->sreg1 = this_reg;
2868 this->dreg = mono_alloc_ireg (cfg);
2869 mono_bblock_add_inst (cfg->cbb, this);
2870 mono_call_inst_add_outarg_reg (cfg, inst, this->dreg, hppa_r26, FALSE);
2871 }
2872
2873 if (vt_reg != -1) {
2874 MonoInst *vtarg;
2875 MONO_INST_NEW (cfg, vtarg, OP_MOVE);
2876 vtarg->type = STACK_MP;
2877 vtarg->sreg1 = vt_reg;
2878 vtarg->dreg = mono_alloc_ireg (cfg);
2879 mono_bblock_add_inst (cfg->cbb, vtarg);
2880 mono_call_inst_add_outarg_reg (cfg, inst, vtarg->dreg, hppa_r28, FALSE);
2881 }
2882 }
2883
2884
2885 MonoInst*
2886 mono_arch_get_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
2887 {
2888 MonoInst *ins = NULL;
2889 DEBUG_FUNC_ENTER();
2890 DEBUG_FUNC_EXIT();
2891
2892 return ins;
2893 }
2894
2895 /*
2896 * mono_arch_get_argument_info:
2897 * @csig: a method signature
2898 * @param_count: the number of parameters to consider
2899 * @arg_info: an array to store the result infos
2900 *
2901 * Gathers information on parameters such as size, alignment and
2902 * padding. arg_info should be large enought to hold param_count + 1 entries.
2903 *
2904 * Returns the size of the activation frame.
2905 */
2906 int
2907 mono_arch_get_argument_info (MonoGenericSharingContext *gsctx, MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
2908 {
2909 int k, align;
2910 CallInfo *cinfo;
2911 ArgInfo *ainfo;
2912
2913 DEBUG_FUNC_ENTER();
2914 cinfo = get_call_info (csig, FALSE);
2915
2916 if (csig->hasthis) {
2917 ainfo = &cinfo->args [0];
2918 arg_info [0].offset = ainfo->offset;
2919 }
2920
2921 for (k = 0; k < param_count; k++) {
2922 ainfo = &cinfo->args [k + csig->hasthis];
2923
2924 arg_info [k + 1].offset = ainfo->offset;
2925 arg_info [k + 1].size = mono_type_size (csig->params [k], &align);
2926 }
2927
2928 g_free (cinfo);
2929 DEBUG_FUNC_EXIT();
2930 }
2931
2932 gboolean
2933 mono_arch_print_tree (MonoInst *tree, int arity)
2934 {
2935 return 0;
2936 }
2937
2938 MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg)
2939 {
2940 return NULL;
2941 }
2942
2943 gpointer
2944 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
2945 {
2946 /* FIXME: implement */
2947 g_assert_not_reached ();
2948 }
Mirror of the official Mono project git repository