| blob | 881a32f7f7f6fc6252653f4ca09977fa2c788ec6 |
1 /*
2 * mini.c: The new Mono code generator.
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002 Ximian, Inc.
9 */
11 #include <config.h>
12 #include <signal.h>
13 #include <unistd.h>
14 #include <math.h>
15 #include <sys/time.h>
17 #ifdef PLATFORM_MACOSX
18 #include <mach/mach.h>
19 #include <mach/mach_error.h>
20 #include <mach/exception.h>
21 #include <mach/task.h>
22 #include <pthread.h>
23 #endif
25 #ifdef HAVE_VALGRIND_MEMCHECK_H
26 #include <valgrind/memcheck.h>
27 #endif
29 #include <mono/metadata/assembly.h>
30 #include <mono/metadata/loader.h>
31 #include <mono/metadata/cil-coff.h>
32 #include <mono/metadata/tabledefs.h>
33 #include <mono/metadata/class.h>
34 #include <mono/metadata/object.h>
35 #include <mono/metadata/exception.h>
36 #include <mono/metadata/opcodes.h>
37 #include <mono/metadata/mono-endian.h>
38 #include <mono/metadata/tokentype.h>
39 #include <mono/metadata/tabledefs.h>
40 #include <mono/metadata/threads.h>
41 #include <mono/metadata/marshal.h>
42 #include <mono/metadata/socket-io.h>
43 #include <mono/metadata/appdomain.h>
44 #include <mono/metadata/debug-helpers.h>
45 #include <mono/io-layer/io-layer.h>
47 #include <mono/metadata/profiler-private.h>
48 #include <mono/metadata/mono-config.h>
49 #include <mono/metadata/environment.h>
50 #include <mono/metadata/mono-debug.h>
51 #include <mono/metadata/monitor.h>
52 #include <mono/metadata/security-manager.h>
53 #include <mono/metadata/threads-types.h>
54 #include <mono/metadata/rawbuffer.h>
55 #include <mono/utils/mono-math.h>
56 #include <mono/utils/mono-compiler.h>
57 #include <mono/utils/mono-counters.h>
58 #include <mono/utils/mono-logger.h>
59 #include <mono/os/gc_wrapper.h>
62 #include <string.h>
63 #include <ctype.h>
71 #define BRANCH_COST 100
72 #define INLINE_LENGTH_LIMIT 20
73 #define INLINE_FAILURE do {\
74 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
75 goto inline_failure;\
76 } while (0)
78 /*
79 * this is used to determine when some branch optimizations are possible: we exclude FP compares
80 * because they have weird semantics with NaNs.
81 */
82 #define MONO_IS_COND_BRANCH_OP(ins) (((ins)->opcode >= CEE_BEQ && (ins)->opcode <= CEE_BLT_UN) || ((ins)->opcode >= OP_LBEQ && (ins)->opcode <= OP_LBLT_UN) || ((ins)->opcode >= OP_FBEQ && (ins)->opcode <= OP_FBLT_UN) || ((ins)->opcode >= OP_IBEQ && (ins)->opcode <= OP_IBLT_UN))
83 #define MONO_IS_COND_BRANCH_NOFP(ins) (MONO_IS_COND_BRANCH_OP(ins) && (ins)->inst_left->inst_left->type != STACK_R8)
85 #define MONO_IS_BRANCH_OP(ins) (MONO_IS_COND_BRANCH_OP(ins) || ((ins)->opcode == CEE_BR) || ((ins)->opcode == OP_BR_REG) || ((ins)->opcode == CEE_SWITCH))
87 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && (ins)->ssa_op == MONO_SSA_LOAD && (ins)->inst_left->inst_c0 == 0)
96 static void handle_stobj (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *dest, MonoInst *src,
97 const unsigned char *ip, MonoClass *klass, gboolean to_end, gboolean native, gboolean write_barrier);
101 static int mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
105 /* helper methods signature */
115 #ifndef DISABLE_AOT
117 #endif
122 #define mono_jit_lock() EnterCriticalSection (&jit_mutex)
123 #define mono_jit_unlock() LeaveCriticalSection (&jit_mutex)
134 /*
135 * Address of the trampoline code. This is used by the debugger to check
136 * whether a method is a trampoline.
137 */
140 gboolean
142 {
143 #ifdef HAVE_VALGRIND_MEMCHECK_H
146 else
148 #else
150 #endif
151 }
153 /*
154 * mono_create_ftnptr:
155 *
156 * Given a function address, create a function descriptor for it.
157 * This is only needed on IA64.
158 */
159 gpointer
161 {
162 #ifdef __ia64__
173 #else
175 #endif
176 }
183 static void
185 {
190 }
192 /* debug function */
195 {
201 FindTrampUserData user_data;
215 }
216 else
218 }
220 /* FIXME: unused ? */
221 location = mono_debug_lookup_source_location (ji->method, (guint32)((guint8*)ip - (guint8*)ji->code_start), domain);
223 res = g_strdup_printf (" %s + 0x%x (%p %p) [%p - %s]", method, (int)((char*)ip - (char*)ji->code_start), ji->code_start, (char*)ji->code_start + ji->code_size, domain, domain->friendly_name);
229 }
233 {
235 }
237 /* debug function */
238 void
240 {
245 FindTrampUserData user_data;
258 }
259 else
262 }
264 source = mono_debug_lookup_source_location (ji->method, (guint32)((guint8*)ip - (guint8*)ji->code_start), domain);
266 g_print ("IP %p at offset 0x%x of method %s (%p %p)[domain %p - %s]\n", ip, (int)((char*)ip - (char*)ji->code_start), method, ji->code_start, (char*)ji->code_start + ji->code_size, domain, domain->friendly_name);
273 }
275 /*
276 * mono_method_same_domain:
277 *
278 * Determine whenever two compiled methods are in the same domain, thus
279 * the address of the callee can be embedded in the caller.
280 */
282 {
286 /*
287 * If the call was made from domain-neutral to domain-specific
288 * code, we can't patch the call site.
289 */
295 /* The InvokeInDomain methods change the current appdomain */
297 }
300 }
302 /*
303 * mono_global_codeman_reserve:
304 *
305 * Allocate code memory from the global code manager.
306 */
308 {
312 /* This can happen during startup */
315 }
321 }
322 }
324 MonoJumpInfoToken *
326 {
332 }
334 #define MONO_INIT_VARINFO(vi,id) do { \
335 (vi)->range.first_use.pos.bid = 0xffff; \
336 (vi)->reg = -1; \
337 (vi)->idx = (id); \
338 } while (0)
340 //#define UNVERIFIED do { G_BREAKPOINT (); goto unverified; } while (0)
341 #define UNVERIFIED do { if (debug_options.break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
343 /*
344 * Basic blocks have two numeric identifiers:
345 * dfn: Depth First Number
346 * block_num: unique ID assigned at bblock creation
347 */
348 #define NEW_BBLOCK(cfg) (mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)))
349 #define ADD_BBLOCK(cfg,bbhash,b) do { \
350 g_hash_table_insert (bbhash, (b)->cil_code, (b)); \
351 (b)->block_num = cfg->num_bblocks++; \
352 (b)->real_offset = real_offset; \
353 } while (0)
355 #define GET_BBLOCK(cfg,bbhash,tblock,ip) do { \
356 (tblock) = g_hash_table_lookup (bbhash, (ip)); \
357 if (!(tblock)) { \
358 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
359 (tblock) = NEW_BBLOCK (cfg); \
360 (tblock)->cil_code = (ip); \
361 ADD_BBLOCK (cfg, (bbhash), (tblock)); \
362 } \
363 } while (0)
365 #define CHECK_BBLOCK(target,ip,tblock) do { \
366 if ((target) < (ip) && !(tblock)->code) { \
367 bb_recheck = g_list_prepend (bb_recheck, (tblock)); \
368 if (cfg->verbose_level > 2) g_print ("queued block %d for check at IL%04x from IL%04x\n", (tblock)->block_num, (int)((target) - header->code), (int)((ip) - header->code)); \
369 } \
370 } while (0)
372 #define NEW_ICONST(cfg,dest,val) do { \
373 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
374 (dest)->opcode = OP_ICONST; \
375 (dest)->inst_c0 = (val); \
376 (dest)->type = STACK_I4; \
377 } while (0)
379 #define NEW_PCONST(cfg,dest,val) do { \
380 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
381 (dest)->opcode = OP_PCONST; \
382 (dest)->inst_p0 = (val); \
383 (dest)->type = STACK_PTR; \
384 } while (0)
387 #ifdef MONO_ARCH_NEED_GOT_VAR
389 #define NEW_PATCH_INFO(cfg,dest,el1,el2) do { \
390 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
391 (dest)->opcode = OP_PATCH_INFO; \
392 (dest)->inst_left = (gpointer)(el1); \
393 (dest)->inst_right = (gpointer)(el2); \
394 } while (0)
396 #define NEW_AOTCONST(cfg,dest,patch_type,cons) do { \
397 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
398 (dest)->opcode = cfg->compile_aot ? OP_GOT_ENTRY : OP_PCONST; \
399 if (cfg->compile_aot) { \
400 MonoInst *group, *got_var, *got_loc; \
401 got_loc = mono_get_got_var (cfg); \
402 NEW_TEMPLOAD ((cfg), got_var, got_loc->inst_c0); \
403 NEW_PATCH_INFO ((cfg), group, cons, patch_type); \
404 (dest)->inst_p0 = got_var; \
405 (dest)->inst_p1 = group; \
406 } else { \
407 (dest)->inst_p0 = (cons); \
408 (dest)->inst_i1 = (gpointer)(patch_type); \
409 } \
410 (dest)->type = STACK_PTR; \
411 } while (0)
413 #define NEW_AOTCONST_TOKEN(cfg,dest,patch_type,image,token,stack_type,stack_class) do { \
414 MonoInst *group, *got_var, *got_loc; \
415 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
416 (dest)->opcode = OP_GOT_ENTRY; \
417 got_loc = mono_get_got_var (cfg); \
418 NEW_TEMPLOAD ((cfg), got_var, got_loc->inst_c0); \
419 NEW_PATCH_INFO ((cfg), group, NULL, patch_type); \
420 group->inst_p0 = mono_jump_info_token_new ((cfg)->mempool, (image), (token)); \
421 (dest)->inst_p0 = got_var; \
422 (dest)->inst_p1 = group; \
423 (dest)->type = (stack_type); \
424 (dest)->klass = (stack_class); \
425 } while (0)
427 #else
429 #define NEW_AOTCONST(cfg,dest,patch_type,cons) do { \
430 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
431 (dest)->opcode = cfg->compile_aot ? OP_AOTCONST : OP_PCONST; \
432 (dest)->inst_p0 = (cons); \
433 (dest)->inst_i1 = (gpointer)(patch_type); \
434 (dest)->type = STACK_PTR; \
435 } while (0)
437 #define NEW_AOTCONST_TOKEN(cfg,dest,patch_type,image,token,stack_type,stack_class) do { \
438 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
439 (dest)->opcode = OP_AOTCONST; \
440 (dest)->inst_p0 = mono_jump_info_token_new ((cfg)->mempool, (image), (token)); \
441 (dest)->inst_p1 = (gpointer)(patch_type); \
442 (dest)->type = (stack_type); \
443 (dest)->klass = (stack_class); \
444 } while (0)
446 #endif
448 #define NEW_CLASSCONST(cfg,dest,val) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_CLASS, (val))
450 #define NEW_IMAGECONST(cfg,dest,val) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_IMAGE, (val))
452 #define NEW_FIELDCONST(cfg,dest,val) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_FIELD, (val))
454 #define NEW_METHODCONST(cfg,dest,val) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_METHODCONST, (val))
456 #define NEW_VTABLECONST(cfg,dest,vtable) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_VTABLE, cfg->compile_aot ? (gpointer)((vtable)->klass) : (vtable))
458 #define NEW_SFLDACONST(cfg,dest,val) NEW_AOTCONST ((cfg), (dest), MONO_PATCH_INFO_SFLDA, (val))
460 #define NEW_LDSTRCONST(cfg,dest,image,token) NEW_AOTCONST_TOKEN ((cfg), (dest), MONO_PATCH_INFO_LDSTR, (image), (token), STACK_OBJ, mono_defaults.string_class)
462 #define NEW_TYPE_FROM_HANDLE_CONST(cfg,dest,image,token) NEW_AOTCONST_TOKEN ((cfg), (dest), MONO_PATCH_INFO_TYPE_FROM_HANDLE, (image), (token), STACK_OBJ, mono_defaults.monotype_class)
464 #define NEW_LDTOKENCONST(cfg,dest,image,token) NEW_AOTCONST_TOKEN ((cfg), (dest), MONO_PATCH_INFO_LDTOKEN, (image), (token), STACK_PTR, NULL)
466 #define NEW_DECLSECCONST(cfg,dest,image,entry) do { \
467 if (cfg->compile_aot) { \
468 NEW_AOTCONST_TOKEN (cfg, dest, MONO_PATCH_INFO_DECLSEC, image, (entry).index, STACK_OBJ, NULL); \
469 } else { \
470 NEW_PCONST (cfg, args [0], (entry).blob); \
471 } \
472 } while (0)
474 #define NEW_DOMAINCONST(cfg,dest) do { \
475 if (cfg->opt & MONO_OPT_SHARED) { \
477 MonoInst* __domain_var = mono_get_domainvar (cfg); \
478 NEW_TEMPLOAD (cfg, dest, __domain_var->inst_c0); \
479 } else { \
480 NEW_PCONST (cfg, dest, (cfg)->domain); \
481 } \
482 } while (0)
484 #define GET_VARINFO_INST(cfg,num) ((cfg)->varinfo [(num)]->inst)
486 #define NEW_ARGLOAD(cfg,dest,num) do { \
487 if (arg_array [(num)]->opcode == OP_ICONST) (dest) = arg_array [(num)]; else { \
488 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
489 (dest)->ssa_op = MONO_SSA_LOAD; \
490 (dest)->inst_i0 = arg_array [(num)]; \
491 (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
492 type_to_eval_stack_type (param_types [(num)], (dest)); \
493 (dest)->klass = (dest)->inst_i0->klass; \
494 }} while (0)
496 #define NEW_LOCLOAD(cfg,dest,num) do { \
497 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
498 (dest)->ssa_op = MONO_SSA_LOAD; \
499 (dest)->inst_i0 = (cfg)->varinfo [locals_offset + (num)]; \
500 (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
501 type_to_eval_stack_type (header->locals [(num)], (dest)); \
502 (dest)->klass = (dest)->inst_i0->klass; \
503 } while (0)
505 #define NEW_LOCLOADA(cfg,dest,num) do { \
506 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
507 (dest)->ssa_op = MONO_SSA_ADDRESS_TAKEN; \
508 (dest)->inst_i0 = (cfg)->varinfo [locals_offset + (num)]; \
509 (dest)->inst_i0->flags |= MONO_INST_INDIRECT; \
510 (dest)->opcode = OP_LDADDR; \
511 (dest)->type = STACK_MP; \
512 (dest)->klass = (dest)->inst_i0->klass; \
513 if (!MONO_TYPE_ISSTRUCT (header->locals [(num)])) \
514 (cfg)->disable_ssa = TRUE; \
515 } while (0)
517 #define NEW_RETLOADA(cfg,dest) do { \
518 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
519 (dest)->ssa_op = MONO_SSA_ADDRESS_TAKEN; \
520 (dest)->inst_i0 = (cfg)->ret; \
521 (dest)->inst_i0->flags |= MONO_INST_INDIRECT; \
522 (dest)->opcode = cfg->ret_var_is_local ? OP_LDADDR : CEE_LDIND_I; \
523 (dest)->type = STACK_MP; \
524 (dest)->klass = (dest)->inst_i0->klass; \
525 (cfg)->disable_ssa = TRUE; \
526 } while (0)
528 #define NEW_ARGLOADA(cfg,dest,num) do { \
529 if (arg_array [(num)]->opcode == OP_ICONST) goto inline_failure; \
530 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
531 (dest)->ssa_op = MONO_SSA_ADDRESS_TAKEN; \
532 (dest)->inst_i0 = arg_array [(num)]; \
533 (dest)->inst_i0->flags |= MONO_INST_INDIRECT; \
534 (dest)->opcode = OP_LDADDR; \
535 (dest)->type = STACK_MP; \
536 (dest)->klass = (dest)->inst_i0->klass; \
537 (cfg)->disable_ssa = TRUE; \
538 } while (0)
540 #define NEW_TEMPLOAD(cfg,dest,num) do { \
541 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
542 (dest)->ssa_op = MONO_SSA_LOAD; \
543 (dest)->inst_i0 = (cfg)->varinfo [(num)]; \
544 (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
545 type_to_eval_stack_type ((dest)->inst_i0->inst_vtype, (dest)); \
546 (dest)->klass = (dest)->inst_i0->klass; \
547 } while (0)
549 #define NEW_TEMPLOADA(cfg,dest,num) do { \
550 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
551 (dest)->ssa_op = MONO_SSA_ADDRESS_TAKEN; \
552 (dest)->inst_i0 = (cfg)->varinfo [(num)]; \
553 (dest)->inst_i0->flags |= MONO_INST_INDIRECT; \
554 (dest)->opcode = OP_LDADDR; \
555 (dest)->type = STACK_MP; \
556 (dest)->klass = (dest)->inst_i0->klass; \
557 if (!MONO_TYPE_ISSTRUCT (cfg->varinfo [(num)]->inst_vtype)) \
558 (cfg)->disable_ssa = TRUE; \
559 } while (0)
562 #define NEW_INDLOAD(cfg,dest,addr,vtype) do { \
563 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
564 (dest)->inst_left = addr; \
565 (dest)->opcode = mono_type_to_ldind (vtype); \
566 type_to_eval_stack_type (vtype, (dest)); \
568 } while (0)
570 #define NEW_INDSTORE(cfg,dest,addr,value,vtype) do { \
571 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
572 (dest)->inst_i0 = addr; \
573 (dest)->opcode = mono_type_to_stind (vtype); \
574 (dest)->inst_i1 = (value); \
576 } while (0)
578 #define NEW_TEMPSTORE(cfg,dest,num,inst) do { \
579 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
580 (dest)->ssa_op = MONO_SSA_STORE; \
581 (dest)->inst_i0 = (cfg)->varinfo [(num)]; \
582 (dest)->opcode = mono_type_to_stind ((dest)->inst_i0->inst_vtype); \
583 (dest)->inst_i1 = (inst); \
584 (dest)->klass = (dest)->inst_i0->klass; \
585 } while (0)
587 #define NEW_LOCSTORE(cfg,dest,num,inst) do { \
588 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
589 (dest)->opcode = mono_type_to_stind (header->locals [(num)]); \
590 (dest)->ssa_op = MONO_SSA_STORE; \
591 (dest)->inst_i0 = (cfg)->varinfo [locals_offset + (num)]; \
592 (dest)->inst_i1 = (inst); \
593 (dest)->klass = (dest)->inst_i0->klass; \
594 } while (0)
596 #define NEW_ARGSTORE(cfg,dest,num,inst) do { \
597 if (arg_array [(num)]->opcode == OP_ICONST) goto inline_failure; \
598 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
599 (dest)->opcode = mono_type_to_stind (param_types [(num)]); \
600 (dest)->ssa_op = MONO_SSA_STORE; \
601 (dest)->inst_i0 = arg_array [(num)]; \
602 (dest)->inst_i1 = (inst); \
603 (dest)->klass = (dest)->inst_i0->klass; \
604 } while (0)
606 #define NEW_DUMMY_USE(cfg,dest,load) do { \
607 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
608 (dest)->opcode = OP_DUMMY_USE; \
609 (dest)->inst_left = (load); \
610 } while (0)
612 #define NEW_DUMMY_STORE(cfg,dest,num) do { \
613 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
614 (dest)->inst_i0 = (cfg)->varinfo [(num)]; \
615 (dest)->opcode = OP_DUMMY_STORE; \
616 (dest)->klass = (dest)->inst_i0->klass; \
617 } while (0)
619 #define ADD_BINOP(op) do { \
620 MONO_INST_NEW (cfg, ins, (op)); \
621 ins->cil_code = ip; \
622 sp -= 2; \
623 ins->inst_i0 = sp [0]; \
624 ins->inst_i1 = sp [1]; \
625 *sp++ = ins; \
626 type_from_op (ins); \
627 CHECK_TYPE (ins); \
628 } while (0)
630 #define ADD_UNOP(op) do { \
631 MONO_INST_NEW (cfg, ins, (op)); \
632 ins->cil_code = ip; \
633 sp--; \
634 ins->inst_i0 = sp [0]; \
635 *sp++ = ins; \
636 type_from_op (ins); \
637 CHECK_TYPE (ins); \
638 } while (0)
640 #define ADD_BINCOND(next_block) do { \
641 MonoInst *cmp; \
642 sp -= 2; \
643 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
644 cmp->inst_i0 = sp [0]; \
645 cmp->inst_i1 = sp [1]; \
646 cmp->cil_code = ins->cil_code; \
647 type_from_op (cmp); \
648 CHECK_TYPE (cmp); \
649 ins->inst_i0 = cmp; \
650 MONO_ADD_INS (bblock, ins); \
651 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
652 GET_BBLOCK (cfg, bbhash, tblock, target); \
653 link_bblock (cfg, bblock, tblock); \
654 ins->inst_true_bb = tblock; \
655 CHECK_BBLOCK (target, ip, tblock); \
656 if ((next_block)) { \
657 link_bblock (cfg, bblock, (next_block)); \
658 ins->inst_false_bb = (next_block); \
659 start_new_bblock = 1; \
660 } else { \
661 GET_BBLOCK (cfg, bbhash, tblock, ip); \
662 link_bblock (cfg, bblock, tblock); \
663 ins->inst_false_bb = tblock; \
664 start_new_bblock = 2; \
665 } \
666 } while (0)
668 /* FIXME: handle float, long ... */
669 #define ADD_UNCOND(istrue) do { \
670 MonoInst *cmp; \
671 sp--; \
672 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
673 cmp->inst_i0 = sp [0]; \
674 switch (cmp->inst_i0->type) { \
675 case STACK_I8: \
676 cmp->inst_i1 = zero_int64; break; \
677 case STACK_R8: \
678 cmp->inst_i1 = zero_r8; break; \
679 case STACK_PTR: \
680 case STACK_MP: \
681 cmp->inst_i1 = zero_ptr; break; \
682 case STACK_OBJ: \
683 cmp->inst_i1 = zero_obj; break; \
684 default: \
685 cmp->inst_i1 = zero_int32; \
686 } \
687 cmp->cil_code = ins->cil_code; \
688 type_from_op (cmp); \
689 CHECK_TYPE (cmp); \
690 ins->inst_i0 = cmp; \
691 ins->opcode = (istrue)? CEE_BNE_UN: CEE_BEQ; \
692 MONO_ADD_INS (bblock, ins); \
693 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
694 GET_BBLOCK (cfg, bbhash, tblock, target); \
695 link_bblock (cfg, bblock, tblock); \
696 ins->inst_true_bb = tblock; \
697 CHECK_BBLOCK (target, ip, tblock); \
698 GET_BBLOCK (cfg, bbhash, tblock, ip); \
699 link_bblock (cfg, bblock, tblock); \
700 ins->inst_false_bb = tblock; \
701 start_new_bblock = 2; \
702 } while (0)
704 #define NEW_LDELEMA(cfg,dest,sp,k) do { \
705 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
706 (dest)->opcode = CEE_LDELEMA; \
707 (dest)->inst_left = (sp) [0]; \
708 (dest)->inst_right = (sp) [1]; \
709 (dest)->type = STACK_MP; \
710 (dest)->klass = (k); \
711 (cfg)->flags |= MONO_CFG_HAS_LDELEMA; \
712 } while (0)
714 #define NEW_GROUP(cfg,dest,el1,el2) do { \
715 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
716 (dest)->opcode = OP_GROUP; \
717 (dest)->inst_left = (el1); \
718 (dest)->inst_right = (el2); \
719 } while (0)
721 #if 0
722 static gint
724 {
729 }
730 #endif
732 /* *
733 * link_bblock: Links two basic blocks
734 *
735 * links two basic blocks in the control flow graph, the 'from'
736 * argument is the starting block and the 'to' argument is the block
737 * the control flow ends to after 'from'.
738 */
739 static void
741 {
745 #if 0
748 g_print ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
749 else
754 else
756 }
757 #endif
763 }
764 }
769 }
773 }
780 }
781 }
786 }
790 }
791 }
793 /**
794 * mono_unlink_bblock:
795 *
796 * Unlink two basic blocks.
797 */
798 static void
800 {
802 gboolean found;
809 }
810 }
816 }
819 }
826 }
827 }
833 }
836 }
837 }
839 /**
840 * mono_find_block_region:
841 *
842 * We mark each basic block with a region ID. We use that to avoid BB
843 * optimizations when blocks are in different regions.
844 *
845 * Returns:
846 * A region token that encodes where this region is, and information
847 * about the clause owner for this block.
848 *
849 * The region encodes the try/catch/filter clause that owns this block
850 * as well as the type. -1 is a special value that represents a block
851 * that is in none of try/catch/filter.
852 */
853 static int
855 {
861 /* first search for handlers and filters */
864 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
871 else
873 }
874 }
876 /* search the try blocks */
881 }
884 }
888 {
904 }
905 }
906 }
908 }
910 MonoInst *
912 {
914 }
916 static void
918 {
926 /* prevent it from being register allocated */
930 }
934 {
936 }
940 {
948 /* prevent it from being register allocated */
954 }
956 static void
958 {
962 /*g_print ("visit %d at %p (BB%ld)\n", *dfn, start->cil_code, start->block_num);*/
971 }
972 }
979 static void
981 {
984 //printf ("FIDPREV %d %p %p %p %p %p %d %d %d\n", bb->block_num, p->code, bb, p->best, bb->cil_code, p->best->cil_code,
985 //bb->method == p->best->method, bb->cil_code < p->code, bb->cil_code > p->best->cil_code);
989 }
993 PrevStruct p;
1000 }
1002 static void
1011 /*
1012 * FIXME: take into account all the details:
1013 * second may have been the target of more than one bblock
1014 */
1023 }
1024 }
1032 /*g_print ("start search at %p for %p\n", first->cil_code, second->cil_code);*/
1034 /*char *code = mono_disasm_code_one (NULL, cfg->method, inst->next->cil_code, NULL);
1035 g_print ("found %p: %s", inst->next->cil_code, code);
1036 g_free (code);*/
1044 }
1045 }
1048 //G_BREAKPOINT ();
1049 }
1050 }
1052 static guint32
1054 {
1058 };
1062 };
1066 };
1070 };
1084 }
1086 #ifdef MONO_ARCH_SOFT_FLOAT
1087 static int
1089 {
1101 }
1104 }
1105 #endif
1107 /*
1108 * Returns the type used in the eval stack when @type is loaded.
1109 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
1110 */
1111 static void
1113 {
1120 }
1122 handle_enum:
1166 }
1176 }
1177 }
1179 /*
1180 * The following tables are used to quickly validate the IL code in type_from_op ().
1181 */
1182 static const char
1192 };
1194 static const char
1195 neg_table [] = {
1197 };
1199 /* reduce the size of this table */
1200 static const char
1210 };
1212 static const char
1214 /* Inv i L p F & O vt */
1223 };
1225 /* reduce the size of this table */
1226 static const char
1236 };
1238 /*
1239 * Tables to map from the non-specific opcode to the matching
1240 * type-specific opcode.
1241 */
1242 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
1243 static const guint16
1246 };
1248 /* handles from CEE_NEG to CEE_CONV_U8 */
1249 static const guint16
1252 };
1254 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
1255 static const guint16
1257 0, 0, OP_LCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2, OP_FCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2
1258 };
1260 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
1261 static const guint16
1263 0, 0, OP_LCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_PCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_FCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_PCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN
1264 };
1266 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
1267 static const guint16
1269 0, 0, OP_LCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_PCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_FCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_PCONV_TO_OVF_I1-CEE_CONV_OVF_I1
1270 };
1272 /* handles from CEE_CEQ to CEE_CLT_UN */
1273 static const guint16
1276 };
1278 /*
1279 * Sets ins->type (the type on the eval stack) according to the
1280 * type of the opcode and the arguments to it.
1281 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
1282 *
1283 * FIXME: this function sets ins->type unconditionally in some cases, but
1284 * it should set it to invalid for some types (a conv.x on an object)
1285 */
1286 static void
1289 /* binops */
1295 /* FIXME: check unverifiable args for STACK_MP */
1315 /* FIXME: handle some specifics with ins->next->type */
1317 if ((ins->inst_i0->type == STACK_I8) || ((sizeof (gpointer) == 8) && ((ins->inst_i0->type == STACK_PTR) || (ins->inst_i0->type == STACK_OBJ) || (ins->inst_i0->type == STACK_MP))))
1328 /* unops */
1336 else
1356 }
1394 }
1442 }
1443 }
1445 static const char
1446 ldind_type [] = {
1447 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1448 };
1450 /* map ldelem.x to the matching ldind.x opcode */
1451 static const guchar
1452 ldelem_to_ldind [] = {
1453 CEE_LDIND_I1,
1454 CEE_LDIND_U1,
1455 CEE_LDIND_I2,
1456 CEE_LDIND_U2,
1457 CEE_LDIND_I4,
1458 CEE_LDIND_U4,
1459 CEE_LDIND_I8,
1460 CEE_LDIND_I,
1461 CEE_LDIND_R4,
1462 CEE_LDIND_R8,
1463 CEE_LDIND_REF
1464 };
1466 /* map stelem.x to the matching stind.x opcode */
1467 static const guchar
1468 stelem_to_stind [] = {
1469 CEE_STIND_I,
1470 CEE_STIND_I1,
1471 CEE_STIND_I2,
1472 CEE_STIND_I4,
1473 CEE_STIND_I8,
1474 CEE_STIND_R4,
1475 CEE_STIND_R8,
1476 CEE_STIND_REF
1477 };
1479 #if 0
1481 static const char
1484 };
1486 static int
1498 }
1499 args++;
1500 }
1521 }
1534 }
1535 /*if (!param_table [args [i].type] [sig->params [i]->type])
1536 return 0;*/
1537 }
1539 }
1540 #endif
1542 /*
1543 * When we need a pointer to the current domain many times in a method, we
1544 * call mono_domain_get() once and we store the result in a local variable.
1545 * This function returns the variable that represents the MonoDomain*.
1546 */
1549 {
1553 }
1555 /*
1556 * The got_var contains the address of the Global Offset Table when AOT
1557 * compiling.
1558 */
1561 {
1562 #ifdef MONO_ARCH_NEED_GOT_VAR
1567 }
1569 #else
1571 #endif
1572 }
1574 MonoInst*
1576 {
1583 cfg->vars = (MonoMethodVar **)g_realloc (cfg->vars, sizeof (MonoMethodVar*) * cfg->varinfo_count);
1584 }
1586 /*g_print ("created temp %d of type 0x%x\n", num, type->type);*/
1593 /* if set to 1 the variable is native */
1602 //g_print ("created temp %d of type %s\n", num, mono_type_get_name (type));
1604 }
1606 /*
1607 * Transform a MonoInst into a load from the variable of index var_index.
1608 */
1609 void
1617 }
1619 /*
1620 * Create a MonoInst that is a load from the variable of index var_index.
1621 */
1622 MonoInst*
1627 }
1629 /*
1630 * Create a MonoInst that is a store of the given value into the variable of index var_index.
1631 */
1632 MonoInst*
1637 }
1647 /*
1648 * FIXME: This doesn't work because mono_class_from_mono_type ()
1649 * returns the original klass for a byref type, not a 'byref' class,
1650 * causing the JIT to create variables with the wrong type, for
1651 * example.
1652 */
1653 /*
1654 if (ins->klass)
1655 return &ins->klass->this_arg;
1656 else
1657 */
1663 }
1665 }
1667 MonoType*
1670 }
1674 {
1708 }
1710 }
1712 void
1714 {
1719 }
1743 }
1747 }
1749 // g_warning ("handle conditional jump in add_ins_to_end ()\n");
1753 }
1754 }
1756 void
1758 {
1770 }
1771 }
1773 /*
1774 * We try to share variables when possible
1775 */
1778 {
1782 /* inlining can result in deeper stacks */
1802 }
1804 }
1806 /*
1807 * merge_stacks:
1808 *
1809 * Merge stack state between two basic blocks according to Ecma 335, Partition III,
1810 * section 1.8.1.1. Store the resulting stack state into stack_2.
1811 * Returns: TRUE, if verification succeeds, FALSE otherwise.
1812 * FIXME: We should store the stack state in a dedicated structure instead of in
1813 * MonoInst's.
1814 */
1815 static gboolean
1817 {
1823 /* FIXME: Implement all checks from the spec */
1834 /* FIXME: Perform merge ? */
1835 /* klass == NULL means a native int */
1839 }
1842 /* FIXME: Change this to an assert and fix the JIT to allways fill this */
1846 }
1853 /* slot1 is ldnull */
1855 /* slot2 is ldnull */
1857 }
1859 }
1860 }
1861 }
1864 }
1866 /*
1867 * This function is called to handle items that are left on the evaluation stack
1868 * at basic block boundaries. What happens is that we save the values to local variables
1869 * and we reload them later when first entering the target basic block (with the
1870 * handle_loaded_temps () function).
1871 * It is also used to handle items on the stack in store opcodes, since it is
1872 * possible that the variable to be stored into is already on the stack, in
1873 * which case its old value should be used.
1874 * A single joint point will use the same variables (stored in the array bb->out_stack or
1875 * bb->in_stack, if the basic block is before or after the joint point).
1876 * If the stack merge fails at a join point, cfg->unverifiable is set.
1877 */
1878 static int
1884 gboolean found;
1896 /* Check that instructions other than ldnull have ins->klass set */
1897 if (!cfg->dont_verify_stack_merge && (sp [i]->type == STACK_OBJ) && !((sp [i]->opcode == OP_PCONST) && sp [i]->inst_c0 == 0))
1899 }
1901 /* Perform verification and stack state merge */
1905 /* exception handlers are linked, but they should not be considered for stack args */
1909 gboolean verified;
1914 }
1919 }
1925 printf ("\tStack state of BB%d, slot %d=%d\n", outb->block_num, j, outb->stack_state [j].type);
1926 }
1928 /* Make a copy of the stack state */
1931 }
1932 }
1936 //g_print ("bblock %d has out:", bb->block_num);
1940 /* exception handlers are linked, but they should not be considered for stack args */
1943 //g_print (" %d", outb->block_num);
1948 }
1949 }
1950 //g_print ("\n");
1954 /*
1955 * try to reuse temps already allocated for this purpouse, if they occupy the same
1956 * stack slot and if they are of the same type.
1957 * This won't cause conflicts since if 'local' is used to
1958 * store one of the values in the in_stack of a bblock, then
1959 * the same variable will be used for the same outgoing stack
1960 * slot as well.
1961 * This doesn't work when inlining methods, since the bblocks
1962 * in the inlined methods do not inherit their in_stack from
1963 * the bblock they are inlined to. See bug #58863 for an
1964 * example.
1965 */
1968 else
1970 }
1971 }
1972 }
1976 /* exception handlers are linked, but they should not be considered for stack args */
1983 }
1986 }
1990 /* add store ops at the end of the bb, before the branch */
1998 }
2001 }
2003 /*
2004 * It is possible that the out bblocks already have in_stack assigned, and
2005 * the in_stacks differ. In this case, we will store to all the different
2006 * in_stacks.
2007 */
2012 /* Find a bblock which has a different in_stack */
2016 /* exception handlers are linked, but they should not be considered for stack args */
2018 bindex++;
2020 }
2022 /*
2023 * Instead of storing sp [i] to locals [i], we need to store
2024 * locals [i] to <new locals>[i], since the sp [i] tree can't
2025 * be shared between trees.
2026 */
2032 }
2033 bindex ++;
2034 }
2035 }
2038 }
2040 static int
2042 {
2046 handle_enum:
2089 }
2091 }
2093 void
2094 mono_create_jump_table (MonoCompile *cfg, MonoInst *label, MonoBasicBlock **bbs, int num_blocks)
2095 {
2108 }
2110 /*
2111 * When we add a tree of instructions, we need to ensure the instructions currently
2112 * on the stack are executed before (like, if we load a value from a local).
2113 * We ensure this by saving the currently loaded values to temps and rewriting the
2114 * instructions to load the values.
2115 * This is not done for opcodes that terminate a basic block (because it's handled already
2116 * by handle_stack_args ()) and for opcodes that can't change values, like POP.
2117 */
2118 static void
2119 handle_loaded_temps (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst **stack, MonoInst **sp)
2120 {
2125 /* handle also other constants */
2127 /* temps never get written to again, so we can safely avoid duplicating them */
2128 !(ins->ssa_op == MONO_SSA_LOAD && ins->inst_i0->opcode == OP_LOCAL && ins->inst_i0->flags & MONO_INST_IS_TEMP)) {
2141 }
2142 stack++;
2143 }
2144 }
2146 /*
2147 * target_type_is_incompatible:
2148 * @cfg: MonoCompile context
2149 *
2150 * Check that the item @arg on the evaluation stack can be stored
2151 * in the target type (can be a local, or field, etc).
2152 * The cfg arg can be used to check if we need verification or just
2153 * validity checks.
2154 *
2155 * Returns: non-0 value if arg can't be stored on a target.
2156 */
2157 static int
2159 {
2164 /* FIXME: check that the pointed to types match */
2170 }
2187 /* STACK_MP is needed when setting pinned locals */
2204 /* FIXME: check type compatibility */
2241 /* FIXME: check type compatibility */
2243 }
2246 }
2248 }
2250 /*
2251 * Prepare arguments for passing to a function call.
2252 * Return a non-zero value if the arguments can't be passed to the given
2253 * signature.
2254 * The type checks are not yet complete and some conversions may need
2255 * casts on 32 or 64 bit architectures.
2256 *
2257 * FIXME: implement this using target_type_is_incompatible ()
2258 */
2259 static int
2261 {
2268 args++;
2269 }
2275 }
2277 handle_enum:
2297 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2322 }
2337 }
2338 }
2340 }
2343 mono_spill_call (MonoCompile *cfg, MonoBasicBlock *bblock, MonoCallInst *call, MonoMethodSignature *sig, gboolean ret_object,
2345 {
2357 }
2364 /*
2365 * Emit a dummy store to the local holding the result so the
2366 * liveness info remains correct.
2367 */
2371 else
2374 /* we use this to allocate native sized structs */
2380 else
2385 else
2392 else
2394 }
2399 else
2402 }
2403 }
2408 {
2427 else
2430 }
2432 }
2437 {
2443 }
2446 mono_emit_method_call_full (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethod *method, MonoMethodSignature *sig,
2448 {
2460 }
2465 /* Needed by the code generated in inssel.brg */
2469 }
2472 mono_emit_method_call (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethod *method, MonoMethodSignature *sig,
2474 {
2476 }
2481 {
2485 }
2488 mono_emit_method_call_spilled_full (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethod *method,
2491 {
2492 MonoCallInst *call = mono_emit_method_call_full (cfg, bblock, method, signature, args, ip, this, to_end);
2495 }
2498 mono_emit_native_call (MonoCompile *cfg, MonoBasicBlock *bblock, gconstpointer func, MonoMethodSignature *sig,
2500 {
2509 }
2512 mono_emit_jit_icall (MonoCompile *cfg, MonoBasicBlock *bblock, gconstpointer func, MonoInst **args, const guint8 *ip)
2513 {
2519 }
2521 return mono_emit_native_call (cfg, bblock, mono_icall_get_wrapper (info), info->sig, args, ip, FALSE, FALSE);
2522 }
2524 static void
2525 mono_emulate_opcode (MonoCompile *cfg, MonoInst *tree, MonoInst **iargs, MonoJitICallInfo *info)
2526 {
2532 //g_print ("emulating: ");
2533 //mono_print_tree_nl (tree);
2550 }
2561 else
2565 /*
2566 * This assumes that that in a tree, emulate_opcode is called for a
2567 * node before it is called for its children. dec_foreach needs to
2568 * take this into account.
2569 */
2575 }
2582 }
2583 }
2587 {
2595 }
2599 }
2604 #ifdef MONO_ARCH_VARARG_ICALLS
2605 /* Only set this only some archs since not all backends can handle varargs+pinvoke */
2607 #endif
2610 #ifdef PLATFORM_WIN32
2611 /*
2612 * The default pinvoke calling convention is STDCALL but we need CDECL.
2613 */
2615 #endif
2626 }
2630 {
2638 }
2642 }
2647 #ifdef MONO_ARCH_VARARG_ICALLS
2648 /* Only set this only some archs since not all backends can handle varargs+pinvoke */
2650 #endif
2652 #ifdef PLATFORM_WIN32
2654 #endif
2666 }
2668 #ifdef MONO_ARCH_SOFT_FLOAT
2669 static void
2670 handle_store_float (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *ptr, MonoInst *val, const unsigned char *ip)
2671 {
2677 }
2679 static int
2680 handle_load_float (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *ptr, const unsigned char *ip)
2681 {
2686 }
2688 #define LDLOC_SOFT_FLOAT(cfg,ins,idx,ip) do {\
2689 if (header->locals [(idx)]->type == MONO_TYPE_R4) { \
2690 int temp; \
2691 NEW_LOCLOADA (cfg, (ins), (idx)); \
2692 temp = handle_load_float (cfg, bblock, (ins), (ip)); \
2693 NEW_TEMPLOAD (cfg, (ins), temp); \
2694 } \
2695 } while (0)
2696 #define STLOC_SOFT_FLOAT(cfg,ins,idx,ip) do {\
2697 if (header->locals [(idx)]->type == MONO_TYPE_R4) { \
2698 int temp; \
2699 NEW_LOCLOADA (cfg, (ins), (idx)); \
2700 handle_store_float (cfg, bblock, (ins), *sp, (ip)); \
2701 MONO_INST_NEW (cfg, (ins), CEE_NOP); \
2702 } \
2703 } while (0)
2704 #define LDARG_SOFT_FLOAT(cfg,ins,idx,ip) do {\
2705 if (param_types [(idx)]->type == MONO_TYPE_R4) { \
2706 int temp; \
2707 NEW_ARGLOADA (cfg, (ins), (idx)); \
2708 temp = handle_load_float (cfg, bblock, (ins), (ip)); \
2709 NEW_TEMPLOAD (cfg, (ins), temp); \
2710 } \
2711 } while (0)
2712 #else
2713 #define LDLOC_SOFT_FLOAT(cfg,ins,idx,ip)
2714 #define STLOC_SOFT_FLOAT(cfg,ins,idx,ip)
2715 #define LDARG_SOFT_FLOAT(cfg,ins,idx,ip)
2716 #endif
2720 {
2726 }
2728 }
2730 static void
2731 handle_stobj (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *dest, MonoInst *src, const unsigned char *ip, MonoClass *klass, gboolean to_end, gboolean native, gboolean write_barrier) {
2738 /*
2739 * This check breaks with spilled vars... need to handle it during verification anyway.
2740 * g_assert (klass && klass == src->klass && klass == dest->klass);
2741 */
2745 else
2748 #if HAVE_WRITE_BARRIERS
2749 /* if native is true there should be no references in the struct */
2757 }
2758 #endif
2760 /* FIXME: add write barrier handling */
2764 /* Keep liveness info correct */
2767 }
2775 }
2781 mono_emit_method_call_spilled_full (cfg, bblock, memcpy_method, memcpy_method->signature, iargs, ip, NULL, FALSE, to_end);
2782 }
2786 {
2792 }
2794 }
2796 static void
2797 handle_initobj (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *dest, const guchar *ip, MonoClass *klass, MonoInst **stack_start, MonoInst **sp)
2798 {
2832 }
2838 mono_emit_method_call_spilled (cfg, bblock, memset_method, memset_method->signature, iargs, ip, NULL);
2840 }
2841 }
2843 static int
2844 handle_alloc (MonoCompile *cfg, MonoBasicBlock *bblock, MonoClass *klass, gboolean for_box, const guchar *ip)
2845 {
2854 } else if (cfg->compile_aot && bblock->out_of_line && klass->type_token && klass->image == mono_defaults.corlib) {
2855 /* This happens often in argument checking code, eg. throw new FooException... */
2856 /* Avoid relocations by calling a helper function specialized to mscorlib */
2861 gboolean pass_lw;
2869 }
2870 else
2872 }
2875 }
2877 /**
2878 * Handles unbox of a Nullable<T>, returning a temp variable
2879 * where the result is stored
2880 */
2881 static int
2882 handle_unbox_nullable (MonoCompile* cfg, MonoBasicBlock* bblock, MonoInst* val, const guchar *ip, MonoClass* klass)
2883 {
2885 return mono_emit_method_call_spilled (cfg, bblock, method, mono_method_signature (method), &val, ip, NULL);
2887 }
2892 handle_box (MonoCompile *cfg, MonoBasicBlock *bblock, MonoInst *val, const guchar *ip, MonoClass *klass)
2893 {
2899 temp = mono_emit_method_call_spilled (cfg, bblock, method, mono_method_signature (method), &val, ip, NULL);
2902 }
2926 }
2928 static int
2929 handle_array_new (MonoCompile *cfg, MonoBasicBlock *bblock, int rank, MonoInst **sp, unsigned char *ip)
2930 {
2936 /* Need to register the icall so it gets an icall wrapper */
2947 }
2952 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
2953 return mono_emit_native_call (cfg, bblock, mono_icall_get_wrapper (info), info->sig, sp, ip, TRUE, FALSE);
2954 }
2956 static void
2958 {
2968 /* Add it to the start of the first bblock */
2972 }
2973 else
2978 /*
2979 * Add a dummy use to keep the got_var alive, since real uses might
2980 * only be generated in the decompose or instruction selection phases.
2981 * Add it to end_bblock, so the variable's lifetime covers the whole
2982 * method.
2983 */
2987 }
2989 #define CODE_IS_STLOC(ip) (((ip) [0] >= CEE_STLOC_0 && (ip) [0] <= CEE_STLOC_3) || ((ip) [0] == CEE_STLOC_S))
2991 static gboolean
2993 {
2996 else
2998 }
3000 static gboolean
3002 {
3008 #ifdef MONO_ARCH_HAVE_LMF_OPS
3013 #endif
3022 /* fixme: why cant we inline valuetype returns? */
3026 /* its not worth to inline methods with valuetype arguments?? */
3030 }
3031 }
3033 /*
3034 * if we can initialize the class of the method right away, we do,
3035 * otherwise we don't allow inlining if the class needs initialization,
3036 * since it would mean inserting a call to mono_runtime_class_init()
3037 * inside the inlined code
3038 */
3043 /* This makes so that inline cannot trigger */
3044 /* .cctors: too many apps depend on them */
3045 /* running with a specific order... */
3049 }
3050 }
3054 /*
3055 * If we're compiling for shared code
3056 * the cctor will need to be run at aot method load time, for example,
3057 * or at the end of the compilation of the inlining method.
3058 */
3059 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3061 }
3062 //if (!MONO_TYPE_IS_VOID (signature->ret)) return FALSE;
3064 /*
3065 * CAS - do not inline methods with declarative security
3066 * Note: this has to be before any possible return TRUE;
3067 */
3071 /* also consider num_locals? */
3075 }
3080 }
3082 static gboolean
3084 {
3095 /* The initialization is already done before the method is called */
3099 }
3102 mini_get_ldelema_ins (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3103 {
3121 }
3124 #if defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(MONO_ARCH_NO_EMULATE_MUL)
3125 /* OP_LDELEMA2D depends on OP_LMUL */
3126 #else
3136 #endif
3137 }
3139 /* Need to register the icall so it gets an icall wrapper */
3150 }
3153 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3154 temp = mono_emit_native_call (cfg, bblock, mono_icall_get_wrapper (info), info->sig, sp, ip, FALSE, FALSE);
3159 }
3163 MonoJitICallInfo *
3165 {
3169 else
3171 }
3174 mini_get_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
3175 {
3209 /* The OP_GETHASHCODE rule depends on OP_MUL */
3210 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
3215 #endif
3242 if (strcmp (cmethod->name, "get_CurrentThread") == 0 && (ins = mono_arch_get_thread_intrinsic (cfg)))
3265 }
3268 }
3270 static void
3271 mono_save_args (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethodSignature *sig, MonoInst **sp, MonoInst **args)
3272 {
3290 }
3291 sp++;
3292 }
3307 }
3308 }
3309 sp++;
3310 }
3311 }
3312 #define MONO_INLINE_CALLED_LIMITED_METHODS 0
3313 #define MONO_INLINE_CALLER_LIMITED_METHODS 0
3315 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
3328 }
3329 }
3331 strncmp_result = strncmp (called_method_name, mono_inline_called_method_name_limit, strlen (mono_inline_called_method_name_limit));
3334 //return (strncmp_result <= 0);
3336 }
3337 #endif
3339 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
3352 }
3353 }
3355 strncmp_result = strncmp (caller_method_name, mono_inline_caller_method_name_limit, strlen (mono_inline_caller_method_name_limit));
3358 //return (strncmp_result <= 0);
3360 }
3361 #endif
3363 static int
3364 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoBasicBlock *bblock, MonoInst **sp,
3365 guchar *ip, guint real_offset, GList *dont_inline, MonoBasicBlock **last_b, gboolean inline_allways)
3366 {
3372 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
3375 #endif
3376 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
3379 #endif
3385 g_print ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
3390 }
3391 /* allocate space to store the return value */
3394 }
3396 /* allocate local variables */
3402 /* allocate starte and end blocks */
3414 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, new_locals_offset, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
3420 g_print ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
3424 /* always add some code to avoid block split failures */
3435 }
3441 }
3443 }
3445 /*
3446 * Some of these comments may well be out-of-date.
3447 * Design decisions: we do a single pass over the IL code (and we do bblock
3448 * splitting/merging in the few cases when it's required: a back jump to an IL
3449 * address that was not already seen as bblock starting point).
3450 * Code is validated as we go (full verification is still better left to metadata/verify.c).
3451 * Complex operations are decomposed in simpler ones right away. We need to let the
3452 * arch-specific code peek and poke inside this process somehow (except when the
3453 * optimizations can take advantage of the full semantic info of coarse opcodes).
3454 * All the opcodes of the form opcode.s are 'normalized' to opcode.
3455 * MonoInst->opcode initially is the IL opcode or some simplification of that
3456 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
3457 * opcode with value bigger than OP_LAST.
3458 * At this point the IR can be handed over to an interpreter, a dumb code generator
3459 * or to the optimizing code generator that will translate it to SSA form.
3460 *
3461 * Profiling directed optimizations.
3462 * We may compile by default with few or no optimizations and instrument the code
3463 * or the user may indicate what methods to optimize the most either in a config file
3464 * or through repeated runs where the compiler applies offline the optimizations to
3465 * each method and then decides if it was worth it.
3466 *
3467 * TODO:
3468 * * consider using an array instead of an hash table (bb_hash)
3469 */
3471 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
3472 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
3473 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
3474 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
3475 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
3476 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
3477 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
3478 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
3480 /* offset from br.s -> br like opcodes */
3481 #define BIG_BRANCH_OFFSET 13
3483 static gboolean
3485 {
3489 }
3491 static int
3492 get_basic_blocks (MonoCompile *cfg, GHashTable *bbhash, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
3493 {
3497 guint cli_addr;
3505 UNVERIFIED;
3509 ip++;
3544 guint32 j;
3554 }
3556 }
3563 }
3568 /* Find the start of the bblock containing the throw */
3572 bb_start --;
3573 }
3576 }
3577 }
3579 unverified:
3582 }
3586 {
3601 }
3605 {
3617 }
3621 {
3626 else
3631 }
3633 /*
3634 * Returns TRUE if the JIT should abort inlining because "callee"
3635 * is influenced by security attributes.
3636 */
3637 static
3638 gboolean check_linkdemand (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee, MonoBasicBlock *bblock, unsigned char *ip)
3639 {
3640 guint32 result;
3644 }
3651 /* Generate code to throw a SecurityException before the actual call/link */
3653 MonoReflectionAssembly *refass = (MonoReflectionAssembly*) mono_assembly_get_object (cfg->domain, assembly);
3661 mono_emit_method_call_spilled (cfg, bblock, secman->linkdemandsecurityexception, mono_method_signature (secman->linkdemandsecurityexception), args, ip, NULL);
3663 /* don't hide previous results */
3666 }
3669 }
3671 static gboolean
3673 {
3681 /* Be conservative with checks */
3691 }
3693 }
3695 }
3697 /* FIXME: check visibility of type, too */
3698 static gboolean
3700 {
3701 /* Partition I 8.5.3.2 */
3702 /* the access level values are the same for fields and methods */
3705 /* same compilation unit */
3726 }
3728 }
3730 static gboolean
3732 {
3733 /* FIXME: check all overlapping fields */
3734 int can = can_access_member (method->klass, field->parent, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
3738 can = can_access_member (nested, field->parent, field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK);
3742 }
3743 }
3745 }
3747 static gboolean
3749 {
3750 int can = can_access_member (method->klass, called->klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
3754 can = can_access_member (nested, called->klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
3758 }
3759 }
3760 /*
3761 * FIXME:
3762 * with generics calls to explicit interface implementations can be expressed
3763 * directly: the method is private, but we must allow it. This may be opening
3764 * a hole or the generics code should handle this differently.
3765 * Maybe just ensure the interface type is public.
3766 */
3770 }
3772 /*
3773 * mono_method_to_ir: translates IL into basic blocks containing trees
3774 */
3775 static int
3776 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
3779 {
3801 guint32 align;
3805 MonoDeclSecurityActions actions;
3809 /* serialization and xdomain stuff may need access to private fields and methods */
3817 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
3822 /* Not turned on yet */
3847 }
3858 /* ENTRY BLOCK */
3864 /* EXIT BLOCK */
3878 }
3879 /* handle exception clauses */
3899 /* todo: is a fault block unsafe to optimize? */
3902 }
3905 /*g_print ("clause try IL_%04x to IL_%04x handler %d at IL_%04x to IL_%04x\n", clause->try_offset, clause->try_offset + clause->try_len, clause->flags, clause->handler_offset, clause->handler_offset + clause->handler_len);
3906 while (p < end) {
3907 g_print ("%s", mono_disasm_code_one (NULL, method, p, &p));
3908 }*/
3909 /* catch and filter blocks get the exception object on the stack */
3914 /* mostly like handle_stack_args (), but just sets the input args */
3915 /* g_print ("handling clause at IL_%04x\n", clause->handler_offset); */
3921 /* FIXME? */
3924 /*
3925 * Add a dummy use for the exvar so its liveness info will be
3926 * correct.
3927 */
3939 /* FIXME? */
3942 /* The filter block shares the exvar with the handler block */
3946 }
3947 }
3948 }
3952 }
3954 /* FIRST CODE BLOCK */
3965 }
3966 }
3972 /* at this point having security doesn't mean we have any code to generate */
3974 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
3975 * And we do not want to enter the next section (with allocation) if we
3976 * have nothing to generate */
3978 }
3980 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
3987 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
3990 }
3996 }
3997 }
3999 /* not a P/Invoke after all */
4001 }
4002 }
4004 if ((header->init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
4005 /* we use a separate basic block for the initialization code */
4016 }
4018 /* at this point we know, if security is TRUE, that some code needs to be generated */
4025 /* Add code for SecurityAction.Demand */
4028 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
4029 mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, mono_method_signature (secman->demand), args, ip, NULL);
4030 }
4032 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
4033 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
4036 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
4037 mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, mono_method_signature (secman->demand), args, ip, NULL);
4038 }
4040 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
4043 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
4044 mono_emit_method_call_spilled (cfg, init_localsbb, secman->demandchoice, mono_method_signature (secman->demandchoice), args, ip, NULL);
4045 }
4046 }
4048 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
4050 mono_emit_method_call_spilled (cfg, init_localsbb, secman->demandunmanaged, mono_method_signature (secman->demandunmanaged), NULL, ip, NULL);
4051 }
4055 UNVERIFIED;
4056 }
4068 UNVERIFIED;
4069 }
4072 /* do this somewhere outside - not here */
4084 /* add a check for this != NULL to inlined methods */
4090 }
4092 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
4093 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
4101 else
4110 }
4119 }
4129 }
4137 }
4140 }
4141 }
4150 /* TODO: Use an increment here */
4163 }
4166 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
4211 UNVERIFIED;
4249 UNVERIFIED;
4285 UNVERIFIED;
4355 /* we should really allocate this only late in the compilation process */
4370 }
4387 }
4392 sp--;
4395 /*
4396 * small optimization: if the loaded value was from a local already,
4397 * just load it twice.
4398 */
4401 sp++;
4417 }
4424 }
4428 }
4440 UNVERIFIED;
4443 /* FIXME: check the signature matches */
4451 INLINE_FAILURE;
4452 }
4477 else
4488 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
4493 }
4498 UNVERIFIED;
4501 /* MS.NET seems to silently convert this to a callvirt */
4507 }
4516 }
4522 INLINE_FAILURE;
4523 }
4528 }
4533 }
4536 UNVERIFIED;
4540 //g_assert (!virtual || fsig->hasthis);
4545 /*
4546 * We have the `constrained.' prefix opcode.
4547 */
4550 /*
4551 * The type parameter is instantiated as a valuetype,
4552 * but that type doesn't override the method we're
4553 * calling, so we need to box `this'.
4554 * sp [0] is a pointer to the data: we need the value
4555 * in handle_box (), so load it here.
4556 */
4565 /*
4566 * The type parameter is instantiated as a reference
4567 * type. We have a managed pointer on the stack, so
4568 * we need to dereference it here.
4569 */
4580 }
4583 UNVERIFIED;
4594 /* Prevent inlining of methods that contain indirect calls */
4595 INLINE_FAILURE;
4604 /* FIXME: This should be a managed pointer */
4619 sp++;
4620 }
4625 }
4628 (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)))) {
4631 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
4632 INLINE_FAILURE;
4633 /* FIXME: This assumes the two methods has the same number and type of arguments */
4634 /*
4635 * We implement tail calls by storing the actual arguments into the
4636 * argument variables, then emitting a CEE_JMP. Since the actual arguments
4637 * can refer to the arg variables, we have to spill them.
4638 */
4641 /* Prevent argument from being register allocated */
4644 /* Check if argument is the same */
4645 /*
4646 * FIXME: This loses liveness info, so it can only be done if the
4647 * argument is not register allocated.
4648 */
4658 }
4659 else
4661 }
4669 /* skip CEE_RET as well */
4673 }
4674 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_get_inst_for_method (cfg, cmethod, fsig, sp))) {
4682 sp++;
4683 }
4688 }
4693 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || (cmethod->flags & METHOD_ATTRIBUTE_FINAL)) &&
4702 /* Prevent inlining of methods that call wrappers */
4703 INLINE_FAILURE;
4706 }
4708 if ((costs = inline_method (cfg, cmethod, fsig, bblock, sp, ip, real_offset, dont_inline, &ebblock, allways))) {
4717 sp++;
4719 /* indicates start of a new block, and triggers a load of all
4720 stack arguments at bb boundarie */
4726 }
4727 }
4731 /* tail recursion elimination */
4732 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET) {
4736 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
4737 INLINE_FAILURE;
4738 /* keep it simple */
4742 }
4749 }
4758 /* skip the CEE_RET, too */
4761 else
4765 }
4766 }
4769 /* Prevent inlining of methods with indirect calls */
4770 INLINE_FAILURE;
4773 sp++;
4774 }
4791 to_store = mono_compile_create_var (cfg, type_from_stack_type (sp [fsig->param_count]), OP_LOCAL);
4797 /*
4798 * We first save the args for the call so that the args are copied to the stack
4799 * and a new instruction tree for them is created. If we don't do this,
4800 * the same MonoInst is added to two different trees and this is not
4801 * allowed by burg.
4802 */
4807 }
4813 handle_stobj (cfg, bblock, addr, sp [fsig->param_count], ip, mono_class_from_mono_type (fsig->params [fsig->param_count-1]), FALSE, FALSE, TRUE);
4816 }
4829 }
4832 /* Prevent inlining of methods which call other methods */
4833 INLINE_FAILURE;
4838 /* no need to spill */
4839 ins = (MonoInst*)mono_emit_method_call (cfg, bblock, cmethod, fsig, sp, ip, virtual ? sp [0] : NULL);
4842 if ((temp = mono_emit_method_call_spilled (cfg, bblock, cmethod, fsig, sp, ip, virtual ? sp [0] : NULL)) != -1) {
4844 sp++;
4845 }
4846 }
4847 }
4852 }
4855 /* return from inlined methode */
4860 //g_assert (returnvar != -1);
4866 /* FIXME: it is possible some optimization will pass the a heap pointer for the struct address, so we'll need the write barrier */
4867 handle_stobj (cfg, bblock, store, *sp, sp [0]->cil_code, return_var->klass, FALSE, FALSE, FALSE);
4870 }
4880 /* FIXME: it is possible some optimization will pass the a heap pointer for the struct address, so we'll need the write barrier */
4888 }
4889 }
4890 }
4892 UNVERIFIED;
4915 }
4924 UNVERIFIED;
4928 ip++;
4934 }
4952 ip++;
4953 #ifdef MONO_ARCH_SOFT_FLOAT
4965 }
4966 #else
4968 #endif
4973 }
4991 }
5000 UNVERIFIED;
5010 }
5029 #ifdef MONO_ARCH_SOFT_FLOAT
5041 }
5042 #else
5044 #endif
5049 }
5060 UNVERIFIED;
5077 }
5082 }
5083 /* Needed by the code generated in inssel.brg */
5109 #ifdef MONO_ARCH_SOFT_FLOAT
5115 sp++;
5116 }
5117 #endif
5128 #ifdef MONO_ARCH_SOFT_FLOAT
5132 ip++;
5134 }
5135 #endif
5136 #if HAVE_WRITE_BARRIERS
5138 /* insert call to write barrier */
5141 mono_emit_method_call_spilled (cfg, bblock, write_barrier, mono_method_signature (write_barrier), sp, ip, NULL);
5142 ip++;
5144 }
5145 #endif
5161 #ifdef MONO_ARCH_NO_EMULATE_MUL_IMM
5162 /* FIXME: This breaks with ssapre (mono -O=ssapre loader.exe) */
5175 }
5176 }
5177 #endif
5182 }
5183 ip++;
5199 /* special case that gives a nice speedup and happens to workaorund a ppc jit but (for the release)
5200 * later apply the speedup to the left shift as well
5201 * See BUG# 57957.
5202 */
5206 /*g_print ("applied long shr speedup to %s\n", cfg->method->name);*/
5207 ip++;
5209 }
5213 }
5214 ip++;
5234 }
5235 ip++;
5249 }
5251 ip++;
5263 }
5265 ip++;
5279 ip++;
5321 mono_emit_method_call_spilled (cfg, bblock, memcpy_method, memcpy_method->signature, iargs, ip, NULL);
5322 }
5323 }
5348 }
5350 /* Optimize the common ldobj+stloc combination */
5365 }
5380 }
5381 }
5400 mono_emit_method_call_spilled (cfg, bblock, memcpy_method, memcpy_method->signature, iargs, ip, NULL);
5401 }
5408 }
5420 }
5438 }
5439 /* avoid depending on undefined C behavior in sequence points */
5453 /*
5454 * Avoid relocations by using a version of helper_ldstr
5455 * specialized to mscorlib.
5456 */
5460 /* Avoid creating the string object */
5464 }
5466 }
5467 else
5471 }
5479 }
5480 }
5481 }
5483 sp++;
5503 INLINE_FAILURE;
5504 }
5509 /* move the args to allow room for 'this' in the first position */
5513 }
5521 /* we simply pass a null pointer */
5523 /* now call the string ctor */
5538 /*
5539 * The code generated by mini_emit_virtual_call () expects
5540 * iargs [0] to be a boxed instance, but luckily the vcall
5541 * will be transformed into a normal call there.
5542 */
5546 }
5548 /* Avoid virtual calls to ctors if possible */
5558 if ((costs = inline_method (cfg, cmethod, fsig, bblock, sp, ip, real_offset, dont_inline, &ebblock, FALSE))) {
5568 sp++;
5570 /* indicates start of a new block, and triggers a load
5571 of all stack arguments at bb boundarie */
5578 /* Prevent inlining of methods which call other methods */
5579 INLINE_FAILURE;
5581 }
5583 /* Prevent inlining of methods which call other methods */
5584 INLINE_FAILURE;
5585 /* now call the actual ctor */
5587 }
5588 }
5591 sp++;
5596 }
5605 UNVERIFIED;
5607 /* Needed by the code generated in inssel.brg */
5636 sp++;
5648 }
5662 /* CASTCLASS */
5688 sp++;
5700 }
5702 }
5707 sp ++;
5710 }
5727 /* LDOBJ impl */
5745 mono_emit_method_call_spilled (cfg, bblock, memcpy_method, memcpy_method->signature, iargs, ip, NULL);
5746 }
5751 }
5765 sp ++;
5768 }
5770 /* Needed by the code generated in inssel.brg */
5790 }
5799 UNVERIFIED;
5801 /* Needed by the code generated in inssel.brg */
5830 sp++;
5842 }
5867 guint foffset;
5875 }
5877 UNVERIFIED;
5879 UNVERIFIED;
5887 }
5892 UNVERIFIED;
5895 /* FIXME: mark instructions for use in SSA */
5898 UNVERIFIED;
5899 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
5922 /* indicates start of a new block, and triggers a load
5923 of all stack arguments at bb boundarie */
5929 mono_emit_method_call_spilled (cfg, bblock, stfld_wrapper, mono_method_signature (stfld_wrapper), iargs, ip, NULL);
5930 }
5931 #if HAVE_WRITE_BARRIERS
5933 /* insert call to write barrier */
5945 mono_emit_method_call_spilled (cfg, bblock, write_barrier, mono_method_signature (write_barrier), iargs, ip, NULL);
5946 #endif
5947 #ifdef MONO_ARCH_SOFT_FLOAT
5957 #endif
5979 }
5981 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
5982 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
5989 NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
5990 if ((cfg->opt & MONO_OPT_INLINE) && !MONO_TYPE_ISSTRUCT (mono_method_signature (wrapper)->ret)) {
6005 sp++;
6007 /* indicates start of a new block, and triggers a load of
6008 all stack arguments at bb boundarie */
6014 temp = mono_emit_method_call_spilled (cfg, bblock, wrapper, mono_method_signature (wrapper), iargs, ip, NULL);
6016 sp++;
6017 }
6037 #ifdef MONO_ARCH_SOFT_FLOAT
6042 sp++;
6044 #endif
6046 }
6047 }
6048 }
6051 }
6063 }
6064 else
6075 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
6076 * to be called here.
6077 */
6091 /* avoid depending on undefined C behavior in sequence points */
6101 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
6104 helper_sig_class_init_trampoline,
6111 /* This makes so that inline cannot trigger */
6112 /* .cctors: too many apps depend on them */
6113 /* running with a specific order... */
6115 INLINE_FAILURE;
6117 }
6118 }
6123 else
6127 /*
6128 * insert call to mono_threads_get_static_data (GPOINTER_TO_UINT (addr))
6129 * This could be later optimized to do just a couple of
6130 * memory dereferences with constant offsets.
6131 */
6137 }
6138 }
6140 /* FIXME: mark instructions for use in SSA */
6147 sp--;
6156 handle_stobj (cfg, bblock, ins, sp [0], ip, mono_class_from_mono_type (field->type), FALSE, FALSE, FALSE);
6168 }
6169 /* g_print ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, field->name);*/
6175 sp++;
6179 sp++;
6184 sp++;
6188 sp++;
6193 sp++;
6197 sp++;
6199 #ifndef HAVE_MOVING_COLLECTOR
6211 sp++;
6213 #endif
6219 sp++;
6227 }
6228 }
6240 /* fixme: dont see the problem why this does not work */
6241 //cfg->disable_aot = TRUE;
6242 }
6243 }
6246 }
6258 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
6266 }
6285 }
6287 UNVERIFIED;
6289 UNVERIFIED;
6290 /* frequent check in generic code: box (struct), brtrue */
6292 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
6293 /*g_print ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
6304 ip++;
6306 ip++;
6309 ip++;
6312 }
6321 }
6324 }
6329 }
6339 /* allocate the domainvar - becaus this is used in decompose_foreach */
6342 /* LAME-IR: Mark it as used since otherwise it will be optimized away */
6344 }
6346 /* Ditto */
6357 /*
6358 * we store the object so calls to create the array are not interleaved
6359 * with the arguments of other calls.
6360 */
6371 }
6378 UNVERIFIED;
6390 UNVERIFIED;
6394 /* we need to make sure that this array is exactly the type it needs
6395 * to be for correctness. the wrappers are lax with their usage
6396 * so we need to ignore them here
6397 */
6407 }
6420 UNVERIFIED;
6435 }
6448 /*
6449 * translate to:
6450 * ldind.x (ldelema (array, index))
6451 * ldelema does the bounds check
6452 */
6456 UNVERIFIED;
6460 #ifdef MONO_ARCH_SOFT_FLOAT
6465 sp++;
6468 }
6469 #endif
6478 }
6487 /*
6488 * translate to:
6489 * stind.x (ldelema (array, index), val)
6490 * ldelema does the bounds check
6491 */
6495 UNVERIFIED;
6499 #ifdef MONO_ARCH_SOFT_FLOAT
6502 ip++;
6504 }
6505 #endif
6515 }
6518 /*
6519 * translate to:
6520 * stind.x (ldelema (array, index), val)
6521 * ldelema does the bounds check
6522 */
6526 UNVERIFIED;
6541 mono_emit_method_call_spilled (cfg, bblock, helper, mono_method_signature (helper), iargs, ip, NULL);
6556 }
6557 }
6561 }
6569 UNVERIFIED;
6571 UNVERIFIED;
6579 mono_emit_method_call_spilled (cfg, bblock, helper, mono_method_signature (helper), iargs, ip, NULL);
6581 /*
6582 MonoInst *group;
6583 NEW_GROUP (cfg, group, sp [0], sp [1]);
6584 MONO_INST_NEW (cfg, ins, CEE_STELEM_REF);
6585 ins->cil_code = ip;
6586 ins->inst_left = group;
6587 ins->inst_right = sp [2];
6588 MONO_ADD_INS (bblock, ins);
6589 */
6594 }
6599 /* this instr. can throw exceptions as side effect,
6600 * so we cant eliminate dead code which contains CKFINITE opdodes.
6601 * Spilling to memory makes sure that we always perform
6602 * this check */
6618 }
6647 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
6659 }
6661 gpointer handle;
6674 }
6677 }
6698 if ((ip [5] == CEE_CALL) && (cmethod = mini_get_method (method, read32 (ip + 6), NULL, generic_context)) &&
6705 else
6715 else
6722 }
6723 }
6728 }
6734 ip++;
6747 }
6748 ip++;
6756 /*
6757 * Control will leave the method so empty the stack, otherwise
6758 * the next basic block will start with a nonempty stack.
6759 */
6763 sp--;
6766 }
6778 }
6780 /* empty the stack */
6784 sp--;
6787 }
6789 /*
6790 * If this leave statement is in a catch block, check for a
6791 * pending exception, and rethrow it if necessary.
6792 */
6796 /*
6797 * Use <= in the final comparison to handle clauses with multiple
6798 * leave statements, like in bug #78024.
6799 * The ordering of the exception clauses guarantees that we find the
6800 * innermost clause.
6801 */
6802 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((*ip == CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len)) {
6817 }
6818 }
6820 /* fixme: call fault handler ? */
6831 }
6833 }
6846 else
6850 }
6865 ip++;
6867 /* trampoline mono specific opcodes */
6877 gpointer func;
6891 sp++;
6892 }
6898 }
6908 /* Can't embed random pointers into AOT code */
6933 sp++;
6937 }
6973 UNVERIFIED;
6999 }
7002 #ifdef MONO_ARCH_HAVE_LMF_OPS
7006 #endif
7026 }
7028 }
7033 /* somewhat similar to LDTOKEN */
7036 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
7049 }
7057 /*
7058 * The following transforms:
7059 * CEE_CEQ into OP_CEQ
7060 * CEE_CGT into OP_CGT
7061 * CEE_CGT_UN into OP_CGT_UN
7062 * CEE_CLT into OP_CLT
7063 * CEE_CLT_UN into OP_CLT_UN
7064 */
7077 #if MONO_ARCH_SOFT_FLOAT
7083 }
7084 #endif
7085 if ((sp [0]->type == STACK_I8) || ((sizeof (gpointer) == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
7087 else
7090 /* spill it to reduce the expression complexity
7091 * and workaround bug 54209
7092 */
7096 }
7099 }
7114 INLINE_FAILURE;
7115 }
7122 else
7125 sp ++;
7130 }
7145 INLINE_FAILURE;
7146 }
7155 sp ++;
7160 }
7192 UNVERIFIED;
7230 UNVERIFIED;
7245 UNVERIFIED;
7247 /*
7248 * Inlining this into a loop in a parent could lead to
7249 * stack overflows which is different behavior than the
7250 * non-inlined case, thus disable inlining in this case.
7251 */
7264 /* FIXME: set init flag if locals init is set in this method */
7273 UNVERIFIED;
7286 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
7290 }
7291 }
7294 UNVERIFIED;
7297 }
7300 /* FIXME: record alignment? we can assume 1 for now */
7311 /* Can't inline tail calls at this time */
7336 }
7341 /* FIXME: implement */
7353 if ((cfg->opt & MONO_OPT_INTRINS) && (ip [1] == CEE_CPBLK) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
7363 }
7370 mono_emit_method_call_spilled (cfg, bblock, memcpy_method, memcpy_method->signature, iargs, ip, NULL);
7373 mono_emit_method_call_spilled (cfg, bblock, memset_method, memset_method->signature, iargs, ip, NULL);
7374 }
7378 }
7385 /* we ignore the no-nullcheck for now since we
7386 * really do it explicitly only when doing callvirt->call
7387 */
7396 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY))
7398 }
7415 }
7420 /* FIXXME: handle generics. */
7429 }
7452 }
7454 }
7457 }
7458 }
7460 UNVERIFIED;
7477 }
7481 }
7508 #ifdef MONO_ARCH_SOFT_FLOAT
7509 /* FIXME: handle init of R4 */
7510 #else
7516 #endif
7525 }
7526 }
7527 }
7529 /* resolve backward branches in the middle of an existing basic block */
7532 /*g_print ("need recheck in %s at IL_%04x\n", method->name, bblock->cil_code - header->code);*/
7542 }
7543 }
7553 }
7556 }
7564 /* Method is too large */
7570 }
7574 inline_failure:
7581 load_error:
7589 unverified:
7598 }
7600 void
7631 else
7658 }
7660 }
7668 }
7671 }
7685 printf ("[%s] <- [%s + 0x%x]", mono_arch_regname (tree->dreg), mono_arch_regname (tree->inst_basereg), (int)tree->inst_offset);
7721 }
7722 }
7724 }
7728 }
7730 void
7732 {
7735 }
7737 static void
7739 {
7742 }
7744 gconstpointer
7746 {
7749 gconstpointer trampoline;
7754 }
7759 /*
7760 * We use the lock on the root domain instead of the JIT lock to protect
7761 * callinfo->trampoline, since we do a lot of stuff inside the critical section.
7762 */
7768 }
7774 trampoline = mono_create_ftnptr (domain, mono_create_jit_trampoline_in_domain (domain, wrapper));
7782 }
7784 static void
7786 {
7787 mono_trampoline_code [MONO_TRAMPOLINE_GENERIC] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_GENERIC);
7788 mono_trampoline_code [MONO_TRAMPOLINE_JUMP] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_JUMP);
7789 mono_trampoline_code [MONO_TRAMPOLINE_CLASS_INIT] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_CLASS_INIT);
7790 #ifdef MONO_ARCH_HAVE_PIC_AOT
7791 mono_trampoline_code [MONO_TRAMPOLINE_AOT] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_AOT);
7792 mono_trampoline_code [MONO_TRAMPOLINE_AOT_PLT] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_AOT_PLT);
7793 #endif
7794 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
7795 mono_trampoline_code [MONO_TRAMPOLINE_DELEGATE] = mono_arch_create_trampoline_code (MONO_TRAMPOLINE_DELEGATE);
7796 #endif
7797 }
7799 static void
7801 {
7802 #ifndef CUSTOM_EXCEPTION_HANDLING
7807 #endif
7808 }
7810 guint8 *
7812 {
7814 }
7816 gpointer
7818 {
7821 /* previously created trampoline code */
7823 ptr =
7825 vtable);
7830 #ifdef MONO_ARCH_HAVE_CREATE_SPECIFIC_TRAMPOLINE
7831 code = mono_arch_create_specific_trampoline (vtable, MONO_TRAMPOLINE_CLASS_INIT, vtable->domain, NULL);
7832 #else
7834 #endif
7838 /* store trampoline address */
7851 }
7853 gpointer
7855 gboolean add_sync_wrapper)
7856 {
7858 gpointer code;
7859 #ifdef MONO_ARCH_HAVE_CREATE_SPECIFIC_TRAMPOLINE
7860 guint32 code_size;
7861 #endif
7864 return mono_create_jump_trampoline (domain, mono_marshal_get_synchronized_wrapper (method), FALSE);
7876 #ifdef MONO_ARCH_HAVE_CREATE_SPECIFIC_TRAMPOLINE
7877 code = mono_arch_create_specific_trampoline (method, MONO_TRAMPOLINE_JUMP, mono_domain_get (), &code_size);
7885 #else
7887 #endif
7889 /*
7890 * mono_delegate_ctor needs to find the method metadata from the
7891 * trampoline address, so we save it here.
7892 */
7901 }
7903 static gpointer
7905 {
7906 gpointer tramp;
7917 #ifdef MONO_ARCH_HAVE_CREATE_SPECIFIC_TRAMPOLINE
7919 #else
7921 #endif
7930 }
7932 gpointer
7934 {
7936 }
7938 #ifdef MONO_ARCH_HAVE_CREATE_TRAMPOLINE_FROM_TOKEN
7939 gpointer
7941 {
7942 gpointer tramp;
7960 }
7961 #endif
7963 static gpointer
7965 {
7966 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
7968 guint32 code_size;
7971 #ifndef __ia64__
7975 #else
7976 /*
7977 * FIXME: We should return a function descriptor here but it is not stored
7978 * anywhere so it would be leaked.
7979 */
7980 #endif
7988 code = mono_arch_create_specific_trampoline (method, MONO_TRAMPOLINE_DELEGATE, domain, &code_size);
7992 /* store trampoline address */
7999 #else
8001 #endif
8002 }
8004 MonoVTable*
8006 {
8012 else
8016 }
8018 static void
8019 mono_dynamic_code_hash_insert (MonoDomain *domain, MonoMethod *method, MonoJitDynamicMethodInfo *ji)
8020 {
8024 }
8028 {
8033 else
8036 }
8044 /*
8045 * mono_allocate_stack_slots_full:
8046 *
8047 * Allocate stack slots for all non register allocated variables using a
8048 * linear scan algorithm.
8049 * Returns: an array of stack offsets which the caller should free.
8050 * STACK_SIZE is set to the amount of stack space needed.
8051 * STACK_ALIGN is set to the alignment needed by the locals area.
8052 */
8053 gint32*
8054 mono_allocate_stack_slots_full (MonoCompile *m, gboolean backward, guint32 *stack_size, guint32 *stack_align)
8055 {
8057 guint32 align;
8078 if ((inst->flags & MONO_INST_IS_DEAD) || inst->opcode == OP_REGVAR || inst->opcode == OP_REGOFFSET)
8082 }
8091 /* inst->backend.is_pinvoke indicates native sized value types, this is used by the
8092 * pinvoke wrappers when they call functions returning structures */
8093 if (inst->backend.is_pinvoke && MONO_TYPE_ISSTRUCT (inst->inst_vtype) && inst->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
8100 }
8111 }
8112 /* Fall through */
8123 nvtypes ++;
8124 }
8128 }
8129 }
8133 //printf ("START %2d %08x %08x\n", vmv->idx, vmv->range.first_use.abs_pos, vmv->range.last_use.abs_pos);
8135 /* expire old intervals in active */
8142 //printf ("EXPIR %2d %08x %08x C%d R%d\n", amv->idx, amv->range.first_use.abs_pos, amv->range.last_use.abs_pos, amv->spill_costs, amv->reg);
8146 }
8148 /*
8149 * This also handles the case when the variable is used in an
8150 * exception region, as liveness info is not computed there.
8151 */
8152 /*
8153 * FIXME: All valuetypes are marked as INDIRECT because of LDADDR
8154 * opcodes.
8155 */
8161 }
8164 }
8165 }
8167 {
8169 count ++;
8171 /*
8172 if (count == atoi (getenv ("COUNT")))
8173 printf ("LAST: %s\n", mono_method_full_name (m->method, TRUE));
8174 if (count > atoi (getenv ("COUNT")))
8175 slot = 0xffffff;
8176 else {
8177 mono_print_tree_nl (inst);
8178 }
8179 */
8180 }
8182 /*
8183 * Allways allocate valuetypes to sizeof (gpointer) to allow more
8184 * efficient copying (and to work around the fact that OP_MEMCPY
8185 * and OP_MEMSET ignores alignment).
8186 */
8195 }
8201 }
8205 }
8208 }
8213 }
8217 }
8223 }
8225 gint32*
8227 {
8229 }
8231 void
8232 mono_register_opcode_emulation (int opcode, const char *name, const char *sigstr, gpointer func, gboolean no_throw)
8233 {
8246 }
8248 static void
8250 {
8255 else
8259 }
8261 static void
8263 {
8279 }
8287 }
8289 MonoVTable *vtable = mono_class_vtable (cfg->domain, mono_array_class_get (tree->inst_newa_class, 1));
8295 }
8299 /* Need to decompose arguments after the the opcode is decomposed */
8303 }
8304 #ifdef MONO_ARCH_SOFT_FLOAT
8329 }
8331 }
8341 /* the args are in the compare opcode ... */
8352 }
8354 }
8355 #endif
8359 }
8360 }
8362 void
8376 }
8378 }
8380 G_GNUC_UNUSED
8381 static void
8389 }
8390 }
8391 }
8393 static void
8403 /*if (bb->cil_code) {
8404 char* code1, *code2;
8405 code1 = mono_disasm_code_one (NULL, cfg->method, bb->cil_code, NULL);
8406 if (bb->last_ins->cil_code)
8407 code2 = mono_disasm_code_one (NULL, cfg->method, bb->last_ins->cil_code, NULL);
8408 else
8409 code2 = g_strdup ("");
8411 code1 [strlen (code1) - 1] = 0;
8412 code = g_strdup_printf ("%s -> %s", code1, code2);
8413 g_free (code1);
8414 g_free (code2);
8415 } else*/
8424 }
8427 }
8432 }
8436 }
8447 }
8450 }
8452 void
8454 {
8462 }
8463 }
8465 void
8467 {
8468 //mono_mempool_stats (cfg->mempool);
8484 }
8486 #ifdef HAVE_KW_THREAD
8488 #ifdef MONO_ARCH_ENABLE_MONO_LMF_VAR
8489 /*
8490 * When this is defined, the current lmf is stored in this tls variable instead of in
8491 * jit_tls->lmf.
8492 */
8494 #endif
8495 #endif
8497 guint32
8499 {
8501 }
8503 gint32
8505 {
8506 #if defined(HAVE_KW_THREAD) && defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
8510 #else
8512 #endif
8513 }
8515 gint32
8517 {
8521 }
8523 MonoLMF *
8525 {
8526 #if defined(HAVE_KW_THREAD) && defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
8528 #else
8536 #endif
8537 }
8539 MonoLMF **
8541 {
8542 #ifdef HAVE_KW_THREAD
8544 #else
8552 #endif
8553 }
8555 /* Called by native->managed wrappers */
8556 void
8558 {
8559 #ifdef HAVE_KW_THREAD
8562 }
8563 #else
8566 #endif
8567 }
8569 /**
8570 * mono_thread_abort:
8571 * @obj: exception object
8572 *
8573 * abort the thread, print exception information and stack trace
8574 */
8575 static void
8577 {
8578 /* MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id); */
8580 /* handle_remove should be eventually called for this thread, too
8581 g_free (jit_tls);*/
8584 }
8588 {
8608 #if defined(HAVE_KW_THREAD) && defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
8609 /* jit_tls->lmf is unused */
8612 #else
8613 #if defined(HAVE_KW_THREAD)
8615 #endif
8618 #endif
8622 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
8624 #endif
8627 }
8629 static void
8631 {
8637 }
8641 static void
8643 {
8646 else
8648 }
8650 static void
8652 {
8660 }
8662 static void
8664 {
8670 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
8672 #endif
8677 }
8678 }
8680 void
8682 {
8691 }
8693 void
8695 {
8701 else
8703 }
8704 }
8706 /**
8707 * mono_patch_info_dup_mp:
8708 *
8709 * Make a copy of PATCH_INFO, allocating memory from the mempool MP.
8710 */
8711 MonoJumpInfo*
8713 {
8731 }
8734 }
8736 guint
8738 {
8749 }
8750 }
8752 /*
8753 * mono_patch_info_equal:
8754 *
8755 * This might fail to recognize equivalent patches, i.e. floats, so its only
8756 * usable in those cases where this is not a problem, i.e. sharing GOT slots
8757 * in AOT.
8758 */
8759 gint
8761 {
8781 }
8784 }
8786 gpointer
8787 mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *patch_info, gboolean run_cctors)
8788 {
8813 }
8816 }
8820 /* get the trampoline to the method from the domain */
8828 }
8833 /* get the trampoline to the method from the domain */
8841 jump_table = mono_code_manager_reserve (mono_dynamic_code_hash_lookup (domain, method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
8844 jump_table = mono_code_manager_reserve (domain->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
8846 }
8850 }
8853 }
8866 target = GINT_TO_POINTER ((int)(-((patch_info->data.klass->interface_id + 1) * SIZEOF_VOID_P)));
8872 target = mono_create_class_init_trampoline (mono_class_vtable (domain, patch_info->data.klass));
8876 if (!vtable->initialized && !(vtable->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT) && (method && mono_class_needs_cctor_run (vtable->klass, method)))
8877 /* Done by the generated code */
8878 ;
8882 }
8885 }
8894 target =
8899 gpointer handle;
8907 target =
8910 }
8912 gpointer handle;
8921 }
8923 target = (mono_metadata_blob_heap (patch_info->data.token->image, patch_info->data.token->token) + 2);
8932 }
8935 }
8937 static void
8955 }
8959 #ifdef MONO_ARCH_BIGMUL_INTRINS
8974 #endif
8989 }
8993 }
8994 }
8996 static void
9007 }
9008 }
9009 }
9011 static void
9013 {
9021 }
9023 static void
9025 {
9034 }
9038 }
9039 }
9040 }
9041 }
9043 static void
9045 {
9054 }
9058 }
9059 }
9060 }
9061 }
9063 static void
9071 }
9072 }
9073 }
9079 }
9087 }
9088 }
9090 }
9103 }
9106 }
9110 }
9111 }
9112 }
9114 static void
9116 {
9124 }
9125 }
9126 }
9128 }
9130 /**
9131 * Check if a bb is useless (is just made of NOPs and ends with an
9132 * unconditional branch, or nothing).
9133 * If it is so, unlink it from the CFG and nullify it, and return TRUE.
9134 * Otherwise, return FALSE;
9135 */
9136 static gboolean
9141 /* Do not touch handlers */
9145 }
9157 }
9158 }
9164 /* Do not touch empty BBs that do not "fall through" to their next BB (like the exit BB) */
9166 }
9167 }
9169 /* Do not touch BBs following a switch (they are the "default" branch) */
9172 }
9174 /* Do not touch BBs following the entry BB and jumping to something that is not */
9175 /* thiry "next" bb (the entry BB cannot contain the branch) */
9178 }
9180 /*
9181 * Do not touch BBs following a try block as the code in
9182 * mini_method_compile needs them to compute the length of the try block.
9183 */
9187 /* Check that there is a target BB, and that bb is not an empty loop (Bug 75061) */
9192 printf ("remove_block_if_useless %s, removed BB%d\n", mono_method_full_name (cfg->method, TRUE), bb->block_num);
9193 }
9195 /* unlink_bblock () modifies the bb->in_bb array so can't use a for loop here */
9201 }
9219 }
9220 }
9221 }
9229 }
9230 }
9232 static void
9234 {
9240 /* Nullify branch at the end of bb */
9243 }
9249 }
9253 }
9256 }
9258 static void
9260 {
9265 /* Find the previous */
9267 ;
9270 }
9272 /* Find the last */
9274 ;
9278 /* Add a branch */
9286 }
9287 }
9289 /* checks that a and b represent the same instructions, conservatively,
9290 * it can return FALSE also for two trees that are equal.
9291 * FIXME: also make sure there are no side effects.
9292 */
9293 static int
9295 {
9312 }
9313 }
9315 }
9317 static int
9319 {
9325 }
9328 }
9330 static int
9335 /* array lengths are positive as are string sizes */
9352 }
9353 }
9355 /* check if an unsigned compare can be used instead of two signed compares
9356 * for (val < 0 || val > limit) conditionals.
9357 * Returns TRUE if the optimization has been applied.
9358 * Note that this can't be applied if the second arg is not positive...
9359 */
9360 static int
9362 {
9373 /* target bb must have one instruction */
9376 if ((((condb->opcode == CEE_BLE || condb->opcode == CEE_BLT) && (condb->inst_false_bb == truet))
9382 /* change the original condbranch to just point to the new unsigned check */
9388 }
9390 }
9392 /*
9393 * Optimizes the branches on the Control Flow Graph
9394 *
9395 */
9396 static void
9398 {
9401 guint32 niterations;
9403 /*
9404 * Some crazy loops could cause the code below to go into an infinite
9405 * loop, see bug #53003 for an example. To prevent this, we put an upper
9406 * bound on the number of iterations.
9407 */
9410 else
9416 niterations --;
9418 /* we skip the entry block (exit is handled specially instead ) */
9419 for (previous_bb = cfg->bb_entry, bb = cfg->bb_entry->next_bb; bb; previous_bb = bb, bb = bb->next_bb) {
9421 /* dont touch code inside exception clauses */
9428 }
9441 }
9446 /* conditional branches where true and false targets are the same can be also replaced with CEE_BR */
9460 }
9463 /* the block are in sequence anyway ... */
9465 /* branches to the following block can be removed */
9471 }
9481 }
9483 //mono_print_bb_code (bb);
9484 }
9485 }
9486 }
9490 }
9499 }
9519 }
9520 }
9531 }
9533 /* if mono_eval_cond_branch () is ever taken to handle
9534 * non-constant values to compare, issue a pop here.
9535 */
9541 }
9550 /*
9551 * Unlink, then relink bblocks to avoid various
9552 * tricky situations when the two targets of the branch
9553 * are equal, or will become equal after the change.
9554 */
9565 }
9585 }
9586 }
9588 /* detect and optimize to unsigned compares checks like: if (v < 0 || v > limit */
9589 if (bb->last_ins && bb->last_ins->opcode == CEE_BLT && bb->last_ins->inst_left->inst_right->opcode == OP_ICONST) {
9591 /*g_print ("applied in bb %d (->%d) %s\n", bb->block_num, bb->last_ins->inst_target_bb->block_num, mono_method_full_name (cfg->method, TRUE));*/
9594 }
9595 }
9598 if (bb->last_ins->inst_false_bb->out_of_line && (bb->region == bb->last_ins->inst_false_bb->region)) {
9599 /* Reverse the branch */
9609 }
9610 }
9611 }
9612 }
9615 }
9617 static void
9619 {
9633 }
9644 }
9645 }
9656 #ifdef MONO_ARCH_HAVE_CREATE_VARS
9658 #endif
9659 }
9661 void
9663 {
9677 }
9681 }
9682 }
9686 static void
9688 {
9693 //g_print ("rule: %s\n", mono_burg_rule_string [ern]);
9696 //if (state->reg2)
9697 // state->reg1 = state->reg2; /* chain rule */
9698 //else
9699 #ifdef MONO_ARCH_ENABLE_EMIT_STATE_OPT
9701 #endif
9703 //g_print ("alloc symbolic R%d (reg2: R%d) in block %d\n", state->reg1, state->reg2, cfg->cbb->block_num);
9710 #ifdef MONO_ARCH_SOFT_FLOAT
9713 #else
9715 #endif
9718 #ifdef MONO_ARCH_ENABLE_EMIT_STATE_OPT
9719 /*
9720 * Enabling this might cause bugs to surface in the local register
9721 * allocators on some architectures like x86.
9722 */
9724 /* Do not optimize away reg-reg moves */
9725 if (! ((state->right->tree->ssa_op == MONO_SSA_LOAD) && (state->right->left->tree->opcode == OP_REGVAR))) {
9727 }
9728 }
9729 #endif
9731 /* do nothing */
9733 }
9743 }
9744 }
9745 }
9747 // g_print ("emit: %s (%p)\n", mono_burg_rule_string [ern], state);
9749 }
9751 #define DEBUG_SELECTION
9753 static void
9755 {
9765 /* we are careful when inverting, since bugs like #59580
9766 * could show up when dealing with NaNs.
9767 */
9779 }
9780 }
9781 }
9783 #ifdef DEBUG_SELECTION
9793 }
9794 }
9795 }
9796 #endif
9810 #ifdef DEBUG_SELECTION
9813 #endif
9816 #ifdef DEBUG_SELECTION
9820 }
9821 #endif
9828 }
9830 }
9838 }
9840 }
9842 void
9844 {
9852 /* we reuse dfn here */
9853 /* bb->dfn = bb_count++; */
9855 }
9870 /* emit code all basic blocks */
9882 }
9885 }
9886 }
9894 /* we always allocate code in cfg->domain->code_mp to increase locality */
9896 /* fixme: align to MONO_ARCH_CODE_ALIGNMENT */
9899 /* Allocate the code into a separate memory pool so it can be freed */
9911 }
9918 /* g_assert (((int)cfg->native_code & (MONO_ARCH_CODE_ALIGNMENT - 1)) == 0); */
9924 //printf ("TEST %s %p\n", info->name, patch_info->data.target);
9927 /*
9928 * This is an icall wrapper, and this is a call to the
9929 * wrapped function.
9930 */
9931 ;
9933 /* for these array methods we currently register the same function pointer
9934 * since it's a vararg function. But this means that mono_find_jit_icall_by_addr ()
9935 * will return the incorrect one depending on the order they are registered.
9936 * See tests/test-arr.cs
9937 */
9938 if (strstr (info->name, "ves_array_new_va_") == NULL && strstr (info->name, "ves_array_element_address_") == NULL) {
9941 }
9942 }
9943 }
9949 }
9950 }
9952 }
9956 table = mono_code_manager_reserve (cfg->dynamic_info->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
9959 table = mono_code_manager_reserve (cfg->domain->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
9961 }
9964 /* In the aot case, the patch already points to the correct location */
9968 }
9971 }
9973 /* do nothing */
9975 }
9976 }
9981 nm,
9982 cfg->native_code, cfg->native_code + cfg->code_len, cfg->code_len, cfg->domain->friendly_name);
9984 }
9986 #ifdef MONO_ARCH_HAVE_SAVE_UNWIND_INFO
9988 #endif
9990 mono_arch_patch_code (cfg->method, cfg->domain, cfg->native_code, cfg->patch_info, cfg->run_cctors);
9993 mono_code_manager_commit (cfg->dynamic_info->code_mp, cfg->native_code, cfg->code_size, cfg->code_len);
9996 mono_code_manager_commit (cfg->domain->code_mp, cfg->native_code, cfg->code_size, cfg->code_len);
9998 }
10003 }
10007 static void
10015 printf ("remove_critical_edges %s, BEFORE BB%d (in:", mono_method_full_name (cfg->method, TRUE), bb->block_num);
10018 }
10022 }
10027 }
10029 }
10030 }
10032 for (previous_bb = cfg->bb_entry, bb = previous_bb->next_bb; bb != NULL; previous_bb = previous_bb->next_bb, bb = bb->next_bb) {
10040 // new_bb->real_offset = bb->real_offset;
10043 /* Do not alter the CFG while altering the BB list */
10046 /* If previous_bb "followed through" to bb, */
10047 /* keep it linked with a CEE_BR */
10053 /* Make sure previous_bb really falls through bb */
10062 }
10063 }
10064 }
10066 /* We cannot add any inst to the entry BB, so we must */
10067 /* put a new BB in the middle to hold the CEE_BR */
10069 MonoBasicBlock *new_bb_after_entry = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
10071 // new_bb_after_entry->real_offset = bb->real_offset;
10083 printf ("remove_critical_edges %s, added helper BB%d jumping to BB%d\n", mono_method_full_name (cfg->method, TRUE), new_bb_after_entry->block_num, bb->block_num);
10084 }
10085 }
10086 }
10088 /* Insert new_bb in the BB list */
10093 /* Setup in_bb and out_bb */
10101 /* Relink in_bb and bb to (from) new_bb */
10107 printf ("remove_critical_edges %s, removed critical edge from BB%d to BB%d (added BB%d)\n", mono_method_full_name (cfg->method, TRUE), in_bb->block_num, bb->block_num, new_bb->block_num);
10108 }
10109 }
10110 }
10111 }
10112 }
10117 printf ("remove_critical_edges %s, AFTER BB%d (in:", mono_method_full_name (cfg->method, TRUE), bb->block_num);
10120 }
10124 }
10129 }
10131 }
10132 }
10133 }
10135 /*
10136 * mini_method_compile:
10137 * @method: the method to compile
10138 * @opts: the optimization flags to use
10139 * @domain: the domain where the method will be compiled in
10140 * @run_cctors: whether we should run type ctors if possible
10141 * @compile_aot: whether this is an AOT compilation
10142 * @parts: debug flag
10143 *
10144 * Returns: a MonoCompile* pointer. Caller must check the exception_type
10145 * field in the returned struct to see if compilation succeded.
10146 */
10147 MonoCompile*
10148 mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gboolean run_cctors, gboolean compile_aot, int parts)
10149 {
10174 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
10178 }
10182 cfg->intvars = mono_mempool_alloc0 (cfg->mempool, sizeof (guint16) * STACK_MAX * header->max_stack);
10188 /*
10189 * create MonoInst* which represents arguments and local variables
10190 */
10193 if ((i = mono_method_to_ir (cfg, method, NULL, NULL, cfg->locals_start, NULL, NULL, NULL, 0, FALSE)) < 0) {
10196 /* cfg contains the details of the failure, so let the caller cleanup */
10198 }
10204 /*
10205 * we disable some optimizations if there are too many variables
10206 * because JIT time may become too expensive. The actual number needs
10207 * to be tweaked and eventually the non-linear algorithms should be fixed.
10208 */
10211 }
10213 /*g_print ("numblocks = %d\n", cfg->num_bblocks);*/
10220 }
10222 /* Depth-first ordering on basic blocks */
10223 cfg->bblocks = mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * (cfg->num_bblocks + 1));
10232 /* remove unreachable code, because the code in them may be
10233 * inconsistent (access to dead variables for example) */
10244 }
10245 }
10246 }
10247 }
10252 }
10254 /* after method_to_ir */
10258 //#define DEBUGSSA "logic_run"
10260 #ifdef DEBUGSSA
10265 }
10266 #else
10268 /* fixme: add all optimizations which requires SSA */
10276 }
10277 }
10278 }
10279 #endif
10281 /* after SSA translation */
10290 }
10291 }
10294 //mono_ssa_deadce (cfg);
10296 //mono_ssa_strength_reduction (cfg);
10300 //mono_local_cprop (cfg);
10301 }
10306 }
10315 }
10317 /* after SSA removal */
10325 }
10334 /*
10335 * Allways allocate the GOT var to a register, because keeping it
10336 * in memory will increase the number of live temporaries in some
10337 * code created by inssel.brg, leading to the well known spills+
10338 * branches problem. Testcase: mcs crash in
10339 * System.MonoCustomAttrs:GetCustomAttributes.
10340 */
10348 }
10353 /* For now, compute aliasing info only if needed for deadce... */
10356 }
10358 /* fixme: maybe we can avoid to compute livenesss here if already computed ? */
10366 }
10373 }
10378 }
10379 }
10381 //mono_print_code (cfg);
10383 //print_dfn (cfg);
10385 /* variables are allocated after decompose, since decompose could create temps */
10398 }
10401 jinfo = g_malloc0 (sizeof (MonoJitInfo) + (header->num_clauses * sizeof (MonoJitExceptionInfo)));
10403 /* we access cfg->domain->mp */
10405 jinfo = mono_mempool_alloc0 (cfg->domain->mp, sizeof (MonoJitInfo) + (header->num_clauses * sizeof (MonoJitExceptionInfo)));
10407 }
10414 jinfo->cas_inited = FALSE; /* initialization delayed at the first stalk walk using this method */
10438 }
10451 }
10452 }
10455 #if defined(__arm__)
10457 #endif
10466 /* collect statistics */
10472 }
10477 }
10484 }
10486 static gpointer
10488 {
10498 #ifdef MONO_USE_AOT_COMPILER
10509 }
10512 }
10513 #endif
10521 g_error ("Method '%s' in assembly '%s' contains native code and mono can't run it. The assembly was probably created by Managed C++.\n", mono_method_full_name (method, TRUE), method->klass->image->name);
10526 else
10529 }
10533 //if (mono_debug_format != MONO_DEBUG_FORMAT_NONE)
10534 //mono_debug_add_wrapper (method, nm);
10553 }
10554 }
10556 }
10565 /* Throw a type load exception if needed */
10577 }
10579 }
10580 }
10582 MonoException *ex = mono_exception_from_name_msg (mono_defaults.corlib, "System", "InvalidProgramException", cfg->exception_message);
10586 }
10588 MonoException *ex = mono_exception_from_name_msg (mono_defaults.corlib, "System.Security", "VerificationException", cfg->exception_message);
10592 }
10593 /* this can only be set if the security manager is active */
10596 MonoReflectionAssembly *refass = (MonoReflectionAssembly*) mono_assembly_get_object (target_domain, assembly);
10611 }
10614 }
10618 /* Check if some other thread already did the job. In this case, we can
10619 discard the code this thread generated. */
10622 /* We can't use a domain specific method in another domain */
10625 // printf("Discarding code for method %s\n", method->name);
10626 }
10627 }
10632 }
10637 MonoJumpInfo patch_info;
10646 }
10650 }
10656 }
10658 static gpointer
10660 {
10663 gpointer p;
10666 /*
10667 * ICALL wrappers are handled specially, since there is only one copy of them
10668 * shared by all appdomains.
10669 */
10670 if ((method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
10678 /* Must be domain neutral since there is only one copy */
10680 }
10684 else
10690 /* We can't use a domain specific method in another domain */
10696 }
10697 }
10700 p = mono_create_ftnptr (target_domain, mono_jit_compile_method_inner (method, target_domain, opt));
10708 }
10710 }
10713 }
10715 static gpointer
10717 {
10719 }
10721 static void
10723 {
10726 desc);
10727 }
10729 /*
10730 * mono_jit_free_method:
10731 *
10732 * Free all memory allocated by the JIT for METHOD.
10733 */
10734 static void
10736 {
10754 #ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD
10756 /*
10757 * Instead of freeing the code, change it to call an error routine
10758 * so people can fix their code.
10759 */
10766 }
10767 #endif
10769 /*
10770 * This needs to be done before freeing code_mp, since the code address is the
10771 * key in the table, so if we the code_mp first, another thread can grab the
10772 * same code address and replace our entry in the table.
10773 */
10780 }
10782 static gpointer
10784 {
10790 else
10796 /* We can't use a domain specific method in another domain */
10801 }
10802 }
10807 }
10809 /**
10810 * mono_jit_runtime_invoke:
10811 * @method: the method to invoke
10812 * @obj: this pointer
10813 * @params: array of parameter values.
10814 * @exc: used to catch exceptions objects
10815 */
10818 {
10820 MonoObject *(*runtime_invoke) (MonoObject *this, void **params, MonoObject **exc, void* compiled_method);
10823 if (obj == NULL && !(method->flags & METHOD_ATTRIBUTE_STATIC) && !method->string_ctor && (method->wrapper_type == 0)) {
10826 }
10832 /* We need this here becuase mono_marshal_get_runtime_invoke can be place
10833 * the helper method in System.Object and not the target class
10834 */
10839 }
10841 #ifdef PLATFORM_WIN32
10842 #define GET_CONTEXT \
10843 struct sigcontext *ctx = (struct sigcontext*)_dummy;
10844 #else
10845 #ifdef MONO_ARCH_USE_SIGACTION
10846 #define GET_CONTEXT \
10847 void *ctx = context;
10848 #elif defined(__sparc__)
10849 #define GET_CONTEXT \
10850 void *ctx = sigctx;
10851 #else
10852 #define GET_CONTEXT \
10853 void **_p = (void **)&_dummy; \
10854 struct sigcontext *ctx = (struct sigcontext *)++_p;
10855 #endif
10856 #endif
10858 #ifdef MONO_ARCH_USE_SIGACTION
10859 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, siginfo_t *info, void *context)
10860 #elif defined(__sparc__)
10861 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, void *sigctx)
10862 #else
10863 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy)
10864 #endif
10866 static void
10868 {
10870 #ifndef MONO_ARCH_USE_SIGACTION
10872 #endif
10873 GET_CONTEXT;
10875 #if defined(MONO_ARCH_HAVE_IS_INT_OVERFLOW)
10878 else
10880 #else
10882 #endif
10885 }
10887 static void
10889 {
10891 GET_CONTEXT;
10896 }
10898 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
10900 #ifndef MONO_ARCH_USE_SIGACTION
10902 #endif
10904 #endif
10906 static void
10908 {
10912 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
10914 #endif
10915 GET_CONTEXT;
10917 #ifdef MONO_ARCH_USE_SIGACTION
10922 }
10926 }
10927 }
10928 #endif
10930 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
10931 /* Can't allocate memory using Boehm GC on altstack */
10936 else
10938 #endif
10943 }
10946 }
10948 static void
10950 {
10952 GET_CONTEXT;
10957 }
10958 }
10960 static void
10962 {
10963 gboolean running_managed;
10968 GET_CONTEXT;
10974 }
10976 /*
10977 * FIXME:
10978 * This is an async signal, so the code below must not call anything which
10979 * is not async safe. That includes the pthread locking functions. If we
10980 * know that we interrupted managed code, then locking is safe.
10981 */
10989 }
10991 static void
10993 {
10994 GET_CONTEXT;
10997 }
10999 static void
11001 {
11002 GET_CONTEXT;
11008 /*
11009 * print_thread_dump () skips the current thread, since sending a signal
11010 * to it would invoke the signal handler below the sigquit signal handler,
11011 * and signal handlers don't create an lmf, so the stack walk could not
11012 * be performed.
11013 */
11015 }
11017 static void
11019 {
11021 GET_CONTEXT;
11026 }
11028 static void
11030 {
11034 }
11036 #ifdef PLATFORM_MACOSX
11038 /*
11039 * This code disables the CrashReporter of MacOS X by installing
11040 * a dummy Mach exception handler.
11041 */
11043 /*
11044 * http://darwinsource.opendarwin.org/10.4.3/xnu-792.6.22/osfmk/man/exc_server.html
11045 */
11046 extern
11047 boolean_t
11051 /*
11052 * The exception message
11053 */
11059 /* The exception port */
11062 /*
11063 * Implicitly called by exc_server. Must be public.
11064 *
11065 * http://darwinsource.opendarwin.org/10.4.3/xnu-792.6.22/osfmk/man/catch_exception_raise.html
11066 */
11067 kern_return_t
11069 mach_port_t exception_port,
11070 mach_port_t thread,
11071 mach_port_t task,
11072 exception_type_t exception,
11073 exception_data_t code,
11074 mach_msg_type_number_t code_count)
11075 {
11076 /* consume the exception */
11078 }
11080 /*
11081 * Exception thread handler.
11082 */
11083 static
11086 {
11088 mach_exception_msg_t request;
11089 mach_exception_msg_t reply;
11090 mach_msg_return_t result;
11092 /* receive from "mach_exception_port" */
11097 mach_exception_port,
11098 MACH_MSG_TIMEOUT_NONE,
11099 MACH_PORT_NULL);
11103 /* dispatch to catch_exception_raise () */
11106 /* send back to sender */
11108 MACH_SEND_MSG,
11111 MACH_PORT_NULL,
11112 MACH_MSG_TIMEOUT_NONE,
11113 MACH_PORT_NULL);
11116 }
11118 }
11120 static void
11122 {
11123 mach_port_t task;
11124 pthread_attr_t attr;
11125 pthread_t thread;
11132 /* create the "mach_exception_port" with send & receive rights */
11138 /* create the exception handler thread */
11144 /*
11145 * register "mach_exception_port" as a receiver for the
11146 * EXC_BAD_ACCESS exception
11147 *
11148 * http://darwinsource.opendarwin.org/10.4.3/xnu-792.6.22/osfmk/man/task_set_exception_ports.html
11149 */
11151 mach_exception_port,
11152 EXCEPTION_DEFAULT,
11154 }
11155 #endif
11157 #ifndef PLATFORM_WIN32
11158 static void
11160 {
11163 #ifdef MONO_ARCH_USE_SIGACTION
11167 #else
11171 #endif
11173 }
11175 static void
11177 {
11185 }
11186 #endif
11188 static void
11190 {
11191 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
11193 #endif
11195 #ifdef PLATFORM_WIN32
11206 #ifdef PLATFORM_MACOSX
11208 #endif
11225 /* catch SIGSEGV */
11226 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
11231 #else
11233 #endif
11235 }
11237 static void
11239 {
11240 #ifdef PLATFORM_WIN32
11242 #else
11259 }
11262 #ifdef HAVE_LINUX_RTC_H
11263 #include <linux/rtc.h>
11264 #include <sys/ioctl.h>
11265 #include <fcntl.h>
11268 static int
11270 {
11276 }
11279 else
11284 }
11286 }
11287 #endif
11289 static void
11291 {
11292 #ifdef ITIMER_PROF
11295 #ifdef HAVE_LINUX_RTC_H
11308 }
11313 }
11317 }
11321 }
11325 }
11328 }
11331 #endif
11341 #endif
11342 }
11344 /* mono_jit_create_remoting_trampoline:
11345 * @method: pointer to the method info
11346 *
11347 * Creates a trampoline which calls the remoting functions. This
11348 * is used in the vtable of transparent proxies.
11349 *
11350 * Returns: a pointer to the newly created code
11351 */
11352 static gpointer
11354 {
11359 (mono_method_signature (method)->hasthis && (method->klass->marshalbyref || method->klass == mono_defaults.object_class))) {
11364 }
11366 }
11368 static void
11370 {
11392 fprintf (stderr, "Available options: 'handle-sigint', 'keep-delegates', 'collect-pagefault-stats', 'break-on-unverified'\n");
11394 }
11395 }
11396 }
11398 MonoDomain *
11400 {
11403 #ifdef __linux__
11407 }
11408 #endif
11410 /* Happens when using the embedding interface */
11431 /*
11432 * Handle the case when we are called from a thread different from the main thread,
11433 * confusing libgc.
11434 * FIXME: Move this to libgc where it belongs.
11435 *
11436 * we used to do this only when running on valgrind,
11437 * but it happens also in other setups.
11438 */
11439 #if defined(HAVE_BOEHM_GC)
11440 #if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK)
11441 {
11444 pthread_attr_t attr;
11448 /*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
11449 #ifdef __ia64__
11450 /*
11451 * The calculation above doesn't seem to work on ia64, also we need to set
11452 * GC_register_stackbottom as well, but don't know how.
11453 */
11454 #else
11455 /* apparently with some linuxthreads implementations sstart can be NULL,
11456 * fallback to the more imprecise method (bug# 78096).
11457 */
11465 }
11466 #endif
11467 }
11468 #elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
11470 #else
11471 {
11475 /*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
11477 }
11478 #endif
11479 #endif
11493 #define JIT_TRAMPOLINES_WORK
11494 #ifdef JIT_TRAMPOLINES_WORK
11500 #endif
11501 #define JIT_INVOKE_WORKS
11502 #ifdef JIT_INVOKE_WORKS
11505 #endif
11515 }
11521 ves_icall_get_frame_info);
11523 ves_icall_get_trace);
11525 ves_icall_System_Exception_get_trace);
11527 ves_icall_System_Security_SecurityFrame_GetSecurityFrame);
11529 ves_icall_System_Security_SecurityFrame_GetSecurityStack);
11531 mono_runtime_install_handlers);
11536 #define JIT_CALLS_WORK
11537 #ifdef JIT_CALLS_WORK
11538 /* Needs to be called here since register_jit_icall depends on it */
11550 register_icall (mono_arch_get_throw_exception (), "mono_arch_throw_exception", "void object", TRUE);
11551 register_icall (mono_arch_get_rethrow_exception (), "mono_arch_rethrow_exception", "void object", TRUE);
11552 register_icall (mono_arch_get_throw_exception_by_name (), "mono_arch_throw_exception_by_name", "void ptr", TRUE);
11553 #if MONO_ARCH_HAVE_THROW_CORLIB_EXCEPTION
11556 #endif
11557 register_icall (mono_thread_get_pending_exception, "mono_thread_get_pending_exception", "object", FALSE);
11558 register_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", "void", FALSE);
11559 register_icall (mono_thread_force_interruption_checkpoint, "mono_thread_force_interruption_checkpoint", "void", FALSE);
11560 register_icall (mono_load_remote_field_new, "mono_load_remote_field_new", "object object ptr ptr", FALSE);
11561 register_icall (mono_store_remote_field_new, "mono_store_remote_field_new", "void object ptr ptr object", FALSE);
11563 /*
11564 * NOTE, NOTE, NOTE, NOTE:
11565 * when adding emulation for some opcodes, remember to also add a dummy
11566 * rule to the burg files, because we need the arity information to be correct.
11567 */
11568 #ifndef MONO_ARCH_NO_EMULATE_LONG_MUL_OPTS
11571 mono_register_opcode_emulation (OP_LDIV_UN, "__emul_ldiv_un", "long long long", mono_lldiv_un, FALSE);
11573 mono_register_opcode_emulation (OP_LREM_UN, "__emul_lrem_un", "long long long", mono_llrem_un, FALSE);
11574 mono_register_opcode_emulation (OP_LMUL_OVF_UN, "__emul_lmul_ovf_un", "long long long", mono_llmult_ovf_un, FALSE);
11575 mono_register_opcode_emulation (OP_LMUL_OVF, "__emul_lmul_ovf", "long long long", mono_llmult_ovf, FALSE);
11576 #endif
11578 #ifndef MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS
11581 mono_register_opcode_emulation (OP_LSHR_UN, "__emul_lshr_un", "long long int32", mono_lshr_un, TRUE);
11582 #endif
11584 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
11585 mono_register_opcode_emulation (CEE_DIV, "__emul_idiv", "int32 int32 int32", mono_idiv, FALSE);
11586 mono_register_opcode_emulation (CEE_DIV_UN, "__emul_idiv_un", "int32 int32 int32", mono_idiv_un, FALSE);
11587 mono_register_opcode_emulation (CEE_REM, "__emul_irem", "int32 int32 int32", mono_irem, FALSE);
11588 mono_register_opcode_emulation (CEE_REM_UN, "__emul_irem_un", "int32 int32 int32", mono_irem_un, FALSE);
11589 #endif
11591 #ifdef MONO_ARCH_EMULATE_MUL_DIV
11592 mono_register_opcode_emulation (CEE_MUL_OVF, "__emul_imul_ovf", "int32 int32 int32", mono_imul_ovf, FALSE);
11593 mono_register_opcode_emulation (CEE_MUL_OVF_UN, "__emul_imul_ovf_un", "int32 int32 int32", mono_imul_ovf_un, FALSE);
11594 mono_register_opcode_emulation (CEE_MUL, "__emul_imul", "int32 int32 int32", mono_imul, TRUE);
11595 #endif
11596 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_SOFT_FLOAT)
11597 mono_register_opcode_emulation (OP_FDIV, "__emul_fdiv", "double double double", mono_fdiv, FALSE);
11598 #endif
11600 mono_register_opcode_emulation (OP_FCONV_TO_U8, "__emul_fconv_to_u8", "ulong double", mono_fconv_u8, FALSE);
11601 mono_register_opcode_emulation (OP_FCONV_TO_U4, "__emul_fconv_to_u4", "uint32 double", mono_fconv_u4, FALSE);
11602 mono_register_opcode_emulation (OP_FCONV_TO_OVF_I8, "__emul_fconv_to_ovf_i8", "long double", mono_fconv_ovf_i8, FALSE);
11603 mono_register_opcode_emulation (OP_FCONV_TO_OVF_U8, "__emul_fconv_to_ovf_u8", "ulong double", mono_fconv_ovf_u8, FALSE);
11605 #ifdef MONO_ARCH_EMULATE_FCONV_TO_I8
11606 mono_register_opcode_emulation (OP_FCONV_TO_I8, "__emul_fconv_to_i8", "long double", mono_fconv_i8, FALSE);
11607 #endif
11608 #ifdef MONO_ARCH_EMULATE_CONV_R8_UN
11609 mono_register_opcode_emulation (CEE_CONV_R_UN, "__emul_conv_r_un", "double int32", mono_conv_to_r8_un, FALSE);
11610 #endif
11611 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R8
11612 mono_register_opcode_emulation (OP_LCONV_TO_R8, "__emul_lconv_to_r8", "double long", mono_lconv_to_r8, FALSE);
11613 #endif
11614 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R4
11615 mono_register_opcode_emulation (OP_LCONV_TO_R4, "__emul_lconv_to_r4", "float long", mono_lconv_to_r4, FALSE);
11616 #endif
11617 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R8_UN
11618 mono_register_opcode_emulation (OP_LCONV_TO_R_UN, "__emul_lconv_to_r8_un", "double long", mono_lconv_to_r8_un, FALSE);
11619 #endif
11620 #ifdef MONO_ARCH_EMULATE_FREM
11622 #endif
11624 #ifdef MONO_ARCH_SOFT_FLOAT
11625 mono_register_opcode_emulation (OP_FSUB, "__emul_fsub", "double double double", mono_fsub, FALSE);
11626 mono_register_opcode_emulation (OP_FADD, "__emul_fadd", "double double double", mono_fadd, FALSE);
11627 mono_register_opcode_emulation (OP_FMUL, "__emul_fmul", "double double double", mono_fmul, FALSE);
11629 mono_register_opcode_emulation (CEE_CONV_R8, "__emul_conv_r8", "double int32", mono_conv_to_r8, FALSE);
11630 mono_register_opcode_emulation (OP_FCONV_TO_R4, "__emul_fconv_to_r4", "double double", mono_fconv_r4, FALSE);
11631 mono_register_opcode_emulation (OP_FCONV_TO_I1, "__emul_fconv_to_i1", "int8 double", mono_fconv_i1, FALSE);
11632 mono_register_opcode_emulation (OP_FCONV_TO_I2, "__emul_fconv_to_i2", "int16 double", mono_fconv_i2, FALSE);
11633 mono_register_opcode_emulation (OP_FCONV_TO_I4, "__emul_fconv_to_i4", "int32 double", mono_fconv_i4, FALSE);
11634 mono_register_opcode_emulation (OP_FCONV_TO_U1, "__emul_fconv_to_u1", "uint8 double", mono_fconv_u1, FALSE);
11635 mono_register_opcode_emulation (OP_FCONV_TO_U2, "__emul_fconv_to_u2", "uint16 double", mono_fconv_u2, FALSE);
11637 mono_register_opcode_emulation (OP_FBEQ, "__emul_fcmp_eq", "uint32 double double", mono_fcmp_eq, FALSE);
11638 mono_register_opcode_emulation (OP_FBLT, "__emul_fcmp_lt", "uint32 double double", mono_fcmp_lt, FALSE);
11639 mono_register_opcode_emulation (OP_FBGT, "__emul_fcmp_gt", "uint32 double double", mono_fcmp_gt, FALSE);
11640 mono_register_opcode_emulation (OP_FBLE, "__emul_fcmp_le", "uint32 double double", mono_fcmp_le, FALSE);
11641 mono_register_opcode_emulation (OP_FBGE, "__emul_fcmp_ge", "uint32 double double", mono_fcmp_ge, FALSE);
11642 mono_register_opcode_emulation (OP_FBNE_UN, "__emul_fcmp_ne_un", "uint32 double double", mono_fcmp_ne_un, FALSE);
11643 mono_register_opcode_emulation (OP_FBLT_UN, "__emul_fcmp_lt_un", "uint32 double double", mono_fcmp_lt_un, FALSE);
11644 mono_register_opcode_emulation (OP_FBGT_UN, "__emul_fcmp_gt_un", "uint32 double double", mono_fcmp_gt_un, FALSE);
11645 mono_register_opcode_emulation (OP_FBLE_UN, "__emul_fcmp_le_un", "uint32 double double", mono_fcmp_le_un, FALSE);
11646 mono_register_opcode_emulation (OP_FBGE_UN, "__emul_fcmp_ge_un", "uint32 double double", mono_fcmp_ge_un, FALSE);
11648 mono_register_opcode_emulation (OP_FCEQ, "__emul_fcmp_ceq", "uint32 double double", mono_fceq, FALSE);
11649 mono_register_opcode_emulation (OP_FCGT, "__emul_fcmp_cgt", "uint32 double double", mono_fcgt, FALSE);
11650 mono_register_opcode_emulation (OP_FCGT_UN, "__emul_fcmp_cgt_un", "uint32 double double", mono_fcgt_un, FALSE);
11651 mono_register_opcode_emulation (OP_FCLT, "__emul_fcmp_clt", "uint32 double double", mono_fclt, FALSE);
11652 mono_register_opcode_emulation (OP_FCLT_UN, "__emul_fcmp_clt_un", "uint32 double double", mono_fclt_un, FALSE);
11656 #endif
11658 #if SIZEOF_VOID_P == 4
11659 mono_register_opcode_emulation (OP_FCONV_TO_U, "__emul_fconv_to_u", "uint32 double", mono_fconv_u4, TRUE);
11660 #endif
11662 /* other jit icalls */
11667 register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", FALSE);
11669 register_icall (mono_helper_stelem_ref_check, "helper_stelem_ref_check", "void object object", FALSE);
11673 register_icall (mono_array_new_specific, "mono_array_new_specific", "object ptr int32", FALSE);
11678 register_icall (mono_helper_compile_generic_method, "compile_generic_method", "ptr object ptr ptr ptr", FALSE);
11683 #endif
11685 #define JIT_RUNTIME_WORKS
11686 #ifdef JIT_RUNTIME_WORKS
11689 #endif
11693 }
11697 static void
11699 {
11728 g_print ("Mscorlib mempool size: %d\n", mono_mempool_get_allocated (mono_defaults.corlib->mempool));
11744 }
11748 }
11749 }
11750 }
11752 void
11754 {
11755 #ifdef HAVE_LINUX_RTC_H
11758 #endif
11760 /*
11761 * mono_runtime_cleanup() and mono_domain_finalize () need to
11762 * be called early since they need the execution engine still
11763 * fully working (mono_domain_finalize may invoke managed finalizers
11764 * and mono_runtime_cleanup will wait for other threads to finish).
11765 */
11768 /* This accesses metadata so needs to be called before runtime shutdown */
11800 }
11802 void
11804 {
11808 }
11810 static void
11812 {
11831 count++;
11836 }
11841 }
11845 }
11846 }
11848 /* Load and precompile referenced assemblies as well */
11853 }
11854 }
11857 {
11863 }