| blob | faeb658ef8c18a8e41f16f248940717f82b3c947 |
1 /*
2 * method-to-ir.c: Convert CIL to the JIT internal representation
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002 Ximian, Inc.
9 * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
10 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
11 */
13 #include <config.h>
15 #ifndef DISABLE_JIT
17 #include <signal.h>
19 #ifdef HAVE_UNISTD_H
20 #include <unistd.h>
21 #endif
23 #include <math.h>
24 #include <string.h>
25 #include <ctype.h>
27 #ifdef HAVE_SYS_TIME_H
28 #include <sys/time.h>
29 #endif
31 #ifdef HAVE_ALLOCA_H
32 #include <alloca.h>
33 #endif
35 #include <mono/utils/memcheck.h>
37 #include <mono/metadata/abi-details.h>
38 #include <mono/metadata/assembly.h>
39 #include <mono/metadata/attrdefs.h>
40 #include <mono/metadata/loader.h>
41 #include <mono/metadata/tabledefs.h>
42 #include <mono/metadata/class.h>
43 #include <mono/metadata/object.h>
44 #include <mono/metadata/exception.h>
45 #include <mono/metadata/opcodes.h>
46 #include <mono/metadata/mono-endian.h>
47 #include <mono/metadata/tokentype.h>
48 #include <mono/metadata/tabledefs.h>
49 #include <mono/metadata/marshal.h>
50 #include <mono/metadata/debug-helpers.h>
51 #include <mono/metadata/mono-debug.h>
52 #include <mono/metadata/gc-internal.h>
53 #include <mono/metadata/security-manager.h>
54 #include <mono/metadata/threads-types.h>
55 #include <mono/metadata/security-core-clr.h>
56 #include <mono/metadata/monitor.h>
57 #include <mono/metadata/profiler-private.h>
58 #include <mono/metadata/profiler.h>
59 #include <mono/metadata/debug-mono-symfile.h>
60 #include <mono/utils/mono-compiler.h>
61 #include <mono/utils/mono-memory-model.h>
62 #include <mono/metadata/mono-basic-block.h>
72 #define BRANCH_COST 10
73 #define INLINE_LENGTH_LIMIT 20
74 #define INLINE_FAILURE(msg) do { \
75 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) { \
76 if (cfg->verbose_level >= 2) \
78 goto inline_failure; \
79 } \
80 } while (0)
81 #define CHECK_CFG_EXCEPTION do {\
82 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
83 goto exception_exit;\
84 } while (0)
85 #define METHOD_ACCESS_FAILURE do { \
86 char *method_fname = mono_method_full_name (method, TRUE); \
87 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
88 mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); \
89 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
90 g_free (method_fname); \
91 g_free (cil_method_fname); \
92 goto exception_exit; \
93 } while (0)
94 #define FIELD_ACCESS_FAILURE do { \
95 char *method_fname = mono_method_full_name (method, TRUE); \
96 char *field_fname = mono_field_full_name (field); \
97 mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); \
98 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
99 g_free (method_fname); \
100 g_free (field_fname); \
101 goto exception_exit; \
102 } while (0)
103 #define GENERIC_SHARING_FAILURE(opcode) do { \
104 if (cfg->generic_sharing_context) { \
105 if (cfg->verbose_level > 2) \
106 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((opcode)), __LINE__); \
107 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
108 goto exception_exit; \
109 } \
110 } while (0)
111 #define GSHAREDVT_FAILURE(opcode) do { \
112 if (cfg->gsharedvt) { \
113 cfg->exception_message = g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((opcode)), __FILE__, __LINE__); \
114 if (cfg->verbose_level >= 2) \
116 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
117 goto exception_exit; \
118 } \
119 } while (0)
120 #define OUT_OF_MEMORY_FAILURE do { \
121 mono_cfg_set_exception (cfg, MONO_EXCEPTION_OUT_OF_MEMORY); \
122 goto exception_exit; \
123 } while (0)
124 #define DISABLE_AOT(cfg) do { \
125 if ((cfg)->verbose_level >= 2) \
127 (cfg)->disable_aot = TRUE; \
128 } while (0)
130 /* Determine whenever 'ins' represents a load of the 'this' argument */
131 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
139 MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
141 /* helper methods signatures */
150 /*
151 * Instruction metadata
152 */
153 #ifdef MINI_OP
154 #undef MINI_OP
155 #endif
156 #ifdef MINI_OP3
157 #undef MINI_OP3
158 #endif
160 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
166 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == SIZEOF_VOID_P
167 #define LREG IREG
168 #else
170 #endif
171 /* keep in sync with the enum in mini.h */
172 const char
173 ins_info[] = {
175 };
176 #undef MINI_OP
177 #undef MINI_OP3
179 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
180 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
181 /*
182 * This should contain the index of the last sreg + 1. This is not the same
183 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
184 */
187 };
188 #undef MINI_OP
189 #undef MINI_OP3
191 #define MONO_INIT_VARINFO(vi,id) do { \
192 (vi)->range.first_use.pos.bid = 0xffff; \
193 (vi)->reg = -1; \
194 (vi)->idx = (id); \
195 } while (0)
197 void
199 {
203 }
205 guint32
207 {
209 }
211 guint32
213 {
215 }
217 guint32
219 {
221 }
223 guint32
225 {
227 }
229 guint32
231 {
233 }
235 /*
236 * mono_alloc_ireg_ref:
237 *
238 * Allocate an IREG, and mark it as holding a GC ref.
239 */
240 guint32
242 {
244 }
246 /*
247 * mono_alloc_ireg_mp:
248 *
249 * Allocate an IREG, and mark it as holding a managed pointer.
250 */
251 guint32
253 {
255 }
257 /*
258 * mono_alloc_ireg_copy:
259 *
260 * Allocate an IREG with the same GC type as VREG.
261 */
262 guint32
264 {
269 else
271 }
273 guint
275 {
280 handle_enum:
306 #if SIZEOF_REGISTER == 8
308 #else
310 #endif
319 }
333 else
337 }
339 }
341 void
343 {
356 }
358 void
360 {
368 }
370 /*
371 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
372 * foo<T> (int i) { ldarg.0; box T; }
373 */
374 #define UNVERIFIED do { \
375 if (cfg->gsharedvt) { \
376 if (cfg->verbose_level > 2) \
378 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
379 goto exception_exit; \
380 } \
381 if (mini_get_debug_options ()->break_on_unverified) \
382 G_BREAKPOINT (); \
383 else \
384 goto unverified; \
385 } while (0)
387 #define LOAD_ERROR do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto load_error; } while (0)
389 #define TYPE_LOAD_ERROR(klass) do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else { cfg->exception_ptr = klass; goto load_error; } } while (0)
391 #define GET_BBLOCK(cfg,tblock,ip) do { \
392 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
393 if (!(tblock)) { \
394 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
395 NEW_BBLOCK (cfg, (tblock)); \
396 (tblock)->cil_code = (ip); \
397 ADD_BBLOCK (cfg, (tblock)); \
398 } \
399 } while (0)
401 #if defined(TARGET_X86) || defined(TARGET_AMD64)
402 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
403 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
404 (dest)->dreg = alloc_ireg_mp ((cfg)); \
405 (dest)->sreg1 = (sr1); \
406 (dest)->sreg2 = (sr2); \
407 (dest)->inst_imm = (imm); \
408 (dest)->backend.shift_amount = (shift); \
409 MONO_ADD_INS ((cfg)->cbb, (dest)); \
410 } while (0)
411 #endif
413 #if SIZEOF_REGISTER == 8
414 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
416 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
417 MonoInst *widen; \
418 int dr = alloc_preg (cfg); \
419 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
420 (ins)->sreg2 = widen->dreg; \
421 } \
422 } while (0)
423 #else
424 #define ADD_WIDEN_OP(ins, arg1, arg2)
425 #endif
427 #define ADD_BINOP(op) do { \
428 MONO_INST_NEW (cfg, ins, (op)); \
429 sp -= 2; \
430 ins->sreg1 = sp [0]->dreg; \
431 ins->sreg2 = sp [1]->dreg; \
432 type_from_op (ins, sp [0], sp [1]); \
433 CHECK_TYPE (ins); \
435 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
436 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
437 MONO_ADD_INS ((cfg)->cbb, (ins)); \
438 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
439 } while (0)
441 #define ADD_UNOP(op) do { \
442 MONO_INST_NEW (cfg, ins, (op)); \
443 sp--; \
444 ins->sreg1 = sp [0]->dreg; \
445 type_from_op (ins, sp [0], NULL); \
446 CHECK_TYPE (ins); \
447 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
448 MONO_ADD_INS ((cfg)->cbb, (ins)); \
449 *sp++ = mono_decompose_opcode (cfg, ins); \
450 } while (0)
452 #define ADD_BINCOND(next_block) do { \
453 MonoInst *cmp; \
454 sp -= 2; \
455 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
456 cmp->sreg1 = sp [0]->dreg; \
457 cmp->sreg2 = sp [1]->dreg; \
458 type_from_op (cmp, sp [0], sp [1]); \
459 CHECK_TYPE (cmp); \
460 type_from_op (ins, sp [0], sp [1]); \
461 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
462 GET_BBLOCK (cfg, tblock, target); \
463 link_bblock (cfg, bblock, tblock); \
464 ins->inst_true_bb = tblock; \
465 if ((next_block)) { \
466 link_bblock (cfg, bblock, (next_block)); \
467 ins->inst_false_bb = (next_block); \
468 start_new_bblock = 1; \
469 } else { \
470 GET_BBLOCK (cfg, tblock, ip); \
471 link_bblock (cfg, bblock, tblock); \
472 ins->inst_false_bb = tblock; \
473 start_new_bblock = 2; \
474 } \
475 if (sp != stack_start) { \
476 handle_stack_args (cfg, stack_start, sp - stack_start); \
477 CHECK_UNVERIFIABLE (cfg); \
478 } \
479 MONO_ADD_INS (bblock, cmp); \
480 MONO_ADD_INS (bblock, ins); \
481 } while (0)
483 /* *
484 * link_bblock: Links two basic blocks
485 *
486 * links two basic blocks in the control flow graph, the 'from'
487 * argument is the starting block and the 'to' argument is the block
488 * the control flow ends to after 'from'.
489 */
490 static void
492 {
496 #if 0
499 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
500 else
505 else
507 }
508 #endif
515 }
516 }
521 }
525 }
532 }
533 }
538 }
542 }
543 }
545 void
547 {
549 }
551 /**
552 * mono_find_block_region:
553 *
554 * We mark each basic block with a region ID. We use that to avoid BB
555 * optimizations when blocks are in different regions.
556 *
557 * Returns:
558 * A region token that encodes where this region is, and information
559 * about the clause owner for this block.
560 *
561 * The region encodes the try/catch/filter clause that owns this block
562 * as well as the type. -1 is a special value that represents a block
563 * that is in none of try/catch/filter.
564 */
565 static int
567 {
574 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
583 else
585 }
589 }
592 }
596 {
608 }
609 }
611 }
613 static void
615 {
623 /* prevent it from being register allocated */
627 }
629 MonoInst *
631 {
633 }
637 {
645 /* prevent it from being register allocated */
651 }
653 /*
654 * Returns the type used in the eval stack when @type is loaded.
655 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
656 */
657 void
659 {
667 }
669 handle_enum:
713 }
729 }
733 }
734 }
736 /*
737 * The following tables are used to quickly validate the IL code in type_from_op ().
738 */
739 static const char
749 };
751 static const char
752 neg_table [] = {
754 };
756 /* reduce the size of this table */
757 static const char
767 };
769 static const char
771 /* Inv i L p F & O vt */
780 };
782 /* reduce the size of this table */
783 static const char
793 };
795 /*
796 * Tables to map from the non-specific opcode to the matching
797 * type-specific opcode.
798 */
799 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
800 static const guint16
803 };
805 /* handles from CEE_NEG to CEE_CONV_U8 */
806 static const guint16
809 };
811 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
812 static const guint16
814 0, OP_ICONV_TO_U2-CEE_CONV_U2, 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
815 };
817 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
818 static const guint16
820 0, OP_ICONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, 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
821 };
823 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
824 static const guint16
826 0, OP_ICONV_TO_OVF_I1-CEE_CONV_OVF_I1, 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
827 };
829 /* handles from CEE_BEQ to CEE_BLT_UN */
830 static const guint16
832 0, OP_IBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ, OP_FBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ
833 };
835 /* handles from CEE_CEQ to CEE_CLT_UN */
836 static const guint16
838 0, OP_ICEQ-OP_CEQ, OP_LCEQ-OP_CEQ, OP_PCEQ-OP_CEQ, OP_FCEQ-OP_CEQ, OP_PCEQ-OP_CEQ, OP_PCEQ-OP_CEQ
839 };
841 /*
842 * Sets ins->type (the type on the eval stack) according to the
843 * type of the opcode and the arguments to it.
844 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
845 *
846 * FIXME: this function sets ins->type unconditionally in some cases, but
847 * it should set it to invalid for some types (a conv.x on an object)
848 */
849 static void
853 /* binops */
859 /* FIXME: check unverifiable args for STACK_MP */
881 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
885 else
890 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
916 /* unops */
924 else
945 }
978 #if SIZEOF_VOID_P == 8
980 #else
982 #endif
990 }
1058 }
1062 }
1064 static const char
1065 ldind_type [] = {
1066 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1067 };
1069 #if 0
1071 static const char
1074 };
1076 static int
1088 }
1089 args++;
1090 }
1111 }
1124 }
1125 /*if (!param_table [args [i].type] [sig->params [i]->type])
1126 return 0;*/
1127 }
1129 }
1130 #endif
1132 /*
1133 * When we need a pointer to the current domain many times in a method, we
1134 * call mono_domain_get() once and we store the result in a local variable.
1135 * This function returns the variable that represents the MonoDomain*.
1136 */
1139 {
1143 }
1145 /*
1146 * The got_var contains the address of the Global Offset Table when AOT
1147 * compiling.
1148 */
1149 MonoInst *
1151 {
1152 #ifdef MONO_ARCH_NEED_GOT_VAR
1157 }
1159 #else
1161 #endif
1162 }
1166 {
1171 /* force the var to be stack allocated */
1173 }
1176 }
1191 }
1193 }
1197 {
1232 else
1237 }
1240 }
1244 {
1278 }
1280 }
1282 /*
1283 * We try to share variables when possible
1284 */
1287 {
1291 /* inlining can result in deeper stacks */
1311 }
1313 }
1315 static void
1317 {
1318 /*
1319 * Don't use this if a generic_context is set, since that means AOT can't
1320 * look up the method using just the image+token.
1321 * table == 0 means this is a reference made from a wrapper.
1322 */
1324 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1328 }
1329 }
1331 /*
1332 * This function is called to handle items that are left on the evaluation stack
1333 * at basic block boundaries. What happens is that we save the values to local variables
1334 * and we reload them later when first entering the target basic block (with the
1335 * handle_loaded_temps () function).
1336 * A single joint point will use the same variables (stored in the array bb->out_stack or
1337 * bb->in_stack, if the basic block is before or after the joint point).
1338 *
1339 * This function needs to be called _before_ emitting the last instruction of
1340 * the bb (i.e. before emitting a branch).
1341 * If the stack merge fails at a join point, cfg->unverifiable is set.
1342 */
1343 static void
1345 {
1350 gboolean found;
1358 //printf ("bblock %d has out:", bb->block_num);
1362 /* exception handlers are linked, but they should not be considered for stack args */
1365 //printf (" %d", outb->block_num);
1370 }
1371 }
1372 //printf ("\n");
1376 /*
1377 * try to reuse temps already allocated for this purpouse, if they occupy the same
1378 * stack slot and if they are of the same type.
1379 * This won't cause conflicts since if 'local' is used to
1380 * store one of the values in the in_stack of a bblock, then
1381 * the same variable will be used for the same outgoing stack
1382 * slot as well.
1383 * This doesn't work when inlining methods, since the bblocks
1384 * in the inlined methods do not inherit their in_stack from
1385 * the bblock they are inlined to. See bug #58863 for an
1386 * example.
1387 */
1390 else
1392 }
1393 }
1394 }
1398 /* exception handlers are linked, but they should not be considered for stack args */
1405 }
1407 }
1410 }
1420 }
1422 /*
1423 * It is possible that the out bblocks already have in_stack assigned, and
1424 * the in_stacks differ. In this case, we will store to all the different
1425 * in_stacks.
1426 */
1431 /* Find a bblock which has a different in_stack */
1435 /* exception handlers are linked, but they should not be considered for stack args */
1437 bindex++;
1439 }
1447 }
1451 }
1452 bindex ++;
1453 }
1454 }
1455 }
1457 /* Emit code which loads interface_offsets [klass->interface_id]
1458 * The array is stored in memory before vtable.
1459 */
1460 static void
1461 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1462 {
1470 }
1472 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1473 }
1474 }
1476 static void
1477 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1478 {
1480 #ifdef COMPRESSED_INTERFACE_BITMAP
1488 else
1492 #else
1507 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1513 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1514 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1515 }
1516 #endif
1517 }
1519 /*
1520 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1521 * stored in "klass_reg" implements the interface "klass".
1522 */
1523 static void
1524 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1525 {
1526 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1527 }
1529 /*
1530 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1531 * stored in "vtable_reg" implements the interface "klass".
1532 */
1533 static void
1534 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1535 {
1536 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1537 }
1539 /*
1540 * Emit code which checks whenever the interface id of @klass is smaller than
1541 * than the value given by max_iid_reg.
1542 */
1543 static void
1546 {
1551 }
1552 else
1556 else
1558 }
1560 /* Same as above, but obtains max_iid from a vtable */
1561 static void
1564 {
1567 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, max_interface_id));
1569 }
1571 /* Same as above, but obtains max_iid from a klass */
1572 static void
1575 {
1578 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id));
1580 }
1582 static void
1583 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1584 {
1592 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1595 }
1596 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1606 }
1608 }
1610 static void
1611 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1612 {
1614 }
1616 static void
1617 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1618 {
1626 else
1628 }
1630 /*
1631 * Variant of the above that takes a register to the class, not the vtable.
1632 */
1633 static void
1634 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1635 {
1643 else
1645 }
1648 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1649 {
1658 }
1660 }
1664 {
1666 }
1669 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1670 {
1677 }
1679 }
1681 static void
1682 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1684 static void
1685 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1686 {
1692 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank));
1695 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
1696 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
1699 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
1700 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1703 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1710 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1712 }
1715 /* Check that the object is a vector too */
1720 }
1729 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1732 }
1733 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1736 }
1737 }
1739 static void
1740 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1741 {
1743 }
1745 static void
1747 {
1766 #if SIZEOF_REGISTER == 8
1770 #endif
1771 }
1772 }
1778 else
1782 /* This could be optimized further if neccesary */
1787 }
1789 }
1791 #if !NO_UNALIGNED_ACCESS
1797 }
1802 }
1803 }
1804 #endif
1810 }
1815 }
1820 }
1821 }
1823 void
1824 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1825 {
1831 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1835 /* This could be optimized further if neccesary */
1843 }
1844 }
1846 #if !NO_UNALIGNED_ACCESS
1855 }
1856 }
1857 #endif
1866 }
1874 }
1882 }
1883 }
1885 static void
1887 {
1901 }
1902 }
1904 /*
1905 * emit_push_lmf:
1906 *
1907 * Emit IR to push the current LMF onto the LMF stack.
1908 */
1909 static void
1911 {
1912 /*
1913 * Emit IR to push the LMF:
1914 * lmf_addr = <lmf_addr from tls>
1915 * lmf->lmf_addr = lmf_addr
1916 * lmf->prev_lmf = *lmf_addr
1917 * *lmf_addr = lmf
1918 */
1926 /* Load current lmf */
1932 /* Save previous_lmf */
1933 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), lmf_ins->dreg);
1934 /* Set new LMF */
1937 /*
1938 * Store lmf_addr in a variable, so it can be allocated to a global register.
1939 */
1941 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1943 #ifdef HOST_WIN32
1950 EMIT_NEW_BIALU_IMM (cfg, lmf_ins, OP_PADD_IMM, lmf_reg, jit_tls_dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
1953 }
1954 #else
1959 #ifdef TARGET_IOS
1962 /* Inline mono_get_lmf_addr () */
1963 /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
1965 /* Load mono_jit_tls_id */
1967 /* call pthread_getspecific () */
1969 /* lmf_addr = &jit_tls->lmf */
1970 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, cfg->lmf_addr_var->dreg, jit_tls_ins->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
1972 #else
1974 #endif
1975 }
1976 #endif
1983 /* Save previous_lmf */
1985 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
1986 /* Set new lmf */
1988 }
1989 }
1991 /*
1992 * emit_pop_lmf:
1993 *
1994 * Emit IR to pop the current LMF from the LMF stack.
1995 */
1996 static void
1998 {
2009 /* Load previous_lmf */
2011 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2012 /* Set new LMF */
2015 /*
2016 * Emit IR to pop the LMF:
2017 * *(lmf->lmf_addr) = lmf->prev_lmf
2018 */
2019 /* This could be called before emit_push_lmf () */
2021 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2025 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2027 }
2028 }
2030 static void
2032 {
2035 /*
2036 * Avoid instrumenting inlined methods since it can
2037 * distort profiling results.
2038 */
2045 }
2046 }
2048 static int
2049 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
2050 {
2054 handle_enum:
2099 /* gsharedvt */
2103 }
2105 }
2107 /*
2108 * target_type_is_incompatible:
2109 * @cfg: MonoCompile context
2110 *
2111 * Check that the item @arg on the evaluation stack can be stored
2112 * in the target type (can be a local, or field, etc).
2113 * The cfg arg can be used to check if we need verification or just
2114 * validity checks.
2115 *
2116 * Returns: non-0 value if arg can't be stored on a target.
2117 */
2118 static int
2120 {
2126 /* FIXME: check that the pointed to types match */
2132 }
2150 /* STACK_MP is needed when setting pinned locals */
2157 /*
2158 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
2159 * in native int. (#688008).
2160 */
2171 /* FIXME: check type compatibility */
2208 /* FIXME: check type compatibility */
2210 }
2220 }
2224 }
2226 }
2228 /*
2229 * Prepare arguments for passing to a function call.
2230 * Return a non-zero value if the arguments can't be passed to the given
2231 * signature.
2232 * The type checks are not yet complete and some conversions may need
2233 * casts on 32 or 64 bit architectures.
2234 *
2235 * FIXME: implement this using target_type_is_incompatible ()
2236 */
2237 static int
2239 {
2246 args++;
2247 }
2253 }
2256 handle_enum:
2276 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2301 }
2314 /* gsharedvt */
2321 }
2322 }
2324 }
2326 static int
2328 {
2342 }
2345 }
2347 /* Either METHOD or IMT_ARG needs to be set */
2348 static void
2349 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2350 {
2366 }
2368 #ifdef ENABLE_LLVM
2370 #endif
2371 #ifdef MONO_ARCH_IMT_REG
2373 #else
2374 /* Need this to keep the IMT arg alive */
2376 #endif
2378 }
2380 #ifdef MONO_ARCH_IMT_REG
2393 }
2396 #else
2398 #endif
2399 }
2403 {
2411 }
2413 static int
2415 {
2418 else
2420 }
2422 static int
2424 {
2427 else
2429 }
2431 /*
2432 * check_method_sharing:
2433 *
2434 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2435 */
2436 static void
2437 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2438 {
2454 }
2456 /*
2457 * Pass vtable iff target method might
2458 * be shared, which means that sharing
2459 * is enabled for its class and its
2460 * context is sharable (and it's not a
2461 * generic method).
2462 */
2463 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2465 }
2482 }
2483 }
2489 }
2494 {
2497 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2499 #endif
2506 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2518 //g_assert_not_reached ();
2519 }
2526 /*
2527 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2528 * address of return value to increase optimization opportunities.
2529 * Before vtype decomposition, the dreg of the call ins itself represents the
2530 * fact the call modifies the return value. After decomposition, the call will
2531 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2532 * will be transformed into an LDADDR.
2533 */
2537 /* We reference the call too since call->dreg could change during optimization */
2547 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2549 /*
2550 * If the call has a float argument, we would need to do an r8->r4 conversion using
2551 * an icall, but that cannot be done during the call sequence since it would clobber
2552 * the call registers + the stack. So we do it before emitting the call.
2553 */
2560 else
2571 /* The result will be in an int vreg */
2573 }
2574 }
2575 }
2576 #endif
2580 #ifdef ENABLE_LLVM
2583 else
2585 #else
2587 #endif
2593 }
2595 static void
2597 {
2598 #ifdef MONO_ARCH_RGCTX_REG
2602 #ifdef ENABLE_LLVM
2604 #endif
2605 #else
2606 NOT_IMPLEMENTED;
2607 #endif
2608 }
2611 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2612 {
2618 if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2623 }
2628 }
2632 cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2637 }
2639 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2657 /* Restore the stack so we don't crash when throwing the exception */
2664 }
2670 }
2673 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2676 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2678 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2681 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2683 {
2684 #ifndef DISABLE_REMOTING
2686 #endif
2692 gboolean need_unbox_trampoline;
2700 }
2703 /* Create the real signature */
2704 /* FIXME: Cache these */
2709 }
2713 #ifndef DISABLE_REMOTING
2723 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2726 }
2727 #endif
2729 need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
2731 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2733 #ifndef DISABLE_REMOTING
2736 else
2737 #endif
2749 if (ARCH_HAVE_DELEGATE_TRAMPOLINES && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2754 /* Make a call to delegate->invoke_impl */
2759 /* We must emit a dummy use here because the delegate trampoline will
2760 replace the 'this' argument with the delegate target making this activation
2761 no longer a root for the delegate.
2762 This is an issue for delegates that target collectible code such as dynamic
2763 methods of GC'able assemblies.
2765 For a test case look into #667921.
2767 FIXME: a dummy use is not the best way to do it as the local register allocator
2768 will put it on a caller save register and spil it around the call.
2769 Ideally, we would either put it on a callee save register or only do the store part.
2770 */
2774 }
2781 /*
2782 * the method is not virtual, we just need to ensure this is not null
2783 * and then we can call the method directly.
2784 */
2785 #ifndef DISABLE_REMOTING
2786 if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2787 /*
2788 * The check above ensures method is not gshared, this is needed since
2789 * gshared methods can't have wrappers.
2790 */
2792 }
2793 #endif
2800 /*
2801 * the method is virtual, but we can statically dispatch since either
2802 * it's class or the method itself are sealed.
2803 * But first we need to ensure it's not a null reference.
2804 */
2810 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2818 }
2823 }
2831 }
2832 }
2837 }
2838 }
2846 }
2848 MonoInst*
2850 {
2851 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this, NULL, NULL);
2852 }
2854 MonoInst*
2857 {
2868 }
2870 MonoInst*
2872 {
2878 }
2880 /*
2881 * mono_emit_abs_call:
2882 *
2883 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2884 */
2888 {
2892 /*
2893 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2894 * handle it.
2895 */
2902 }
2906 {
2911 /*
2912 * Native code might return non register sized integers
2913 * without initializing the upper bits.
2914 */
2930 }
2939 }
2940 }
2941 }
2944 }
2948 {
2954 }
2956 }
2958 static void
2959 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
2960 {
2977 }
2978 }
2979 }
2981 static void
2983 {
2985 gpointer card_table_mask;
2999 #ifdef MONO_ARCH_HAVE_CARD_TABLE_WBARRIER
3001 #endif
3003 if (has_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3019 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3020 * IMM's larger than 32bits.
3021 */
3029 }
3036 }
3039 }
3041 static gboolean
3042 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3043 {
3050 /*types with references can't have alignment smaller than sizeof(void*) */
3054 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3060 /* We don't unroll more than 5 stores to avoid code bloat. */
3062 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3070 }
3079 /*tmp = dreg*/
3099 /*tmp += sizeof (void*)*/
3103 }
3104 }
3106 /* Those cannot be references since size < sizeof (void*) */
3112 }
3119 }
3126 }
3129 }
3131 /*
3132 * Emit code to copy a valuetype of type @klass whose address is stored in
3133 * @src->dreg to memory whose address is stored at @dest->dreg.
3134 */
3135 void
3136 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3137 {
3146 /*
3147 * This check breaks with spilled vars... need to handle it during verification anyway.
3148 * g_assert (klass && klass == src->klass && klass == dest->klass);
3149 */
3156 }
3160 else
3163 /* if native is true there should be no references in the struct */
3165 /* Avoid barriers when storing to the stack */
3175 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3176 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3186 }
3187 }
3191 else
3194 }
3195 }
3198 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3205 else
3211 else
3213 }
3214 }
3218 {
3224 }
3226 }
3228 void
3230 {
3233 guint32 align;
3239 /* FIXME: Optimize this for the case when dest is an LDADDR */
3247 bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3253 }
3259 }
3266 }
3267 }
3271 {
3304 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3306 }
3314 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3316 }
3317 }
3320 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3321 {
3331 }
3335 {
3336 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3337 }
3342 {
3343 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_CLASS, klass, rgctx_type);
3347 }
3352 {
3353 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_SIGNATURE, sig, rgctx_type);
3357 }
3362 {
3371 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_CALL, call_info, rgctx_type);
3375 }
3381 {
3385 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_METHOD, info, MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO);
3389 }
3391 /*
3392 * emit_get_rgctx_method:
3393 *
3394 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3395 * normal constants, else emit a load from the rgctx.
3396 */
3400 {
3413 }
3415 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_METHODCONST, cmethod, rgctx_type);
3419 }
3420 }
3425 {
3426 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_FIELD, field, rgctx_type);
3430 }
3432 static int
3434 {
3444 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3446 }
3452 new_entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3454 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3457 }
3467 }
3469 /*
3470 * emit_get_gsharedvt_info:
3471 *
3472 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3473 */
3476 {
3481 /* Load info->entries [idx] */
3483 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3486 }
3489 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3490 {
3492 }
3494 /*
3495 * On return the caller must check @klass for load errors.
3496 */
3497 static void
3499 {
3515 }
3518 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
3519 else
3520 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
3521 #ifdef MONO_ARCH_VTABLE_REG
3524 #else
3525 NOT_IMPLEMENTED;
3526 #endif
3527 }
3529 static void
3530 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3531 {
3539 }
3540 }
3542 static void
3543 save_cast_details (MonoCompile *cfg, MonoClass *klass, int obj_reg, gboolean null_check, MonoBasicBlock **out_bblock)
3544 {
3557 }
3563 }
3566 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3567 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3569 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3571 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3577 }
3578 }
3579 }
3581 static void
3583 {
3584 /* Reset the variables holding the cast details */
3589 /* It is enough to reset the from field */
3590 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3591 }
3592 }
3594 /*
3595 * On return the caller must check @array_class for load errors
3596 */
3597 static void
3599 {
3607 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3611 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3618 }
3639 }
3640 }
3645 }
3647 /**
3648 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3649 * generic code is generated.
3650 */
3653 {
3659 /* FIXME: What if the class is shared? We might not
3660 have to get the address of the method from the
3661 RGCTX. */
3663 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3680 }
3683 }
3684 }
3688 {
3697 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3698 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
3700 /* FIXME: generics */
3703 // Check rank == 0
3707 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3708 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, element_class));
3713 /* This assertion is from the unboxcast insn */
3725 }
3727 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
3733 }
3736 handle_unbox_gsharedvt (MonoCompile *cfg, MonoClass *klass, MonoInst *obj, MonoBasicBlock **out_cbb)
3737 {
3745 /* obj */
3748 /* klass */
3751 /* CASTCLASS */
3764 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
3767 /* Non-ref case */
3768 /* UNBOX */
3774 /* Ref case */
3777 /* Save the ref to a temporary */
3784 /* Nullable case */
3787 {
3788 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
3795 unbox_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
3803 }
3807 /* End */
3810 /* LDOBJ */
3816 }
3818 /*
3819 * Returns NULL and set the cfg exception on error.
3820 */
3823 {
3836 else
3847 }
3853 }
3860 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3861 /* This happens often in argument checking code, eg. throw new FooException... */
3862 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3868 gboolean pass_lw;
3874 }
3876 #ifndef MONO_CROSS_COMPILE
3878 #endif
3883 }
3890 }
3893 }
3894 }
3897 }
3899 /*
3900 * Returns NULL and set the cfg exception on error.
3901 */
3903 handle_box (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used, MonoBasicBlock **out_cbb)
3904 {
3913 /* FIXME: What if the class is shared? We might not
3914 have to get the method address from the RGCTX. */
3916 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3932 }
3935 }
3936 }
3955 /* Non-ref case */
3959 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3967 /* Ref case */
3971 /* val is a vtype, so has to load the value manually */
3979 /* Nullable case */
3982 {
3984 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
3988 /*
3989 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
3990 * construct that method at JIT time, so have to do things by hand.
3991 */
3992 box_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4000 }
4014 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4016 }
4017 }
4020 static gboolean
4021 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4022 {
4035 }
4039 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4044 }
4046 }
4048 // FIXME: This doesn't work yet (class libs tests fail?)
4049 #define is_complex_isinst(klass) (TRUE || (klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
4052 emit_castclass_with_cache (MonoCompile *cfg, MonoClass *klass, MonoInst **args, MonoBasicBlock **out_bblock)
4053 {
4064 }
4066 /*
4067 * Returns NULL and set the cfg exception on error.
4068 */
4071 {
4080 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4085 /* obj */
4088 /* klass - it's the second element of the cache entry*/
4089 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4091 /* cache */
4095 }
4098 }
4108 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4113 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4115 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4116 /* the remoting code is broken, access the class for now */
4117 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4123 }
4126 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4128 }
4131 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4133 }
4134 }
4141 }
4143 /*
4144 * Returns NULL and set the cfg exception on error.
4145 */
4148 {
4159 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4165 /* obj */
4168 /* klass - it's the second element of the cache entry*/
4169 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4171 /* cache */
4175 }
4178 }
4184 /* Do the assignment at the beginning, so the other assignment can be if converted */
4192 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4196 /* the is_null_bb target simply copies the input register to the output */
4206 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4209 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4210 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
4213 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
4214 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4218 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4228 /* Check that the object is a vector too */
4233 }
4235 /* the is_null_bb target simply copies the input register to the output */
4237 }
4240 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4241 /* the is_null_bb target simply copies the input register to the output */
4244 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4246 /* the remoting code is broken, access the class for now */
4247 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4253 }
4256 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4258 }
4262 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4263 /* the is_null_bb target simply copies the input register to the output */
4265 }
4266 }
4267 }
4279 }
4283 {
4284 /* This opcode takes as input an object reference and a class, and returns:
4285 0) if the object is an instance of the class,
4286 1) if the object is not instance of the class,
4287 2) if the object is a proxy whose type cannot be determined */
4290 #ifndef DISABLE_REMOTING
4292 #else
4294 #endif
4298 #ifndef DISABLE_REMOTING
4300 #endif
4305 #ifndef DISABLE_REMOTING
4308 #endif
4314 #ifndef DISABLE_REMOTING
4316 #endif
4320 #ifndef DISABLE_REMOTING
4325 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4328 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4331 #else
4333 #endif
4335 #ifndef DISABLE_REMOTING
4340 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4342 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4343 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4346 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4356 #else
4358 #endif
4359 }
4366 #ifndef DISABLE_REMOTING
4371 #endif
4379 /* FIXME: */
4385 }
4389 {
4390 /* This opcode takes as input an object reference and a class, and returns:
4391 0) if the object is an instance of the class,
4392 1) if the object is a proxy whose type cannot be determined
4393 an InvalidCastException exception is thrown otherwhise*/
4396 #ifndef DISABLE_REMOTING
4398 #else
4400 #endif
4405 #ifndef DISABLE_REMOTING
4408 #endif
4418 #ifndef DISABLE_REMOTING
4429 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4435 #else
4439 #endif
4441 #ifndef DISABLE_REMOTING
4446 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4449 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4450 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4453 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4469 #else
4471 #endif
4472 }
4478 #ifndef DISABLE_REMOTING
4480 #endif
4482 /* FIXME: */
4488 }
4490 /*
4491 * Returns NULL and set the cfg exception on error.
4492 */
4494 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
4495 {
4507 /* Inline the contents of mono_delegate_ctor */
4509 /* Set target field */
4510 /* Optimize away setting of NULL target */
4512 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
4515 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
4517 }
4518 }
4520 /* Set method field */
4522 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
4523 /*
4524 * To avoid looking up the compiled code belonging to the target method
4525 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
4526 * store it, and we fill it after the method has been compiled.
4527 */
4532 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
4542 }
4547 else
4549 }
4550 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
4551 }
4553 /* Set invoke_impl field */
4562 trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
4564 }
4567 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
4568 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
4571 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
4572 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
4574 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
4577 }
4581 {
4584 /* Need to register the icall so it gets an icall wrapper */
4589 /* mono_array_new_va () needs a vararg calling convention */
4592 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
4594 }
4596 static void
4598 {
4608 /* Add it to the start of the first bblock */
4612 }
4613 else
4618 /*
4619 * Add a dummy use to keep the got_var alive, since real uses might
4620 * only be generated by the back ends.
4621 * Add it to end_bblock, so the variable's lifetime covers the whole
4622 * method.
4623 * It would be better to make the usage of the got var explicit in all
4624 * cases when the backend needs it (i.e. calls, throw etc.), so this
4625 * wouldn't be needed.
4626 */
4629 }
4634 static gboolean
4636 {
4637 MonoMethodHeaderSummary header;
4639 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
4642 #endif
4650 #ifdef MONO_ARCH_HAVE_LMF_OPS
4655 #endif
4661 /*runtime, icall and pinvoke are checked by summary call*/
4668 /* also consider num_locals? */
4669 /* Do the size check early to avoid creating vtables */
4673 else
4676 }
4677 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
4680 /*
4681 * if we can initialize the class of the method right away, we do,
4682 * otherwise we don't allow inlining if the class needs initialization,
4683 * since it would mean inserting a call to mono_runtime_class_init()
4684 * inside the inlined code
4685 */
4687 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
4696 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
4698 /* No vtable created yet */
4703 /* This makes so that inline cannot trigger */
4704 /* .cctors: too many apps depend on them */
4705 /* running with a specific order... */
4709 }
4712 /* No vtable created yet */
4719 }
4721 /*
4722 * If we're compiling for shared code
4723 * the cctor will need to be run at aot method load time, for example,
4724 * or at the end of the compilation of the inlining method.
4725 */
4726 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
4728 }
4730 /*
4731 * CAS - do not inline methods with declarative security
4732 * Note: this has to be before any possible return TRUE;
4733 */
4737 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
4739 /* FIXME: */
4745 }
4746 #endif
4749 }
4751 static gboolean
4752 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
4753 {
4758 }
4763 }
4769 /* The initialization is already done before the method is called */
4773 }
4776 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4777 {
4779 guint32 size;
4788 }
4794 #if SIZEOF_REGISTER == 8
4795 /* The array reg is 64 bits but the index reg is only 32 */
4797 /* Not needed */
4802 }
4803 #else
4809 }
4810 #endif
4815 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4819 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
4824 }
4825 #endif
4832 /* gsharedvt */
4836 rgctx_ins = emit_get_gsharedvt_info (cfg, &klass->byval_arg, MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE);
4840 }
4842 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
4848 }
4850 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4852 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4853 {
4867 guint32 size;
4875 #if SIZEOF_REGISTER == 8
4876 /* The array reg is 64 bits but the index reg is only 32 */
4878 /* Not needed */
4886 }
4887 #else
4888 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
4890 #endif
4892 /* range checking */
4916 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
4923 }
4924 #endif
4927 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
4928 {
4939 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4940 /* emit_ldelema_2 depends on OP_LMUL */
4943 }
4944 #endif
4951 }
4953 static MonoBreakPolicy
4955 {
4957 }
4961 /**
4962 * mono_set_break_policy:
4963 * policy_callback: the new callback function
4964 *
4965 * Allow embedders to decide wherther to actually obey breakpoint instructions
4966 * (both break IL instructions and Debugger.Break () method calls), for example
4967 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4968 * untrusted or semi-trusted code.
4969 *
4970 * @policy_callback will be called every time a break point instruction needs to
4971 * be inserted with the method argument being the method that calls Debugger.Break()
4972 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4973 * if it wants the breakpoint to not be effective in the given method.
4974 * #MONO_BREAK_POLICY_ALWAYS is the default.
4975 */
4976 void
4978 {
4981 else
4983 }
4985 static gboolean
4998 }
4999 }
5001 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5003 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5004 {
5008 /* the bounds check is already done by the callers */
5018 }
5020 }
5023 static gboolean
5025 {
5027 }
5031 {
5058 // FIXME-VT: OP_ICONST optimization
5065 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
5075 }
5077 }
5078 }
5081 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5082 {
5087 else
5096 }
5097 }
5099 static gboolean
5101 {
5104 //Only allow for valuetypes
5108 //That are blitable
5112 /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5113 if ((MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5114 (!MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)))
5117 if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5121 //And have the same size
5122 if (mono_class_value_size (param_klass, &align) != mono_class_value_size (return_klass, &align))
5125 }
5129 {
5133 //Valuetypes that are semantically equivalent
5137 //Arrays of valuetypes that are semantically equivalent
5138 if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (param_klass->element_class, return_klass->element_class))
5142 }
5145 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5146 {
5147 #ifdef MONO_ARCH_SIMD_INTRINSICS
5154 }
5155 #endif
5158 }
5162 {
5169 }
5172 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5173 {
5177 /* The LLVM backend supports these intrinsics */
5187 }
5195 }
5217 }
5218 }
5227 }
5228 }
5231 }
5234 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5235 {
5243 }
5246 }
5249 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5250 {
5265 #if SIZEOF_REGISTER == 8
5266 /* The array reg is 64 bits but the index reg is only 32 */
5268 #else
5270 #endif
5273 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5274 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
5276 /* Avoid a warning */
5280 #else
5285 #endif
5290 /* Decompose later to allow more optimizations */
5302 /* The corlib functions check for oob already. */
5305 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, MONO_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
5314 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
5315 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
5319 #if !defined(MONO_ARCH_EMULATE_MUL_DIV)
5329 #endif
5340 #ifndef MONO_BIG_ARRAYS
5341 /*
5342 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
5343 * Array methods.
5344 */
5345 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
5358 /* Non-szarray case */
5362 else
5367 /* Szarray case */
5371 else
5379 }
5380 #endif
5419 }
5422 /* FIXME this should be integrated to the check below once we support the trampoline version */
5423 #if defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
5427 /* Avoid infinite recursion */
5428 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN && !strcmp (cfg->method->name, "FastMonitorEnterV4"))
5436 }
5437 #endif
5439 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
5444 /*
5445 * Pass the argument normally, the LLVM backend will handle the
5446 * calling convention problems.
5447 */
5448 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
5454 }
5461 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
5467 }
5470 }
5471 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
5472 {
5475 /* Avoid infinite recursion */
5488 }
5489 #endif
5495 #if SIZEOF_REGISTER == 8
5501 /* 64 bit reads are already atomic */
5511 }
5512 #endif
5521 }
5522 #if SIZEOF_REGISTER == 8
5525 #endif
5541 }
5549 }
5550 #if SIZEOF_REGISTER == 8
5553 #endif
5569 }
5576 }
5577 #if SIZEOF_REGISTER == 8
5580 #endif
5591 }
5592 }
5595 guint32 opcode;
5601 }
5602 #if SIZEOF_REGISTER == 8
5606 #else
5610 }
5611 #endif
5612 else
5638 }
5642 }
5675 /* g_assert_not_reached (); */
5676 }
5679 }
5694 }
5696 }
5699 #ifdef TARGET_WIN32
5701 #else
5703 #endif
5705 }
5707 /*
5708 * There is general branches code for Min/Max, but it does not work for
5709 * all inputs:
5710 * http://everything2.com/?node_id=1051618
5711 */
5712 } else if ((!strcmp (cmethod->klass->image->assembly->aname.name, "MonoMac") || !strcmp (cmethod->klass->image->assembly->aname.name, "monotouch")) && !strcmp (cmethod->klass->name, "Selector") && !strcmp (cmethod->name, "GetHandle") && cfg->compile_aot && (args [0]->opcode == OP_GOT_ENTRY || args[0]->opcode == OP_AOTCONST)) {
5713 #ifdef MONO_ARCH_HAVE_OBJC_GET_SELECTOR
5728 }
5732 // FIXME: Ugly
5736 // FIXME: Leaks
5740 #endif
5741 }
5743 #ifdef MONO_ARCH_SIMD_INTRINSICS
5748 }
5749 #endif
5759 }
5762 }
5764 /*
5765 * This entry point could be used later for arbitrary method
5766 * redirection.
5767 */
5771 {
5773 /* managed string allocation support */
5774 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
5780 #ifndef MONO_CROSS_COMPILE
5782 #endif
5788 }
5789 }
5791 }
5793 static void
5795 {
5800 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
5802 /*
5803 * FIXME: We should use *args++ = sp [0], but that would mean the arg
5804 * would be different than the MonoInst's used to represent arguments, and
5805 * the ldelema implementation can't deal with that.
5806 * Solution: When ldelema is used on an inline argument, create a var for
5807 * it, emit ldelema on that var, and emit the saving code below in
5808 * inline_method () if needed.
5809 */
5812 /* This uses cfg->args [i] which is set by the preceeding line */
5815 sp++;
5816 }
5817 }
5819 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
5820 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
5822 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5823 static gboolean
5825 {
5834 else
5836 }
5844 //return (strncmp_result <= 0);
5848 }
5849 }
5850 #endif
5852 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5853 static gboolean
5855 {
5865 }
5866 }
5874 //return (strncmp_result <= 0);
5878 }
5879 }
5880 #endif
5882 static void
5884 {
5907 } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (cfg, rtype)) {
5911 }
5912 }
5914 static void
5916 {
5933 } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (cfg, rtype)) {
5937 }
5938 }
5940 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
5941 static void
5943 {
5953 else
5955 }
5956 }
5958 static int
5959 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
5961 {
5969 guint prev_real_offset;
5974 guint32 prev_cil_offset_to_bb_len;
5981 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5984 #endif
5985 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5988 #endif
5991 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
5996 }
5998 /* allocate local variables */
6011 }
6013 /*Must verify before creating locals as it can cause the JIT to assert.*/
6017 }
6019 /* allocate space to store the return value */
6022 }
6029 /* allocate start and end blocks */
6030 /* This is needed so if the inline is aborted, we can clean up */
6057 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
6077 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
6081 /* always add some code to avoid block split failures */
6088 /*
6089 * Get rid of the begin and end bblocks if possible to aid local
6090 * optimizations.
6091 */
6094 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
6101 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
6104 }
6106 /*
6107 * Its possible that the rvar is set in some prev bblock, but not in others.
6108 * (#1835).
6109 */
6120 }
6121 }
6122 }
6125 }
6128 /*
6129 * If the inlined method contains only a throw, then the ret var is not
6130 * set, so set it to a dummy value.
6131 */
6137 }
6146 /* This gets rid of the newly added bblocks */
6148 }
6151 }
6153 /*
6154 * Some of these comments may well be out-of-date.
6155 * Design decisions: we do a single pass over the IL code (and we do bblock
6156 * splitting/merging in the few cases when it's required: a back jump to an IL
6157 * address that was not already seen as bblock starting point).
6158 * Code is validated as we go (full verification is still better left to metadata/verify.c).
6159 * Complex operations are decomposed in simpler ones right away. We need to let the
6160 * arch-specific code peek and poke inside this process somehow (except when the
6161 * optimizations can take advantage of the full semantic info of coarse opcodes).
6162 * All the opcodes of the form opcode.s are 'normalized' to opcode.
6163 * MonoInst->opcode initially is the IL opcode or some simplification of that
6164 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
6165 * opcode with value bigger than OP_LAST.
6166 * At this point the IR can be handed over to an interpreter, a dumb code generator
6167 * or to the optimizing code generator that will translate it to SSA form.
6168 *
6169 * Profiling directed optimizations.
6170 * We may compile by default with few or no optimizations and instrument the code
6171 * or the user may indicate what methods to optimize the most either in a config file
6172 * or through repeated runs where the compiler applies offline the optimizations to
6173 * each method and then decides if it was worth it.
6174 */
6176 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
6177 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
6178 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
6179 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
6180 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
6181 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
6182 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
6183 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; LOAD_ERROR;}
6185 /* offset from br.s -> br like opcodes */
6186 #define BIG_BRANCH_OFFSET 13
6188 static gboolean
6190 {
6194 }
6196 static int
6197 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
6198 {
6202 guint cli_addr;
6210 UNVERIFIED;
6214 ip++;
6249 guint32 j;
6259 }
6261 }
6268 }
6273 /* Find the start of the bblock containing the throw */
6277 bb_start --;
6278 }
6281 }
6282 }
6284 unverified:
6285 exception_exit:
6288 }
6291 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
6292 {
6301 }
6304 }
6307 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
6308 {
6311 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
6315 }
6319 {
6328 }
6332 }
6336 {
6340 MonoError error;
6345 // FIXME:
6347 }
6350 }
6352 }
6354 /*
6355 * Returns TRUE if the JIT should abort inlining because "callee"
6356 * is influenced by security attributes.
6357 */
6358 static
6360 {
6361 guint32 result;
6365 }
6372 /* Generate code to throw a SecurityException before the actual call/link */
6380 /* don't hide previous results */
6384 }
6387 }
6391 {
6397 }
6400 }
6402 static void
6404 {
6410 }
6412 /*
6413 * Return the original method is a wrapper is specified. We can only access
6414 * the custom attributes from the original method.
6415 */
6418 {
6422 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
6426 /* in other cases we need to find the original method */
6428 }
6430 static void
6431 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
6433 {
6434 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
6435 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
6438 }
6440 static void
6441 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
6443 {
6444 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
6445 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
6448 }
6450 /*
6451 * Check that the IL instructions at ip are the array initialization
6452 * sequence and return the pointer to the data and the size.
6453 */
6455 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
6456 {
6457 /*
6458 * newarr[System.Int32]
6459 * dup
6460 * ldtoken field valuetype ...
6461 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
6462 */
6467 guint32 rva;
6472 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
6483 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
6490 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
6491 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
6504 #endif
6507 }
6512 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
6517 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
6518 /* for aot code we do the lookup on load */
6522 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
6525 }
6527 }
6529 }
6531 static void
6533 {
6540 else
6543 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
6547 }
6549 static void
6551 {
6555 }
6557 static void
6559 {
6564 /* Optimize reg-reg moves away */
6565 /*
6566 * Can't optimize other opcodes, since sp[0] might point to
6567 * the last ins of a decomposed opcode.
6568 */
6572 }
6573 }
6575 /*
6576 * ldloca inhibits many optimizations so try to get rid of it in common
6577 * cases.
6578 */
6581 {
6592 }
6594 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
6595 /* From the INITOBJ case */
6602 }
6603 load_error:
6605 }
6607 static gboolean
6609 {
6614 }
6616 }
6618 /*
6619 * is_jit_optimizer_disabled:
6620 *
6621 * Determine whenever M's assembly has a DebuggableAttribute with the
6622 * IsJITOptimizerDisabled flag set.
6623 */
6624 static gboolean
6626 {
6638 klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
6640 /* Linked away */
6645 }
6657 /* Decode the attribute. See reflection.c */
6663 // FIXME: Support named parameters
6665 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
6667 /* Two boolean arguments */
6668 p ++;
6670 }
6672 }
6679 }
6681 static gboolean
6682 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
6683 {
6684 gboolean supported_tail_call;
6687 #ifdef MONO_ARCH_HAVE_OP_TAIL_CALL
6688 supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
6689 #else
6690 supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6691 #endif
6694 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
6695 /* These can point to the current method's stack */
6697 }
6699 /* this might point to the current method's stack */
6710 /* Debugging support */
6711 #if 0
6715 }
6716 #endif
6719 }
6721 /* the JIT intercepts ldflda instructions to the tlsdata field in ThreadLocal<T> and redirects
6722 * it to the thread local value based on the tls_offset field. Every other kind of access to
6723 * the field causes an assert.
6724 */
6725 static gboolean
6727 {
6733 }
6735 /* emits the code needed to access a managed tls var (like ThreadStatic)
6736 * with the value of the tls offset in offset_reg. thread_ins represents the MonoInternalThread
6737 * pointer for the current thread.
6738 * Returns the MonoInst* representing the address of the tls var.
6739 */
6742 {
6746 // inlined access to the tls data
6747 // idx = (offset >> 24) - 1;
6748 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
6750 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
6763 }
6765 /*
6766 * redirect access to the tlsdata field to the tls var given by the tls_offset field.
6767 * this address is cached per-method in cached_tls_addr.
6768 */
6770 create_magic_tls_access (MonoCompile *cfg, MonoClassField *tls_field, MonoInst **cached_tls_addr, MonoInst *thread_local)
6771 {
6778 }
6782 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, offset_field->type, thread_local->dreg, offset_field->offset);
6787 thread_method = mono_class_get_method_from_name (mono_get_thread_class(), "CurrentInternalThread_internal", 0);
6789 }
6793 *cached_tls_addr = temp = mono_compile_create_var (cfg, type_from_stack_type (addr), OP_LOCAL);
6798 }
6800 /*
6801 * mono_method_to_ir:
6802 *
6803 * Translate the .net IL into linear IR.
6804 */
6805 int
6806 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
6809 {
6810 MonoError error;
6829 guint num_args;
6832 MonoDeclSecurityActions actions;
6845 /* serialization and xdomain stuff may need access to private fields and methods */
6855 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
6870 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
6871 }
6873 }
6883 #ifdef PLATFORM_ANDROID
6885 #endif
6888 /* We could hit a seq point before attaching to the JIT (#8338) */
6890 }
6899 mono_debug_symfile_get_line_numbers_full (minfo, NULL, NULL, &n_il_offsets, &il_offsets, &line_numbers, NULL, NULL, NULL, NULL);
6900 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6901 seq_point_set_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6906 }
6909 }
6910 }
6912 /*
6913 * Methods without init_locals set could cause asserts in various passes
6914 * (#497220). To work around this, we emit dummy initialization opcodes
6915 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
6916 * on some platforms.
6917 */
6920 else
6927 }
6929 /* SkipVerification is not allowed if core-clr is enabled */
6933 }
6947 }
6955 }
6957 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
6978 /* ENTRY BLOCK */
6983 #if defined(__native_client_codegen__)
6987 #endif
6989 /* EXIT BLOCK */
7002 }
7003 /* handle exception clauses */
7015 /*
7016 * Linking the try block with the EH block hinders inlining as we won't be able to
7017 * merge the bblocks from inlining and produce an artificial hole for no good reason.
7018 */
7032 /* finally clauses already have a seq point */
7035 }
7037 /* todo: is a fault block unsafe to optimize? */
7040 }
7043 /*printf ("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);
7044 while (p < end) {
7045 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
7046 }*/
7047 /* catch and filter blocks get the exception object on the stack */
7052 /* mostly like handle_stack_args (), but just sets the input args */
7053 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
7058 /*
7059 * Add a dummy use for the exvar so its liveness info will be
7060 * correct.
7061 */
7071 /* The filter block shares the exvar with the handler block */
7075 }
7076 }
7082 /*
7083 * In shared generic code with catch
7084 * clauses containing type variables
7085 * the exception handling code has to
7086 * be able to get to the rgctx.
7087 * Therefore we have to make sure that
7088 * the vtable/mrgctx argument (for
7089 * static or generic methods) or the
7090 * "this" argument (for non-static
7091 * methods) are live.
7092 */
7101 }
7102 }
7103 }
7109 }
7111 /* FIRST CODE BLOCK */
7124 }
7125 }
7131 /* at this point having security doesn't mean we have any code to generate */
7133 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
7134 * And we do not want to enter the next section (with allocation) if we
7135 * have nothing to generate */
7137 }
7139 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
7146 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
7149 }
7157 }
7160 }
7162 /* not a P/Invoke after all */
7164 }
7165 }
7167 /* we use a separate basic block for the initialization code */
7186 info->entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
7190 /* prevent it from being register allocated */
7191 //var->flags |= MONO_INST_VOLATILE;
7194 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
7197 /* Allocate locals */
7199 /* prevent it from being register allocated */
7200 //locals_var->flags |= MONO_INST_VOLATILE;
7204 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
7213 /*
7214 if (init_locals)
7215 ins->flags |= MONO_INST_INIT;
7216 */
7217 }
7219 /* at this point we know, if security is TRUE, that some code needs to be generated */
7226 /* Add code for SecurityAction.Demand */
7229 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
7231 }
7233 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
7234 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
7237 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
7239 }
7241 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
7244 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
7246 }
7247 }
7249 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
7252 }
7255 /* check if this is native code, e.g. an icall or a p/invoke */
7262 /* if this ia a native call then it can only be JITted from platform code */
7268 }
7269 }
7270 }
7271 }
7272 }
7274 CHECK_CFG_EXCEPTION;
7277 UNVERIFIED;
7281 UNVERIFIED;
7282 }
7289 UNVERIFIED;
7290 }
7293 /* We force the vtable variable here for all shared methods
7294 for the possibility that they might show up in a stack
7295 trace where their exact instantiation is needed. */
7302 /* FIXME: Is there a better way to do this?
7303 We need the variable live for the duration
7304 of the whole method. */
7306 }
7307 }
7309 /* add a check for this != NULL to inlined methods */
7316 }
7323 UNVERIFIED;
7324 }
7326 }
7328 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
7329 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
7337 else
7349 }
7359 }
7370 }
7379 }
7382 }
7383 }
7401 }
7405 }
7406 }
7407 /*
7408 * Sequence points are points where the debugger can place a breakpoint.
7409 * Currently, we generate these automatically at points where the IL
7410 * stack is empty.
7411 */
7412 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
7413 /*
7414 * Make methods interruptable at the beginning, and at the targets of
7415 * backward branches.
7416 * Also, do this at the start of every bblock in methods with clauses too,
7417 * to be able to handle instructions with inprecise control flow like
7418 * throw/endfinally.
7419 * Backward branches are handled at the end of method-to-ir ().
7420 */
7423 /* Avoid sequence points on empty IL like .volatile */
7424 // FIXME: Enable this
7425 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
7433 }
7441 /* TODO: Use an increment here */
7442 #if defined(TARGET_X86)
7447 #else
7450 #endif
7451 }
7454 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
7459 /*
7460 * The C# compiler uses these nops to notify the JIT that it should
7461 * insert seq points.
7462 */
7465 }
7468 else
7470 ip++;
7478 }
7479 ip++;
7490 ip++;
7501 ip++;
7513 UNVERIFIED;
7518 }
7545 UNVERIFIED;
7568 }
7574 }
7581 UNVERIFIED;
7644 #ifdef TARGET_POWERPC
7645 /* FIXME: Clean this up */
7648 #endif
7650 /* FIXME: we should really allocate this only late in the compilation process */
7670 }
7676 }
7681 #ifdef TARGET_POWERPC
7682 /* FIXME: Clean this up */
7685 #endif
7687 /* FIXME: we should really allocate this only late in the compilation process */
7707 }
7713 }
7718 sp--;
7733 }
7736 ip++;
7739 #ifdef TARGET_X86
7741 /* we need to pop the value from the x86 FP stack */
7743 #endif
7753 UNVERIFIED;
7755 /* FIXME: check the signature matches */
7759 LOAD_ERROR;
7765 CHECK_CFG_EXCEPTION;
7773 /* Handle tail calls similarly to calls */
7792 /* Prevent arguments from being optimized away */
7799 }
7804 }
7835 //GSHAREDVT_FAILURE (*ip);
7846 /*
7847 * This is a call through a function pointer using a pinvoke
7848 * signature. Have to create a wrapper and call that instead.
7849 * FIXME: This is very slow, need to create a wrapper at JIT time
7850 * instead based on the signature.
7851 */
7856 }
7870 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_call, generic_context);
7871 }
7876 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
7877 /*
7878 * This is needed since get_method_constrained can't find
7879 * the method in klass representing a type var.
7880 * The type var is guaranteed to be a reference type in this
7881 * case.
7882 */
7886 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
7887 }
7888 }
7889 }
7892 LOAD_ERROR;
7896 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
7897 }
7900 METHOD_ACCESS_FAILURE;
7901 }
7907 /* MS.NET seems to silently convert this to a callvirt */
7910 {
7911 /*
7912 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
7913 * converts to a callvirt.
7914 *
7915 * tests/bug-515884.il is an example of this behavior
7916 */
7917 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
7919 if (!virtual && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
7921 }
7935 LOAD_ERROR;
7945 }
7946 }
7951 /*
7952 * Need to emit an implicit seq point after every non-void call so single stepping through nested calls like
7953 * foo (bar (), baz ())
7954 * works correctly. MS does this also:
7955 * http://stackoverflow.com/questions/6937198/making-your-net-language-step-correctly-in-the-debugger
7956 * The problem with this approach is that the debugger will stop after all calls returning a value,
7957 * even for simple cases, like:
7958 * int i = foo ();
7959 */
7960 /* Special case a few common successor opcodes */
7961 if (!(ip + 5 < end && (ip [5] == CEE_POP || ip [5] == CEE_NOP)) && !(seq_point_locs && mono_bitset_test_fast (seq_point_locs, ip + 5 - header->code)))
7963 }
7967 /* Don't support calls made using type arguments for now */
7968 /*
7969 if (cfg->gsharedvt) {
7970 if (mini_is_gsharedvt_signature (cfg, fsig))
7971 GSHAREDVT_FAILURE (*ip);
7972 }
7973 */
7978 CHECK_CFG_EXCEPTION;
7979 }
7983 }
7986 UNVERIFIED;
7993 //g_assert (!virtual || fsig->hasthis);
7999 /*
8000 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
8001 */
8002 if ((cmethod->klass != mono_defaults.object_class) && constrained_call->valuetype && cmethod->klass->valuetype) {
8003 /* The 'Own method' case below */
8004 } else if (cmethod->klass->image != mono_defaults.corlib && !(cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) && !cmethod->klass->valuetype) {
8005 /* 'The type parameter is instantiated as a reference type' case below. */
8006 } else if (((cmethod->klass == mono_defaults.object_class) || (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
8007 (MONO_TYPE_IS_VOID (fsig->ret) || MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_IS_REFERENCE (fsig->ret) || mini_is_gsharedvt_type (cfg, fsig->ret)) &&
8008 (fsig->param_count == 0 || (!fsig->hasthis && fsig->param_count == 1) || (fsig->param_count == 1 && (MONO_TYPE_IS_REFERENCE (fsig->params [0]) || mini_is_gsharedvt_type (cfg, fsig->params [0]))))) {
8011 /*
8012 * This case handles calls to
8013 * - object:ToString()/Equals()/GetHashCode(),
8014 * - System.IComparable<T>:CompareTo()
8015 * - System.IEquatable<T>:Equals ()
8016 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
8017 */
8021 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
8022 else
8024 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_call), constrained_call, MONO_RGCTX_INFO_KLASS);
8026 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
8028 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
8038 args [3] = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
8046 }
8050 }
8059 /* Unbox */
8060 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
8062 /* Load value */
8065 /* ins represents the call result */
8066 }
8071 }
8072 }
8073 /*
8074 * We have the `constrained.' prefix opcode.
8075 */
8076 if (constrained_call->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
8077 /*
8078 * The type parameter is instantiated as a valuetype,
8079 * but that type doesn't override the method we're
8080 * calling, so we need to box `this'.
8081 */
8084 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call), &bblock);
8085 CHECK_CFG_EXCEPTION;
8089 /*
8090 * The type parameter is instantiated as a reference
8091 * type. We have a managed pointer on the stack, so
8092 * we need to dereference it here.
8093 */
8099 /* Own method */
8101 /* Interface method */
8115 /* Enum implements some interfaces, so treat this as the first case */
8118 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call), &bblock);
8119 CHECK_CFG_EXCEPTION;
8120 }
8121 }
8123 }
8125 }
8128 UNVERIFIED;
8130 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
8131 if (cmethod && (cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
8133 #endif
8135 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
8140 }
8143 }
8145 /*
8146 * If the callee is a shared method, then its static cctor
8147 * might not get called after the call was patched.
8148 */
8149 if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
8152 }
8163 /* Generic method interface
8164 calls are resolved via a
8165 helper function and don't
8166 need an imt. */
8169 }
8171 /*
8172 * If a shared method calls another
8173 * shared method then the caller must
8174 * have a generic sharing context
8175 * because the magic trampoline
8176 * requires it. FIXME: We shouldn't
8177 * have to force the vtable/mrgctx
8178 * variable here. Instead there
8179 * should be a flag in the cfg to
8180 * request a generic sharing context.
8181 */
8185 }
8195 }
8196 }
8202 /*
8203 * emit_get_rgctx_method () calls mono_class_vtable () so check
8204 * for type load errors before.
8205 */
8208 }
8212 /* !marshalbyref is needed to properly handle generic methods + remoting */
8219 }
8220 }
8228 }
8233 /* Calling virtual generic methods */
8246 /* Prevent inlining of methods that contain indirect calls */
8252 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
8255 #endif
8269 /* FIXME: This should be a managed pointer */
8282 }
8285 }
8287 /*
8288 * Implement a workaround for the inherent races involved in locking:
8289 * Monitor.Enter ()
8290 * try {
8291 * } finally {
8292 * Monitor.Exit ()
8293 * }
8294 * If a thread abort happens between the call to Monitor.Enter () and the start of the
8295 * try block, the Exit () won't be executed, see:
8296 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
8297 * To work around this, we extend such try blocks to include the last x bytes
8298 * of the Monitor.Enter () call.
8299 */
8300 if (cmethod && cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
8304 /*
8305 * Only extend try blocks with a finally, to avoid catching exceptions thrown
8306 * from Monitor.Enter like ArgumentNullException.
8307 */
8309 /* Mark this bblock as needing to be extended */
8311 }
8312 }
8314 /* Conversion to a JIT intrinsic */
8315 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
8320 }
8322 }
8324 /* Inlining */
8326 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
8334 /* Prevent inlining of methods that call wrappers */
8338 }
8346 /* *sp is already set by inline_method */
8347 sp++;
8349 }
8354 }
8355 }
8357 /* Tail recursion elimination */
8358 if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
8362 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
8365 /* keep it simple */
8369 }
8381 /* skip the CEE_RET, too */
8386 }
8387 }
8391 /*
8392 * Making generic calls out of gsharedvt methods.
8393 */
8395 MonoRgctxInfoType info_type;
8398 //if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
8399 //GSHAREDVT_FAILURE (*ip);
8400 // disable for possible remoting calls
8401 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
8404 /* virtual generic call */
8407 /* Same as the virtual generic case above */
8410 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
8412 }
8413 }
8416 /* test_0_multi_dim_arrays () in gshared.cs */
8419 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
8424 else
8431 /*
8432 * We pass the address to the gsharedvt trampoline in the rgctx reg
8433 */
8437 /* Not tested */
8444 }
8446 /* Generic sharing */
8447 /* FIXME: only do this for generic methods if
8448 they are not shared! */
8459 /*
8460 * We are compiling a call to a
8461 * generic method from shared code,
8462 * which means that we have to look up
8463 * the method in the rgctx and do an
8464 * indirect call.
8465 */
8469 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8472 }
8474 /* Indirect calls */
8480 else
8481 /* FIXME: what the hell is this??? */
8485 /* Prevent inlining of methods with indirect calls */
8488 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
8490 gpointer info_data;
8492 /*
8493 * Instead of emitting an indirect call, emit a direct call
8494 * with the contents of the aotconst as the patch info.
8495 */
8502 }
8508 }
8509 }
8512 }
8514 /* Array methods */
8528 }
8531 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
8532 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
8548 }
8552 }
8558 /* Tail prefix / tail call optimization */
8560 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
8561 /* FIXME: runtime generic context pointer for jumps? */
8562 /* FIXME: handle this for generic sharing eventually */
8564 !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
8570 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
8573 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
8576 /* Handle tail calls similarly to normal calls */
8586 /*
8587 * We implement tail calls by storing the actual arguments into the
8588 * argument variables, then emitting a CEE_JMP.
8589 */
8591 /* Prevent argument from being register allocated */
8594 }
8602 // FIXME: Eliminate unreachable epilogs
8604 /*
8605 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
8606 * only reachable from this call.
8607 */
8614 }
8615 }
8617 /*
8618 * Synchronized wrappers.
8619 * Its hard to determine where to replace a method with its synchronized
8620 * wrapper without causing an infinite recursion. The current solution is
8621 * to add the synchronized wrapper in the trampolines, and to
8622 * change the called method to a dummy wrapper, and resolve that wrapper
8623 * to the real method in mono_jit_compile_method ().
8624 */
8627 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
8629 }
8631 /* Common call */
8640 // FIXME: Eliminate unreachable epilogs
8642 /*
8643 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
8644 * only reachable from this call.
8645 */
8650 }
8652 call_end:
8654 /* End of call, INS should contain the result of the call, if any */
8660 else
8662 }
8667 /* See mono_emit_method_call_full () */
8669 }
8671 CHECK_CFG_EXCEPTION;
8677 }
8683 }
8686 /* return from inlined method */
8687 /*
8688 * If in_count == 0, that means the ret is unreachable due to
8689 * being preceeded by a throw. In that case, inline_method () will
8690 * handle setting the return value
8691 * (test case: test_0_inline_throw ()).
8692 */
8700 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
8701 UNVERIFIED;
8703 //g_assert (returnvar != -1);
8706 }
8717 /*
8718 * Place a seq point here too even through the IL stack is not
8719 * empty, so a step over on
8720 * call <FOO>
8721 * ret
8722 * will work correctly.
8723 */
8726 }
8732 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
8733 UNVERIFIED;
8747 }
8749 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8759 }
8760 #else
8762 #endif
8763 }
8764 }
8765 }
8767 UNVERIFIED;
8769 ip++;
8778 ip++;
8788 }
8806 ip++;
8808 ip++;
8818 ip++;
8829 }
8848 UNVERIFIED;
8849 ip ++;
8853 sp--;
8863 }
8870 #if SIZEOF_REGISTER == 4
8872 /* Convert it to OP_LCOMPARE */
8880 }
8881 #endif
8897 }
8911 ip++;
8929 gboolean use_op_switch;
8937 UNVERIFIED;
8952 }
8955 /*
8956 * Link the current bb with the targets as well, so handle_stack_args
8957 * will set their in_stack correctly.
8958 */
8966 }
8980 #ifdef TARGET_ARM
8981 /* ARM implements SWITCH statements differently */
8982 /* FIXME: Make it use the generic implementation */
8985 #endif
9002 else
9005 #if SIZEOF_REGISTER == 8
9006 /* The upper word might not be zero, and we add it to a 64 bit address later */
9008 #endif
9018 }
9020 /* FIXME: Use load_memindex */
9024 }
9028 }
9056 }
9064 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9065 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9067 }
9083 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
9084 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9086 }
9094 if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0)))
9112 /* Use the immediate opcodes if possible */
9121 }
9122 }
9127 ip++;
9152 /* FIXME: Pass opcode to is_inst_imm */
9154 /* Use the immediate opcodes if possible */
9155 if (((sp [1]->opcode == OP_ICONST) || (sp [1]->opcode == OP_I8CONST)) && mono_arch_is_inst_imm (sp [1]->opcode == OP_ICONST ? sp [1]->inst_c0 : sp [1]->inst_l)) {
9159 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
9160 /* Keep emulated opcodes which are optimized away later */
9161 if ((ins->opcode == OP_IREM_UN || ins->opcode == OP_IDIV_UN_IMM) && (cfg->opt & (MONO_OPT_CONSPROP | MONO_OPT_COPYPROP)) && sp [1]->opcode == OP_ICONST && mono_is_power_of_two (sp [1]->inst_c0) >= 0) {
9163 }
9164 #endif
9168 #if SIZEOF_REGISTER == 8
9170 #else
9173 #endif
9174 }
9175 else
9179 /* Might be followed by an instruction added by ADD_WIDEN_OP */
9182 }
9183 }
9187 ip++;
9204 /* Special case this earlier so we have long constants in the IR */
9209 #if SIZEOF_REGISTER == 8
9212 else
9214 #else
9218 else
9220 #endif
9222 }
9225 }
9226 ip++;
9240 }
9241 ip++;
9253 }
9254 ip++;
9272 CHECK_CFG_EXCEPTION;
9273 ip++;
9283 ip++;
9309 }
9324 /* Optimize the common ldobj+stloc combination */
9339 }
9350 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9351 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9353 }
9356 }
9358 /* Optimize the ldobj+stobj combination */
9359 /* The reference case ends up being a load+store anyway */
9360 /* Skip this if the operation is volatile. */
9361 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass) && !(ins_flag & MONO_INST_VOLATILE)) {
9364 sp --;
9371 }
9378 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9379 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9381 }
9387 }
9397 }
9409 }
9420 /*
9421 * Avoid relocations in AOT and save some space by using a
9422 * version of helper_ldstr specialized to mscorlib.
9423 */
9427 /* Avoid creating the string object */
9431 }
9432 }
9433 else
9438 }
9444 OUT_OF_MEMORY_FAILURE;
9448 }
9449 }
9450 }
9452 sp++;
9458 MonoInst this_ins;
9466 LOAD_ERROR;
9469 LOAD_ERROR;
9481 CHECK_CFG_EXCEPTION;
9484 }
9486 if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
9489 }
9491 /*
9492 if (cfg->gsharedvt) {
9493 if (mini_is_gsharedvt_variable_signature (sig))
9494 GSHAREDVT_FAILURE (*ip);
9495 }
9496 */
9515 }
9516 }
9517 }
9522 /*
9523 * Generate smaller code for the common newobj <exception> instruction in
9524 * argument checking code.
9525 */
9552 }
9557 }
9559 /* move the args to allow room for 'this' in the first position */
9563 }
9565 /* check_call_signature () requires sp[0] to be set */
9569 UNVERIFIED;
9579 /* Avoid varargs in the common case */
9588 else
9593 /* we simply pass a null pointer */
9595 /* now call the string ctor */
9607 /*
9608 * The code generated by mini_emit_virtual_call () expects
9609 * iargs [0] to be a boxed instance, but luckily the vcall
9610 * will be transformed into a normal call there.
9611 */
9622 /*
9623 * TypeInitializationExceptions thrown from the mono_runtime_class_init
9624 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
9625 * As a workaround, we call class cctors before allocating objects.
9626 */
9627 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
9628 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, cmethod->klass, helper_sig_class_init_trampoline, NULL);
9630 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
9632 }
9636 }
9642 /* Now call the actual ctor */
9643 /* Avoid virtual calls to ctors if possible */
9648 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
9652 sp++;
9653 }
9655 CHECK_CFG_EXCEPTION;
9662 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
9669 // FIXME-VT: Clean this up
9673 }
9677 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
9684 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
9694 }
9695 }
9698 /* Valuetype */
9702 }
9703 else
9709 }
9718 UNVERIFIED;
9722 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9725 /* obj */
9728 /* klass */
9731 /* inline cache*/
9734 else
9737 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
9742 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9754 CHECK_CFG_EXCEPTION;
9764 }
9767 CHECK_CFG_EXCEPTION;
9771 }
9781 UNVERIFIED;
9785 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9789 /* obj */
9792 /* klass */
9795 /* inline cache*/
9798 else
9804 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9814 CHECK_CFG_EXCEPTION;
9824 }
9827 CHECK_CFG_EXCEPTION;
9831 }
9833 }
9848 sp ++;
9853 }
9856 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
9857 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9860 /* obj */
9863 /* klass */
9866 /* inline cache*/
9867 /*FIXME AOT support*/
9870 else
9873 /* The wrapper doesn't inline well so the bloat of inlining doesn't pay off. */
9877 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9887 CHECK_CFG_EXCEPTION;
9898 CHECK_CFG_EXCEPTION;
9902 }
9904 }
9911 }
9913 /* UNBOX */
9919 /* LDOBJ */
9925 }
9945 }
9948 UNVERIFIED;
9950 UNVERIFIED;
9951 /* frequent check in generic code: box (struct), brtrue */
9953 // FIXME: LLVM can't handle the inconsistent bb linking
9967 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9969 }
9975 ip++;
9977 ip++;
9982 ip++;
9988 }
9990 /*
9991 * We need to link both bblocks, since it is needed for handling stack
9992 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
9993 * Branching to only one of them would lead to inconsistencies, so
9994 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
9995 */
10006 }
10015 /* The JIT can't eliminate the iconst+compare */
10019 }
10023 }
10027 CHECK_CFG_EXCEPTION;
10031 }
10054 }
10058 }
10066 #ifndef DISABLE_REMOTING
10068 #endif
10069 guint foffset;
10070 gboolean is_instance;
10073 gboolean is_special_static;
10088 }
10090 UNVERIFIED;
10092 UNVERIFIED;
10096 sp--;
10098 }
10099 }
10106 }
10109 }
10111 LOAD_ERROR;
10113 FIELD_ACCESS_FAILURE;
10117 UNVERIFIED;
10119 /* if the class is Critical then transparent code cannot access it's fields */
10123 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
10124 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
10125 if (mono_security_core_clr_enabled ())
10126 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
10127 */
10129 /*
10130 * LDFLD etc. is usable on static fields as well, so convert those cases to
10131 * the static case.
10132 */
10146 }
10148 }
10152 /* INSTANCE CASE */
10157 UNVERIFIED;
10158 #ifndef DISABLE_REMOTING
10159 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
10175 CHECK_CFG_EXCEPTION;
10184 }
10186 #endif
10187 {
10200 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
10204 }
10208 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
10209 /* insert call to write barrier */
10216 }
10219 }
10223 }
10225 #ifndef DISABLE_REMOTING
10226 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
10227 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
10235 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
10239 CHECK_CFG_EXCEPTION;
10251 }
10253 #endif
10258 /* Have to compute the address of the variable */
10263 else
10268 }
10279 }
10290 }
10294 }
10309 }
10314 }
10315 }
10321 }
10323 /* STATIC CASE */
10325 /*
10326 * We can only support shared generic static
10327 * field access on architectures where the
10328 * trampoline code has been extended to handle
10329 * the generic class init.
10330 */
10331 #ifndef MONO_ARCH_VTABLE_REG
10333 #endif
10340 UNVERIFIED;
10342 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
10343 * to be called here.
10344 */
10348 }
10358 else
10361 /* Generate IR to compute the field address */
10362 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
10363 /*
10364 * Fast access to TLS data
10365 * Inline version of get_thread_static_data () in
10366 * threads.c.
10367 */
10368 guint32 offset;
10373 // offset &= 0x7fffffff;
10374 // idx = (offset >> 24) - 1;
10375 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
10378 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
10383 /* For TLS variables, this will return the TLS offset */
10406 }
10419 }
10424 /*
10425 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
10426 method->klass->name_space, method->klass->name, method->name,
10427 depth, field->offset);
10428 */
10433 /*
10434 * The pointer we're computing here is
10435 *
10436 * super_info.static_data + field->offset
10437 */
10452 }
10470 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, klass, helper_sig_class_init_trampoline, NULL);
10472 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
10474 }
10478 /* This makes so that inline cannot trigger */
10479 /* .cctors: too many apps depend on them */
10480 /* running with a specific order... */
10488 }
10489 }
10490 }
10498 }
10503 }
10504 }
10506 /* Generate IR to do the actual load/store operation */
10509 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10510 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10512 }
10531 }
10532 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
10533 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
10539 }
10543 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
10549 sp++;
10553 sp++;
10558 sp++;
10562 sp++;
10567 sp++;
10571 sp++;
10579 sp++;
10589 sp++;
10592 }
10597 sp++;
10605 }
10606 }
10617 }
10618 }
10621 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10622 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10624 }
10629 }
10638 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10639 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10641 }
10642 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
10647 /* insert call to write barrier */
10649 }
10655 /*
10656 * Array opcodes
10657 */
10662 guint32 field_token;
10682 }
10689 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
10691 /* vtable */
10694 /* array len */
10699 else
10703 /* Decompose now to avoid problems with references to the domainvar */
10712 /* Decompose later since it is needed by abcrem */
10727 /* Needed so mono_emit_load_get_addr () gets called */
10729 }
10730 }
10737 /*
10738 * we inline/optimize the initialization sequence if possible.
10739 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
10740 * for small sizes open code the memcpy
10741 * ensure the rva field is big enough
10742 */
10743 if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, bblock, ip + 6) && (len_ins->opcode == OP_ICONST) && (data_ptr = initialize_array_data (method, cfg->compile_aot, ip, klass, len_ins->inst_c0, &data_size, &field_token))) {
10748 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
10750 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
10753 }
10757 }
10760 }
10765 UNVERIFIED;
10771 /* This flag will be inherited by the decomposition */
10776 ip ++;
10784 UNVERIFIED;
10790 /* we need to make sure that this array is exactly the type it needs
10791 * to be for correctness. the wrappers are lax with their usage
10792 * so we need to ignore them here
10793 */
10798 }
10828 }
10829 else
10833 UNVERIFIED;
10838 // FIXME-VT: OP_ICONST optimization
10845 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
10852 }
10856 else
10859 }
10880 }
10881 else
10885 UNVERIFIED;
10891 else
10895 }
10910 }
10929 // FIXME:
10932 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
10934 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
10942 // FIXME:
10947 }
10948 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
10953 }
10969 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
10977 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
10978 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
10979 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10985 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
10986 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
10987 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10989 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
10990 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), klass);
10991 }
10992 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
11000 }
11002 gpointer handle;
11016 }
11019 }
11021 LOAD_ERROR;
11026 /* This case handles ldtoken
11027 of an open type, like for
11028 typeof(Gen<>). */
11031 /* If we get a MONO_TYPE_CLASS
11032 then we need to provide the
11033 open type, not an
11034 instantiation of it. */
11037 else
11043 else
11045 }
11066 }
11087 /* Special case for static synchronized wrappers */
11088 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
11090 /* FIXME: n is not a normal token */
11093 }
11096 }
11099 }
11112 MONO_RGCTX_INFO_TYPE);
11121 }
11126 }
11130 }
11131 }
11136 }
11142 ip++;
11153 /* mono_save_seq_point_info () depends on this */
11158 ip++;
11161 /*
11162 * Control will leave the method so empty the stack, otherwise
11163 * the next basic block will start with a nonempty stack.
11164 */
11166 sp--;
11167 }
11179 }
11181 /* empty the stack */
11183 sp--;
11184 }
11186 /*
11187 * If this leave statement is in a catch block, check for a
11188 * pending exception, and rethrow it if necessary.
11189 * We avoid doing this in runtime invoke wrappers, since those are called
11190 * by native code which excepts the wrapper to catch all exceptions.
11191 */
11195 /*
11196 * Use <= in the final comparison to handle clauses with multiple
11197 * leave statements, like in bug #78024.
11198 * The ordering of the exception clauses guarantees that we find the
11199 * innermost clause.
11200 */
11201 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) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
11205 /*
11206 MonoInst *load;
11208 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
11209 */
11215 /*
11216 * Currently, we always rethrow the abort exception, despite the
11217 * fact that this is not correct. See thread6.cs for an example.
11218 * But propagating the abort exception is more important than
11219 * getting the sematics right.
11220 */
11227 }
11228 }
11247 /*
11248 * Link the finally bblock with the target, since it will
11249 * conceptually branch there.
11250 * FIXME: Have to link the bblock containing the endfinally.
11251 */
11254 }
11255 }
11257 }
11268 else
11272 }
11274 /*
11275 * Mono specific opcodes
11276 */
11284 gpointer func;
11305 }
11307 gpointer ptr;
11314 /* FIXME: Generalize this */
11320 }
11325 /* Can't embed random pointers into AOT code */
11328 }
11331 gpointer ptr;
11345 }
11348 gpointer ptr;
11362 }
11366 }
11373 // FIXME:
11379 }
11396 }
11409 /*
11410 * Similar to LDOBJ, but instead load the unmanaged
11411 * representation of the vtype to the stack.
11412 */
11421 {
11436 }
11439 /*
11440 * Same as RET, but return the native representation of a vtype
11441 * to the caller.
11442 */
11458 }
11462 UNVERIFIED;
11471 }
11482 else
11488 }
11491 #ifdef MONO_ARCH_HAVE_LMF_OPS
11495 #endif
11528 }
11529 }
11535 }
11539 /* It would be easier to call a trampoline, but that would put an
11540 * extra frame on the stack, confusing exception handling. So
11541 * implement it inline using an opcode for now.
11542 */
11545 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
11546 /* prevent it from being register allocated */
11548 }
11550 /* Has to use a call inst since it local regalloc expects it */
11564 }
11570 }
11576 cfg->orig_domain_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
11581 #if TARGET_WIN32
11584 #else
11587 #endif
11599 }
11602 /* AOT code is only used in the root domain */
11606 }
11613 }
11616 }
11620 /* Restore the original domain */
11626 }
11630 }
11632 }
11638 /* somewhat similar to LDTOKEN */
11641 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
11652 }
11660 /*
11661 * The following transforms:
11662 * CEE_CEQ into OP_CEQ
11663 * CEE_CGT into OP_CGT
11664 * CEE_CGT_UN into OP_CGT_UN
11665 * CEE_CLT into OP_CLT
11666 * CEE_CLT_UN into OP_CLT_UN
11667 */
11676 if ((sp [0]->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
11680 else
11688 /*
11689 * The backends expect the fceq opcodes to do the
11690 * comparison too.
11691 */
11695 }
11700 }
11710 LOAD_ERROR;
11718 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
11719 METHOD_ACCESS_FAILURE;
11724 CHECK_CFG_EXCEPTION;
11727 }
11729 /*
11730 * Optimize the common case of ldftn+delegate creation
11731 */
11732 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
11733 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
11741 LOAD_ERROR;
11751 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
11752 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
11755 }
11756 }
11758 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
11759 /* FIXME: SGEN support */
11763 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11764 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used))) {
11765 sp --;
11767 CHECK_CFG_EXCEPTION;
11769 sp ++;
11771 }
11773 }
11774 #endif
11775 }
11776 }
11785 }
11794 LOAD_ERROR;
11802 CHECK_CFG_EXCEPTION;
11805 }
11815 else
11821 }
11848 UNVERIFIED;
11872 }
11878 }
11886 UNVERIFIED;
11895 UNVERIFIED;
11897 /*
11898 * Inlining this into a loop in a parent could lead to
11899 * stack overflows which is different behavior than the
11900 * non-inlined case, thus disable inlining in this case.
11901 */
11924 UNVERIFIED;
11936 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
11940 }
11941 }
11944 UNVERIFIED;
11947 }
11950 /* FIXME: record alignment? we can assume 1 for now */
11961 /* Can't inline tail calls at this time */
11974 else
11992 /* Skip optimized paths for volatile operations. */
11993 if ((ip [1] == CEE_CPBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
11995 } else if ((ip [1] == CEE_INITBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5) && (sp [1]->opcode == OP_ICONST) && (sp [1]->inst_c0 == 0)) {
11996 /* emit_memset only works when val == 0 */
12004 /*
12005 * FIXME: It's unclear whether we should be emitting both the acquire
12006 * and release barriers for cpblk. It is technically both a load and
12007 * store operation, so it seems like that's the sensible thing to do.
12008 */
12011 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
12012 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12014 }
12018 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
12019 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12021 }
12025 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
12026 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12028 }
12031 }
12032 }
12037 }
12044 /* we ignore the no-nullcheck for now since we
12045 * really do it explicitly only when doing callvirt->call
12046 */
12055 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
12058 }
12059 }
12064 UNVERIFIED;
12079 }
12081 guint32 val;
12089 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (method->klass->image) && !generic_context) {
12097 }
12102 }
12111 // FIXME:
12114 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12116 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
12120 }
12131 UNVERIFIED;
12135 UNVERIFIED;
12136 }
12138 }
12141 UNVERIFIED;
12145 UNVERIFIED;
12146 }
12147 }
12149 UNVERIFIED;
12153 /* This could already be set because of inlining, #693905 */
12161 }
12173 }
12176 }
12178 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
12180 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
12182 #endif
12192 }
12193 }
12196 /* Emit initialization for ref vars */
12197 // FIXME: Avoid duplication initialization for IL locals.
12203 }
12204 }
12209 }
12217 /*
12218 * Make seq points at backward branch targets interruptable.
12219 */
12223 }
12225 /* Add a sequence point for method entry/exit events */
12231 }
12233 /*
12234 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
12235 * the code they refer to was dead (#11880).
12236 */
12239 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
12244 }
12245 }
12246 }
12258 }
12259 }
12267 /* Method is too large */
12275 }
12284 exception_exit:
12288 inline_failure:
12291 load_error:
12295 unverified:
12299 cleanup:
12305 }
12307 static int
12309 {
12323 }
12326 }
12328 int
12330 {
12375 #if SIZEOF_REGISTER == 8
12378 #endif
12396 #if defined(TARGET_X86) || defined (TARGET_AMD64)
12401 #endif
12402 #if defined(TARGET_AMD64)
12405 #endif
12416 }
12419 }
12421 static int
12423 {
12449 }
12452 }
12454 static int
12456 {
12475 }
12478 }
12480 int
12482 {
12483 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
12484 #if defined(TARGET_X86) || defined(TARGET_AMD64)
12496 #if SIZEOF_REGISTER == 8
12499 #endif
12500 }
12501 #endif
12504 }
12508 {
12509 #if defined(TARGET_X86)
12541 }
12542 #endif
12544 #if defined(TARGET_AMD64)
12545 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
12596 }
12597 #endif
12600 }
12604 {
12605 #if defined(TARGET_X86) || defined(TARGET_AMD64)
12613 }
12614 #endif
12617 }
12621 {
12622 #ifdef TARGET_X86
12623 /* FIXME: This has sign extension issues */
12624 /*
12625 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
12626 return OP_X86_COMPARE_MEMBASE8_IMM;
12627 */
12629 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
12641 }
12642 #endif
12644 #ifdef TARGET_AMD64
12645 /* FIXME: This has sign extension issues */
12646 /*
12647 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
12648 return OP_X86_COMPARE_MEMBASE8_IMM;
12649 */
12653 #ifdef __mono_ilp32__
12655 #else
12657 #endif
12660 /* FIXME: This only works for 32 bit immediates
12661 case OP_COMPARE_IMM:
12662 case OP_LCOMPARE_IMM:
12663 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
12664 return OP_AMD64_COMPARE_MEMBASE_IMM;
12665 */
12672 #ifdef __mono_ilp32__
12676 #else
12678 #endif
12685 }
12686 #endif
12689 }
12693 {
12694 #ifdef TARGET_X86
12695 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
12712 }
12713 #endif
12715 #ifdef TARGET_AMD64
12716 #ifdef __mono_ilp32__
12717 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE) ) {
12718 #else
12720 #endif
12734 }
12735 #ifdef __mono_ilp32__
12737 #else
12739 #endif
12754 }
12755 }
12756 #endif
12759 }
12761 int
12763 {
12765 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
12770 #endif
12771 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
12777 #endif
12778 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
12781 #endif
12784 }
12785 }
12787 /**
12788 * mono_handle_global_vregs:
12789 *
12790 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
12791 * for them.
12792 */
12793 void
12795 {
12802 #ifdef MONO_ARCH_SIMD_INTRINSICS
12805 #endif
12807 /* Find local vregs used in more than one bb */
12819 gint32 prev_bb;
12849 }
12851 #if SIZEOF_REGISTER == 4
12852 /* In the LLVM case, the long opcodes are not decomposed */
12854 /*
12855 * Since some instructions reference the original long vreg,
12856 * and some reference the two component vregs, it is quite hard
12857 * to determine when it needs to be global. So be conservative.
12858 */
12860 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
12864 }
12866 /*
12867 * Make the component vregs volatile since the optimizations can
12868 * get confused otherwise.
12869 */
12872 }
12873 #endif
12879 /* 0 is a valid block num */
12882 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
12892 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
12893 else
12897 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
12900 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
12907 }
12908 }
12910 /* Flag as having been used in more than one bb */
12912 }
12913 }
12914 }
12915 }
12917 /* If a variable is used in only one bblock, convert it into a local vreg */
12928 #if SIZEOF_REGISTER == 8
12930 #endif
12931 #if !defined(TARGET_X86)
12932 /* Enabling this screws up the fp stack on x86 */
12934 #endif
12938 /* Arguments are implicitly global */
12939 /* Putting R4 vars into registers doesn't work currently */
12940 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
12941 if ((var->opcode != OP_ARG) && (var != cfg->ret) && !(var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && (vreg_to_bb [var->dreg] != -1) && (var->klass->byval_arg.type != MONO_TYPE_R4) && !cfg->disable_vreg_to_lvreg && var != cfg->gsharedvt_info_var && var != cfg->gsharedvt_locals_var && var != cfg->lmf_addr_var) {
12942 /*
12943 * Make that the variable's liveness interval doesn't contain a call, since
12944 * that would cause the lvreg to be spilled, making the whole optimization
12945 * useless.
12946 */
12947 /* This is too slow for JIT compilation */
12948 #if 0
12968 }
12969 }
12974 ins_index ++;
12975 }
12979 }
12980 #endif
12986 }
12988 }
12989 }
12991 /*
12992 * Compress the varinfo and vars tables so the liveness computation is faster and
12993 * takes up less space.
12994 */
13006 #if SIZEOF_REGISTER == 4
13008 /* Modify the two component vars too */
13015 }
13016 #endif
13017 }
13018 pos ++;
13019 }
13020 }
13024 }
13026 /**
13027 * mono_spill_global_vars:
13028 *
13029 * Generate spill code for variables which are not allocated to registers,
13030 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
13031 * code is generated which could be optimized by the local optimization passes.
13032 */
13033 void
13035 {
13052 /* FIXME: Move this function to mini.c */
13056 #ifdef MONO_ARCH_SIMD_INTRINSICS
13058 #endif
13060 #if SIZEOF_REGISTER == 4
13061 /* Create MonoInsts for longs */
13088 }
13091 }
13092 }
13093 }
13094 #endif
13097 /* registers need liveness info even for !non refs */
13103 }
13104 }
13115 /* Local */
13121 /* Arg */
13124 }
13125 }
13126 }
13127 }
13129 /* FIXME: widening and truncation */
13131 /*
13132 * As an optimization, when a variable allocated to the stack is first loaded into
13133 * an lvreg, we will remember the lvreg and use it the next time instead of loading
13134 * the variable again.
13135 */
13141 /*
13142 * These arrays contain the first and last instructions accessing a given
13143 * variable.
13144 * Since we emit bblocks in the same order we process them here, and we
13145 * don't split live ranges, these will precisely describe the live range of
13146 * the variable, i.e. the instruction range where a valid value can be found
13147 * in the variables location.
13148 * The live range is computed using the liveness info computed by the liveness pass.
13149 * We can't use vmv->range, since that is an abstract live range, and we need
13150 * one which is instruction precise.
13151 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
13152 */
13153 /* FIXME: Only do this if debugging info is requested */
13159 /* Add spill loads/stores */
13166 /* Clear vreg_to_lvreg array */
13184 /*
13185 * We handle LDADDR here as well, since it can only be decomposed
13186 * when variable addresses are known.
13187 */
13192 /* Happens on SPARC/S390 where vtypes are passed by reference */
13197 }
13203 NOT_IMPLEMENTED;
13205 /* gsharedvt arg passed by ref */
13218 /*
13219 * gsharedvt local.
13220 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
13221 */
13228 /* Mark the instruction used to compute the locals var as used */
13231 /* Load the offset */
13234 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
13240 }
13242 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
13243 /* Load the locals area address */
13246 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
13251 }
13252 /* Compute the address */
13267 }
13271 }
13276 }
13278 /*
13279 * Store opcodes have destbasereg in the dreg, but in reality, it is an
13280 * src register.
13281 * FIXME:
13282 */
13296 else
13306 }
13308 /***************/
13309 /* DREG */
13310 /***************/
13312 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
13326 } else if ((ins->dreg == ins->sreg1) && (spec [MONO_INST_DEST] == 'i') && (spec [MONO_INST_SRC1] == 'i') && !vreg_to_lvreg [ins->dreg] && (op_to_op_dest_membase (store_opcode, ins->opcode) != -1)) {
13327 /*
13328 * Instead of emitting a load+store, use a _membase opcode.
13329 */
13339 }
13342 guint32 lvreg;
13348 /* Invalidate any previous lvreg for this vreg */
13356 }
13360 #if SIZEOF_REGISTER != 8
13362 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
13364 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
13367 }
13368 else
13369 #endif
13370 {
13373 /* Try to fuse the store into the instruction itself */
13374 /* FIXME: Add more instructions */
13375 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
13381 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
13399 // FIXME: The backends expect the base reg to be in inst_basereg
13406 /* printf ("INS: "); mono_print_ins (ins); */
13407 /* Create a store instruction */
13408 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
13410 /* Insert it after the instruction */
13415 /*
13416 * We can't assign ins->dreg to var->dreg here, since the
13417 * sregs could use it. So set a flag, and do it after
13418 * the sregs.
13419 */
13420 if ((!MONO_ARCH_USE_FPSTACK || ((store_opcode != OP_STORER8_MEMBASE_REG) && (store_opcode != OP_STORER4_MEMBASE_REG))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)))
13422 }
13423 }
13424 }
13429 }
13437 }
13438 }
13440 /************/
13441 /* SREGS */
13442 /************/
13453 guint32 load_opcode;
13457 //mono_inst_set_src_registers (ins, sregs);
13461 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
13465 /* var->dreg is a hreg */
13468 }
13471 }
13482 /* The variable is already loaded to an lvreg */
13486 //mono_inst_set_src_registers (ins, sregs);
13488 }
13490 /* Try to fuse the load into the instruction */
13494 //mono_inst_set_src_registers (ins, sregs);
13499 //mono_inst_set_src_registers (ins, sregs);
13506 //printf ("%d ", srcindex); mono_print_ins (ins);
13510 if ((!MONO_ARCH_USE_FPSTACK || ((load_opcode != OP_LOADR8_MEMBASE) && (load_opcode != OP_LOADR4_MEMBASE))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && !no_lvreg) {
13512 /*
13513 * sreg refers to the value loaded by the load
13514 * emitted below, but we need to use ins->dreg
13515 * since it refers to the store emitted earlier.
13516 */
13518 }
13523 }
13524 }
13527 //mono_inst_set_src_registers (ins, sregs);
13529 #if SIZEOF_REGISTER != 8
13531 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
13533 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
13536 }
13537 else
13538 #endif
13539 {
13540 #if SIZEOF_REGISTER == 4
13542 #endif
13546 }
13547 }
13552 }
13554 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
13560 }
13561 }
13562 }
13571 }
13577 }
13580 /* Clear vreg_to_lvreg array */
13587 }
13591 }
13593 /* Extend the live range based on the liveness info */
13599 /* The liveness info is incomplete */
13603 /* Live from at least the first ins of this bb */
13606 }
13609 /* Live at least until the last ins of this bb */
13612 }
13613 }
13614 }
13615 }
13617 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
13618 /*
13619 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
13620 * by storing the current native offset into MonoMethodVar->live_range_start/end.
13621 */
13632 }
13639 else
13641 }
13642 }
13643 }
13644 #endif
13647 /* Nullify if unused */
13650 }
13656 }
13658 /**
13659 * FIXME:
13660 * - use 'iadd' instead of 'int_add'
13661 * - handling ovf opcodes: decompose in method_to_ir.
13662 * - unify iregs/fregs
13663 * -> partly done, the missing parts are:
13664 * - a more complete unification would involve unifying the hregs as well, so
13665 * code wouldn't need if (fp) all over the place. but that would mean the hregs
13666 * would no longer map to the machine hregs, so the code generators would need to
13667 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
13668 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
13669 * fp/non-fp branches speeds it up by about 15%.
13670 * - use sext/zext opcodes instead of shifts
13671 * - add OP_ICALL
13672 * - get rid of TEMPLOADs if possible and use vregs instead
13673 * - clean up usage of OP_P/OP_ opcodes
13674 * - cleanup usage of DUMMY_USE
13675 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
13676 * stack
13677 * - set the stack type and allocate a dreg in the EMIT_NEW macros
13678 * - get rid of all the <foo>2 stuff when the new JIT is ready.
13679 * - make sure handle_stack_args () is called before the branch is emitted
13680 * - when the new IR is done, get rid of all unused stuff
13681 * - COMPARE/BEQ as separate instructions or unify them ?
13682 * - keeping them separate allows specialized compare instructions like
13683 * compare_imm, compare_membase
13684 * - most back ends unify fp compare+branch, fp compare+ceq
13685 * - integrate mono_save_args into inline_method
13686 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
13687 * - handle long shift opts on 32 bit platforms somehow: they require
13688 * 3 sregs (2 for arg1 and 1 for arg2)
13689 * - make byref a 'normal' type.
13690 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
13691 * variable if needed.
13692 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
13693 * like inline_method.
13694 * - remove inlining restrictions
13695 * - fix LNEG and enable cfold of INEG
13696 * - generalize x86 optimizations like ldelema as a peephole optimization
13697 * - add store_mem_imm for amd64
13698 * - optimize the loading of the interruption flag in the managed->native wrappers
13699 * - avoid special handling of OP_NOP in passes
13700 * - move code inserting instructions into one function/macro.
13701 * - try a coalescing phase after liveness analysis
13702 * - add float -> vreg conversion + local optimizations on !x86
13703 * - figure out how to handle decomposed branches during optimizations, ie.
13704 * compare+branch, op_jump_table+op_br etc.
13705 * - promote RuntimeXHandles to vregs
13706 * - vtype cleanups:
13707 * - add a NEW_VARLOADA_VREG macro
13708 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
13709 * accessing vtype fields.
13710 * - get rid of I8CONST on 64 bit platforms
13711 * - dealing with the increase in code size due to branches created during opcode
13712 * decomposition:
13713 * - use extended basic blocks
13714 * - all parts of the JIT
13715 * - handle_global_vregs () && local regalloc
13716 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
13717 * - sources of increase in code size:
13718 * - vtypes
13719 * - long compares
13720 * - isinst and castclass
13721 * - lvregs not allocated to global registers even if used multiple times
13722 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
13723 * meaningful.
13724 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
13725 * - add all micro optimizations from the old JIT
13726 * - put tree optimizations into the deadce pass
13727 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
13728 * specific function.
13729 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
13730 * fcompare + branchCC.
13731 * - create a helper function for allocating a stack slot, taking into account
13732 * MONO_CFG_HAS_SPILLUP.
13733 * - merge r68207.
13734 * - merge the ia64 switch changes.
13735 * - optimize mono_regstate2_alloc_int/float.
13736 * - fix the pessimistic handling of variables accessed in exception handler blocks.
13737 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
13738 * parts of the tree could be separated by other instructions, killing the tree
13739 * arguments, or stores killing loads etc. Also, should we fold loads into other
13740 * instructions if the result of the load is used multiple times ?
13741 * - make the REM_IMM optimization in mini-x86.c arch-independent.
13742 * - LAST MERGE: 108395.
13743 * - when returning vtypes in registers, generate IR and append it to the end of the
13744 * last bb instead of doing it in the epilog.
13745 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
13746 */
13748 /*
13750 NOTES
13751 -----
13753 - When to decompose opcodes:
13754 - earlier: this makes some optimizations hard to implement, since the low level IR
13755 no longer contains the neccessary information. But it is easier to do.
13756 - later: harder to implement, enables more optimizations.
13757 - Branches inside bblocks:
13758 - created when decomposing complex opcodes.
13759 - branches to another bblock: harmless, but not tracked by the branch
13760 optimizations, so need to branch to a label at the start of the bblock.
13761 - branches to inside the same bblock: very problematic, trips up the local
13762 reg allocator. Can be fixed by spitting the current bblock, but that is a
13763 complex operation, since some local vregs can become global vregs etc.
13764 - Local/global vregs:
13765 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
13766 local register allocator.
13767 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
13768 structure, created by mono_create_var (). Assigned to hregs or the stack by
13769 the global register allocator.
13770 - When to do optimizations like alu->alu_imm:
13771 - earlier -> saves work later on since the IR will be smaller/simpler
13772 - later -> can work on more instructions
13773 - Handling of valuetypes:
13774 - When a vtype is pushed on the stack, a new temporary is created, an
13775 instruction computing its address (LDADDR) is emitted and pushed on
13776 the stack. Need to optimize cases when the vtype is used immediately as in
13777 argument passing, stloc etc.
13778 - Instead of the to_end stuff in the old JIT, simply call the function handling
13779 the values on the stack before emitting the last instruction of the bb.
13780 */