| blob | a186c9849332574c3ab4cf49598961275e40c2f6 |
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/assembly.h>
38 #include <mono/metadata/attrdefs.h>
39 #include <mono/metadata/loader.h>
40 #include <mono/metadata/tabledefs.h>
41 #include <mono/metadata/class.h>
42 #include <mono/metadata/object.h>
43 #include <mono/metadata/exception.h>
44 #include <mono/metadata/opcodes.h>
45 #include <mono/metadata/mono-endian.h>
46 #include <mono/metadata/tokentype.h>
47 #include <mono/metadata/tabledefs.h>
48 #include <mono/metadata/marshal.h>
49 #include <mono/metadata/debug-helpers.h>
50 #include <mono/metadata/mono-debug.h>
51 #include <mono/metadata/gc-internal.h>
52 #include <mono/metadata/security-manager.h>
53 #include <mono/metadata/threads-types.h>
54 #include <mono/metadata/security-core-clr.h>
55 #include <mono/metadata/monitor.h>
56 #include <mono/metadata/profiler-private.h>
57 #include <mono/metadata/profiler.h>
58 #include <mono/metadata/debug-mono-symfile.h>
59 #include <mono/utils/mono-compiler.h>
60 #include <mono/utils/mono-memory-model.h>
61 #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, G_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, G_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, G_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, G_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, G_STRUCT_OFFSET (MonoClass, idepth));
1595 }
1596 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_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, G_STRUCT_OFFSET (MonoClass, rank));
1695 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1696 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
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, G_STRUCT_OFFSET (MonoClass, idepth));
1732 }
1733 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_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, G_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, G_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, G_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, G_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, G_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, G_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 #ifdef MONO_ARCH_HAVE_IMT
2348 /* Either METHOD or IMT_ARG needs to be set */
2349 static void
2350 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2351 {
2367 }
2369 #ifdef ENABLE_LLVM
2371 #endif
2372 #ifdef MONO_ARCH_IMT_REG
2374 #else
2375 /* Need this to keep the IMT arg alive */
2377 #endif
2379 }
2381 #ifdef MONO_ARCH_IMT_REG
2394 }
2397 #else
2399 #endif
2400 }
2401 #endif
2405 {
2413 }
2415 static int
2417 {
2420 else
2422 }
2424 static int
2426 {
2429 else
2431 }
2433 /*
2434 * check_method_sharing:
2435 *
2436 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2437 */
2438 static void
2439 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2440 {
2456 }
2458 /*
2459 * Pass vtable iff target method might
2460 * be shared, which means that sharing
2461 * is enabled for its class and its
2462 * context is sharable (and it's not a
2463 * generic method).
2464 */
2465 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2467 }
2484 }
2485 }
2491 }
2496 {
2499 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2501 #endif
2508 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2520 //g_assert_not_reached ();
2521 }
2528 /*
2529 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2530 * address of return value to increase optimization opportunities.
2531 * Before vtype decomposition, the dreg of the call ins itself represents the
2532 * fact the call modifies the return value. After decomposition, the call will
2533 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2534 * will be transformed into an LDADDR.
2535 */
2539 /* We reference the call too since call->dreg could change during optimization */
2549 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2551 /*
2552 * If the call has a float argument, we would need to do an r8->r4 conversion using
2553 * an icall, but that cannot be done during the call sequence since it would clobber
2554 * the call registers + the stack. So we do it before emitting the call.
2555 */
2562 else
2573 /* The result will be in an int vreg */
2575 }
2576 }
2577 }
2578 #endif
2582 #ifdef ENABLE_LLVM
2585 else
2587 #else
2589 #endif
2595 }
2597 static void
2599 {
2600 #ifdef MONO_ARCH_RGCTX_REG
2604 #ifdef ENABLE_LLVM
2606 #endif
2607 #else
2608 NOT_IMPLEMENTED;
2609 #endif
2610 }
2613 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2614 {
2620 if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2625 }
2630 }
2634 cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2639 }
2641 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2659 /* Restore the stack so we don't crash when throwing the exception */
2666 }
2672 }
2675 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2678 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2680 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2683 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2685 {
2686 #ifndef DISABLE_REMOTING
2688 #endif
2694 gboolean need_unbox_trampoline;
2702 }
2705 /* Create the real signature */
2706 /* FIXME: Cache these */
2711 }
2715 #ifndef DISABLE_REMOTING
2725 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2728 }
2729 #endif
2731 need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
2733 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2735 #ifndef DISABLE_REMOTING
2738 else
2739 #endif
2751 if (ARCH_HAVE_DELEGATE_TRAMPOLINES && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2756 /* Make a call to delegate->invoke_impl */
2761 /* We must emit a dummy use here because the delegate trampoline will
2762 replace the 'this' argument with the delegate target making this activation
2763 no longer a root for the delegate.
2764 This is an issue for delegates that target collectible code such as dynamic
2765 methods of GC'able assemblies.
2767 For a test case look into #667921.
2769 FIXME: a dummy use is not the best way to do it as the local register allocator
2770 will put it on a caller save register and spil it around the call.
2771 Ideally, we would either put it on a callee save register or only do the store part.
2772 */
2776 }
2783 /*
2784 * the method is not virtual, we just need to ensure this is not null
2785 * and then we can call the method directly.
2786 */
2787 #ifndef DISABLE_REMOTING
2788 if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2789 /*
2790 * The check above ensures method is not gshared, this is needed since
2791 * gshared methods can't have wrappers.
2792 */
2794 }
2795 #endif
2802 /*
2803 * the method is virtual, but we can statically dispatch since either
2804 * it's class or the method itself are sealed.
2805 * But first we need to ensure it's not a null reference.
2806 */
2812 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2815 #ifdef MONO_ARCH_HAVE_IMT
2821 }
2822 #endif
2827 }
2832 #ifdef MONO_ARCH_HAVE_IMT
2836 }
2837 #endif
2838 }
2843 }
2844 }
2852 }
2854 MonoInst*
2856 {
2857 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this, NULL, NULL);
2858 }
2860 MonoInst*
2863 {
2874 }
2876 MonoInst*
2878 {
2884 }
2886 /*
2887 * mono_emit_abs_call:
2888 *
2889 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2890 */
2894 {
2898 /*
2899 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2900 * handle it.
2901 */
2908 }
2912 {
2917 /*
2918 * Native code might return non register sized integers
2919 * without initializing the upper bits.
2920 */
2936 }
2945 }
2946 }
2947 }
2950 }
2954 {
2960 }
2962 }
2964 static void
2965 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
2966 {
2983 }
2984 }
2985 }
2987 static void
2989 {
2991 gpointer card_table_mask;
3005 #ifdef MONO_ARCH_HAVE_CARD_TABLE_WBARRIER
3007 #endif
3009 if (has_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3025 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3026 * IMM's larger than 32bits.
3027 */
3035 }
3042 }
3045 }
3047 static gboolean
3048 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3049 {
3056 /*types with references can't have alignment smaller than sizeof(void*) */
3060 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3066 /* We don't unroll more than 5 stores to avoid code bloat. */
3068 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3076 }
3085 /*tmp = dreg*/
3105 /*tmp += sizeof (void*)*/
3109 }
3110 }
3112 /* Those cannot be references since size < sizeof (void*) */
3118 }
3125 }
3132 }
3135 }
3137 /*
3138 * Emit code to copy a valuetype of type @klass whose address is stored in
3139 * @src->dreg to memory whose address is stored at @dest->dreg.
3140 */
3141 void
3142 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3143 {
3152 /*
3153 * This check breaks with spilled vars... need to handle it during verification anyway.
3154 * g_assert (klass && klass == src->klass && klass == dest->klass);
3155 */
3162 }
3166 else
3169 /* if native is true there should be no references in the struct */
3171 /* Avoid barriers when storing to the stack */
3181 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3182 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3192 }
3193 }
3197 else
3200 }
3201 }
3204 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3211 else
3217 else
3219 }
3220 }
3224 {
3230 }
3232 }
3234 void
3236 {
3239 guint32 align;
3245 /* FIXME: Optimize this for the case when dest is an LDADDR */
3253 bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3259 }
3265 }
3272 }
3273 }
3277 {
3310 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3312 }
3320 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3322 }
3323 }
3326 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3327 {
3337 }
3341 {
3342 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3343 }
3348 {
3349 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);
3353 }
3358 {
3359 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);
3363 }
3368 {
3377 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);
3381 }
3387 {
3391 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);
3395 }
3397 /*
3398 * emit_get_rgctx_method:
3399 *
3400 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3401 * normal constants, else emit a load from the rgctx.
3402 */
3406 {
3419 }
3421 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);
3425 }
3426 }
3431 {
3432 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);
3436 }
3438 static int
3440 {
3450 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3452 }
3458 new_entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3460 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3463 }
3473 }
3475 /*
3476 * emit_get_gsharedvt_info:
3477 *
3478 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3479 */
3482 {
3487 /* Load info->entries [idx] */
3489 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, G_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3492 }
3495 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3496 {
3498 }
3500 /*
3501 * On return the caller must check @klass for load errors.
3502 */
3503 static void
3505 {
3521 }
3524 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
3525 else
3526 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
3527 #ifdef MONO_ARCH_VTABLE_REG
3530 #else
3531 NOT_IMPLEMENTED;
3532 #endif
3533 }
3535 static void
3536 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3537 {
3545 }
3546 }
3548 static void
3549 save_cast_details (MonoCompile *cfg, MonoClass *klass, int obj_reg, gboolean null_check, MonoBasicBlock **out_bblock)
3550 {
3563 }
3569 }
3575 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3577 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3583 }
3584 }
3585 }
3587 static void
3589 {
3590 /* Reset the variables holding the cast details */
3595 /* It is enough to reset the from field */
3596 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3597 }
3598 }
3600 /*
3601 * On return the caller must check @array_class for load errors
3602 */
3603 static void
3605 {
3613 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3624 }
3645 }
3646 }
3651 }
3653 /**
3654 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3655 * generic code is generated.
3656 */
3659 {
3665 /* FIXME: What if the class is shared? We might not
3666 have to get the address of the method from the
3667 RGCTX. */
3669 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3686 }
3689 }
3690 }
3694 {
3703 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3704 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3706 /* FIXME: generics */
3709 // Check rank == 0
3714 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3719 /* This assertion is from the unboxcast insn */
3731 }
3733 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
3739 }
3742 handle_unbox_gsharedvt (MonoCompile *cfg, MonoClass *klass, MonoInst *obj, MonoBasicBlock **out_cbb)
3743 {
3751 /* obj */
3754 /* klass */
3757 /* CASTCLASS */
3770 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
3773 /* Non-ref case */
3774 /* UNBOX */
3780 /* Ref case */
3783 /* Save the ref to a temporary */
3790 /* Nullable case */
3793 {
3794 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
3801 unbox_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
3809 }
3813 /* End */
3816 /* LDOBJ */
3822 }
3824 /*
3825 * Returns NULL and set the cfg exception on error.
3826 */
3829 {
3842 else
3853 }
3859 }
3866 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3867 /* This happens often in argument checking code, eg. throw new FooException... */
3868 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3874 gboolean pass_lw;
3880 }
3882 #ifndef MONO_CROSS_COMPILE
3884 #endif
3889 }
3896 }
3899 }
3900 }
3903 }
3905 /*
3906 * Returns NULL and set the cfg exception on error.
3907 */
3909 handle_box (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used, MonoBasicBlock **out_cbb)
3910 {
3919 /* FIXME: What if the class is shared? We might not
3920 have to get the method address from the RGCTX. */
3922 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3938 }
3941 }
3942 }
3961 /* Non-ref case */
3965 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3973 /* Ref case */
3977 /* val is a vtype, so has to load the value manually */
3985 /* Nullable case */
3988 {
3990 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
3994 /*
3995 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
3996 * construct that method at JIT time, so have to do things by hand.
3997 */
3998 box_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4006 }
4020 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4022 }
4023 }
4026 static gboolean
4027 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4028 {
4041 }
4045 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4050 }
4052 }
4054 // FIXME: This doesn't work yet (class libs tests fail?)
4055 #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)
4058 emit_castclass_with_cache (MonoCompile *cfg, MonoClass *klass, MonoInst **args, MonoBasicBlock **out_bblock)
4059 {
4070 }
4072 /*
4073 * Returns NULL and set the cfg exception on error.
4074 */
4077 {
4086 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4091 /* obj */
4094 /* klass - it's the second element of the cache entry*/
4095 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4097 /* cache */
4101 }
4104 }
4121 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4122 /* the remoting code is broken, access the class for now */
4123 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4129 }
4134 }
4139 }
4140 }
4147 }
4149 /*
4150 * Returns NULL and set the cfg exception on error.
4151 */
4154 {
4165 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4171 /* obj */
4174 /* klass - it's the second element of the cache entry*/
4175 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4177 /* cache */
4181 }
4184 }
4190 /* Do the assignment at the beginning, so the other assignment can be if converted */
4202 /* the is_null_bb target simply copies the input register to the output */
4212 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
4216 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
4220 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4224 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4234 /* Check that the object is a vector too */
4239 }
4241 /* the is_null_bb target simply copies the input register to the output */
4243 }
4247 /* the is_null_bb target simply copies the input register to the output */
4250 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4252 /* the remoting code is broken, access the class for now */
4253 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4259 }
4264 }
4269 /* the is_null_bb target simply copies the input register to the output */
4271 }
4272 }
4273 }
4285 }
4289 {
4290 /* This opcode takes as input an object reference and a class, and returns:
4291 0) if the object is an instance of the class,
4292 1) if the object is not instance of the class,
4293 2) if the object is a proxy whose type cannot be determined */
4296 #ifndef DISABLE_REMOTING
4298 #else
4300 #endif
4304 #ifndef DISABLE_REMOTING
4306 #endif
4311 #ifndef DISABLE_REMOTING
4314 #endif
4320 #ifndef DISABLE_REMOTING
4322 #endif
4326 #ifndef DISABLE_REMOTING
4331 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4334 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4337 #else
4339 #endif
4341 #ifndef DISABLE_REMOTING
4346 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4348 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4349 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4352 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4362 #else
4364 #endif
4365 }
4372 #ifndef DISABLE_REMOTING
4377 #endif
4385 /* FIXME: */
4391 }
4395 {
4396 /* This opcode takes as input an object reference and a class, and returns:
4397 0) if the object is an instance of the class,
4398 1) if the object is a proxy whose type cannot be determined
4399 an InvalidCastException exception is thrown otherwhise*/
4402 #ifndef DISABLE_REMOTING
4404 #else
4406 #endif
4411 #ifndef DISABLE_REMOTING
4414 #endif
4424 #ifndef DISABLE_REMOTING
4435 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4441 #else
4445 #endif
4447 #ifndef DISABLE_REMOTING
4452 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4455 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4456 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4459 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4475 #else
4477 #endif
4478 }
4484 #ifndef DISABLE_REMOTING
4486 #endif
4488 /* FIXME: */
4494 }
4496 /*
4497 * Returns NULL and set the cfg exception on error.
4498 */
4500 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
4501 {
4513 /* Inline the contents of mono_delegate_ctor */
4515 /* Set target field */
4516 /* Optimize away setting of NULL target */
4518 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
4521 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target));
4523 }
4524 }
4526 /* Set method field */
4528 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
4529 /*
4530 * To avoid looking up the compiled code belonging to the target method
4531 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
4532 * store it, and we fill it after the method has been compiled.
4533 */
4538 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
4548 }
4553 else
4555 }
4556 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
4557 }
4559 /* Set invoke_impl field */
4568 trampoline = mono_create_delegate_trampoline_with_method (cfg->domain, klass, context_used ? NULL : method);
4570 }
4571 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
4573 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
4576 }
4580 {
4583 /* Need to register the icall so it gets an icall wrapper */
4588 /* mono_array_new_va () needs a vararg calling convention */
4591 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
4593 }
4595 static void
4597 {
4607 /* Add it to the start of the first bblock */
4611 }
4612 else
4617 /*
4618 * Add a dummy use to keep the got_var alive, since real uses might
4619 * only be generated by the back ends.
4620 * Add it to end_bblock, so the variable's lifetime covers the whole
4621 * method.
4622 * It would be better to make the usage of the got var explicit in all
4623 * cases when the backend needs it (i.e. calls, throw etc.), so this
4624 * wouldn't be needed.
4625 */
4628 }
4633 static gboolean
4635 {
4636 MonoMethodHeaderSummary header;
4638 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
4641 #endif
4649 #ifdef MONO_ARCH_HAVE_LMF_OPS
4654 #endif
4660 /*runtime, icall and pinvoke are checked by summary call*/
4667 /* also consider num_locals? */
4668 /* Do the size check early to avoid creating vtables */
4672 else
4675 }
4676 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
4679 /*
4680 * if we can initialize the class of the method right away, we do,
4681 * otherwise we don't allow inlining if the class needs initialization,
4682 * since it would mean inserting a call to mono_runtime_class_init()
4683 * inside the inlined code
4684 */
4686 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
4695 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
4697 /* No vtable created yet */
4702 /* This makes so that inline cannot trigger */
4703 /* .cctors: too many apps depend on them */
4704 /* running with a specific order... */
4708 }
4711 /* No vtable created yet */
4718 }
4720 /*
4721 * If we're compiling for shared code
4722 * the cctor will need to be run at aot method load time, for example,
4723 * or at the end of the compilation of the inlining method.
4724 */
4725 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
4727 }
4729 /*
4730 * CAS - do not inline methods with declarative security
4731 * Note: this has to be before any possible return TRUE;
4732 */
4736 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
4738 /* FIXME: */
4744 }
4745 #endif
4748 }
4750 static gboolean
4751 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
4752 {
4757 }
4762 }
4768 /* The initialization is already done before the method is called */
4772 }
4775 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4776 {
4778 guint32 size;
4787 }
4793 #if SIZEOF_REGISTER == 8
4794 /* The array reg is 64 bits but the index reg is only 32 */
4796 /* Not needed */
4801 }
4802 #else
4808 }
4809 #endif
4814 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4818 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
4823 }
4824 #endif
4831 /* gsharedvt */
4835 rgctx_ins = emit_get_gsharedvt_info (cfg, &klass->byval_arg, MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE);
4839 }
4847 }
4849 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4851 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4852 {
4866 guint32 size;
4874 #if SIZEOF_REGISTER == 8
4875 /* The array reg is 64 bits but the index reg is only 32 */
4877 /* Not needed */
4885 }
4886 #else
4887 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
4889 #endif
4891 /* range checking */
4922 }
4923 #endif
4926 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
4927 {
4938 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4939 /* emit_ldelema_2 depends on OP_LMUL */
4942 }
4943 #endif
4950 }
4952 static MonoBreakPolicy
4954 {
4956 }
4960 /**
4961 * mono_set_break_policy:
4962 * policy_callback: the new callback function
4963 *
4964 * Allow embedders to decide wherther to actually obey breakpoint instructions
4965 * (both break IL instructions and Debugger.Break () method calls), for example
4966 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4967 * untrusted or semi-trusted code.
4968 *
4969 * @policy_callback will be called every time a break point instruction needs to
4970 * be inserted with the method argument being the method that calls Debugger.Break()
4971 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4972 * if it wants the breakpoint to not be effective in the given method.
4973 * #MONO_BREAK_POLICY_ALWAYS is the default.
4974 */
4975 void
4977 {
4980 else
4982 }
4984 static gboolean
4997 }
4998 }
5000 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5002 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5003 {
5007 /* the bounds check is already done by the callers */
5017 }
5019 }
5022 static gboolean
5024 {
5026 }
5030 {
5057 // FIXME-VT: OP_ICONST optimization
5064 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
5074 }
5076 }
5077 }
5080 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5081 {
5086 else
5095 }
5096 }
5098 static gboolean
5100 {
5103 //Only allow for valuetypes
5107 //That are blitable
5111 /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5112 if ((MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5113 (!MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)))
5116 if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5120 //And have the same size
5121 if (mono_class_value_size (param_klass, &align) != mono_class_value_size (return_klass, &align))
5124 }
5128 {
5132 //Valuetypes that are semantically equivalent
5136 //Arrays of valuetypes that are semantically equivalent
5137 if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (param_klass->element_class, return_klass->element_class))
5141 }
5144 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5145 {
5146 #ifdef MONO_ARCH_SIMD_INTRINSICS
5153 }
5154 #endif
5157 }
5161 {
5168 }
5171 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5172 {
5176 /* The LLVM backend supports these intrinsics */
5186 }
5194 }
5216 }
5217 }
5226 }
5227 }
5230 }
5233 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5234 {
5242 }
5245 }
5248 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5249 {
5264 #if SIZEOF_REGISTER == 8
5265 /* The array reg is 64 bits but the index reg is only 32 */
5267 #else
5269 #endif
5272 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5273 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
5275 /* Avoid a warning */
5279 #else
5284 #endif
5289 /* Decompose later to allow more optimizations */
5301 /* The corlib functions check for oob already. */
5304 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
5313 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
5314 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
5318 #if !defined(MONO_ARCH_EMULATE_MUL_DIV)
5328 #endif
5339 #ifndef MONO_BIG_ARRAYS
5340 /*
5341 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
5342 * Array methods.
5343 */
5344 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
5357 /* Non-szarray case */
5361 else
5366 /* Szarray case */
5370 else
5378 }
5379 #endif
5418 }
5421 /* FIXME this should be integrated to the check below once we support the trampoline version */
5422 #if defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
5426 /* Avoid infinite recursion */
5427 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN && !strcmp (cfg->method->name, "FastMonitorEnterV4"))
5435 }
5436 #endif
5438 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
5443 /*
5444 * Pass the argument normally, the LLVM backend will handle the
5445 * calling convention problems.
5446 */
5447 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
5453 }
5460 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
5466 }
5469 }
5470 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
5471 {
5474 /* Avoid infinite recursion */
5487 }
5488 #endif
5494 #if SIZEOF_REGISTER == 8
5496 /* 64 bit reads are already atomic */
5502 }
5503 #endif
5505 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
5513 }
5514 #if SIZEOF_REGISTER == 8
5517 #endif
5533 }
5541 }
5542 #if SIZEOF_REGISTER == 8
5545 #endif
5561 }
5568 }
5569 #if SIZEOF_REGISTER == 8
5572 #endif
5583 }
5584 }
5587 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
5589 guint32 opcode;
5595 }
5596 #if SIZEOF_REGISTER == 8
5600 #else
5604 }
5605 #endif
5606 else
5632 }
5636 }
5639 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
5671 /* g_assert_not_reached (); */
5672 }
5675 }
5691 }
5693 }
5696 #ifdef TARGET_WIN32
5698 #else
5700 #endif
5702 }
5704 /*
5705 * There is general branches code for Min/Max, but it does not work for
5706 * all inputs:
5707 * http://everything2.com/?node_id=1051618
5708 */
5709 } 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)) {
5710 #ifdef MONO_ARCH_HAVE_OBJC_GET_SELECTOR
5725 }
5729 // FIXME: Ugly
5733 // FIXME: Leaks
5737 #endif
5738 }
5740 #ifdef MONO_ARCH_SIMD_INTRINSICS
5745 }
5746 #endif
5756 }
5759 }
5761 /*
5762 * This entry point could be used later for arbitrary method
5763 * redirection.
5764 */
5768 {
5770 /* managed string allocation support */
5771 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
5777 #ifndef MONO_CROSS_COMPILE
5779 #endif
5785 }
5786 }
5788 }
5790 static void
5792 {
5797 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
5799 /*
5800 * FIXME: We should use *args++ = sp [0], but that would mean the arg
5801 * would be different than the MonoInst's used to represent arguments, and
5802 * the ldelema implementation can't deal with that.
5803 * Solution: When ldelema is used on an inline argument, create a var for
5804 * it, emit ldelema on that var, and emit the saving code below in
5805 * inline_method () if needed.
5806 */
5809 /* This uses cfg->args [i] which is set by the preceeding line */
5812 sp++;
5813 }
5814 }
5816 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
5817 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
5819 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5820 static gboolean
5822 {
5831 else
5833 }
5841 //return (strncmp_result <= 0);
5845 }
5846 }
5847 #endif
5849 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5850 static gboolean
5852 {
5862 }
5863 }
5871 //return (strncmp_result <= 0);
5875 }
5876 }
5877 #endif
5879 static void
5881 {
5904 } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (cfg, rtype)) {
5908 }
5909 }
5911 static void
5913 {
5930 } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (cfg, rtype)) {
5934 }
5935 }
5937 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
5938 static void
5940 {
5950 else
5952 }
5953 }
5955 static int
5956 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
5958 {
5966 guint prev_real_offset;
5971 guint32 prev_cil_offset_to_bb_len;
5978 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5981 #endif
5982 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5985 #endif
5988 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
5993 }
5995 /* allocate local variables */
6008 }
6010 /*Must verify before creating locals as it can cause the JIT to assert.*/
6014 }
6016 /* allocate space to store the return value */
6019 }
6026 /* allocate start and end blocks */
6027 /* This is needed so if the inline is aborted, we can clean up */
6054 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
6074 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
6078 /* always add some code to avoid block split failures */
6085 /*
6086 * Get rid of the begin and end bblocks if possible to aid local
6087 * optimizations.
6088 */
6091 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
6098 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
6101 }
6103 /*
6104 * Its possible that the rvar is set in some prev bblock, but not in others.
6105 * (#1835).
6106 */
6117 }
6118 }
6119 }
6122 }
6125 /*
6126 * If the inlined method contains only a throw, then the ret var is not
6127 * set, so set it to a dummy value.
6128 */
6134 }
6143 /* This gets rid of the newly added bblocks */
6145 }
6148 }
6150 /*
6151 * Some of these comments may well be out-of-date.
6152 * Design decisions: we do a single pass over the IL code (and we do bblock
6153 * splitting/merging in the few cases when it's required: a back jump to an IL
6154 * address that was not already seen as bblock starting point).
6155 * Code is validated as we go (full verification is still better left to metadata/verify.c).
6156 * Complex operations are decomposed in simpler ones right away. We need to let the
6157 * arch-specific code peek and poke inside this process somehow (except when the
6158 * optimizations can take advantage of the full semantic info of coarse opcodes).
6159 * All the opcodes of the form opcode.s are 'normalized' to opcode.
6160 * MonoInst->opcode initially is the IL opcode or some simplification of that
6161 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
6162 * opcode with value bigger than OP_LAST.
6163 * At this point the IR can be handed over to an interpreter, a dumb code generator
6164 * or to the optimizing code generator that will translate it to SSA form.
6165 *
6166 * Profiling directed optimizations.
6167 * We may compile by default with few or no optimizations and instrument the code
6168 * or the user may indicate what methods to optimize the most either in a config file
6169 * or through repeated runs where the compiler applies offline the optimizations to
6170 * each method and then decides if it was worth it.
6171 */
6173 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
6174 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
6175 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
6176 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
6177 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
6178 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
6179 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
6180 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; LOAD_ERROR;}
6182 /* offset from br.s -> br like opcodes */
6183 #define BIG_BRANCH_OFFSET 13
6185 static gboolean
6187 {
6191 }
6193 static int
6194 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
6195 {
6199 guint cli_addr;
6207 UNVERIFIED;
6211 ip++;
6246 guint32 j;
6256 }
6258 }
6265 }
6270 /* Find the start of the bblock containing the throw */
6274 bb_start --;
6275 }
6278 }
6279 }
6281 unverified:
6282 exception_exit:
6285 }
6288 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
6289 {
6298 }
6301 }
6304 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
6305 {
6308 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
6312 }
6316 {
6325 }
6329 }
6333 {
6337 MonoError error;
6342 // FIXME:
6344 }
6347 }
6349 }
6351 /*
6352 * Returns TRUE if the JIT should abort inlining because "callee"
6353 * is influenced by security attributes.
6354 */
6355 static
6357 {
6358 guint32 result;
6362 }
6369 /* Generate code to throw a SecurityException before the actual call/link */
6377 /* don't hide previous results */
6381 }
6384 }
6388 {
6394 }
6397 }
6399 static void
6401 {
6407 }
6409 /*
6410 * Return the original method is a wrapper is specified. We can only access
6411 * the custom attributes from the original method.
6412 */
6415 {
6419 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
6423 /* in other cases we need to find the original method */
6425 }
6427 static void
6428 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
6430 {
6431 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
6432 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
6435 }
6437 static void
6438 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
6440 {
6441 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
6442 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
6445 }
6447 /*
6448 * Check that the IL instructions at ip are the array initialization
6449 * sequence and return the pointer to the data and the size.
6450 */
6452 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
6453 {
6454 /*
6455 * newarr[System.Int32]
6456 * dup
6457 * ldtoken field valuetype ...
6458 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
6459 */
6464 guint32 rva;
6469 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
6480 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
6487 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
6488 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
6501 #endif
6504 }
6509 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
6514 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
6515 /* for aot code we do the lookup on load */
6519 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
6522 }
6524 }
6526 }
6528 static void
6530 {
6537 else
6540 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
6544 }
6546 static void
6548 {
6552 }
6554 static void
6556 {
6561 /* Optimize reg-reg moves away */
6562 /*
6563 * Can't optimize other opcodes, since sp[0] might point to
6564 * the last ins of a decomposed opcode.
6565 */
6569 }
6570 }
6572 /*
6573 * ldloca inhibits many optimizations so try to get rid of it in common
6574 * cases.
6575 */
6578 {
6589 }
6591 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
6592 /* From the INITOBJ case */
6599 }
6600 load_error:
6602 }
6604 static gboolean
6606 {
6611 }
6613 }
6615 /*
6616 * is_jit_optimizer_disabled:
6617 *
6618 * Determine whenever M's assembly has a DebuggableAttribute with the
6619 * IsJITOptimizerDisabled flag set.
6620 */
6621 static gboolean
6623 {
6635 klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
6637 /* Linked away */
6642 }
6654 /* Decode the attribute. See reflection.c */
6660 // FIXME: Support named parameters
6662 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
6664 /* Two boolean arguments */
6665 p ++;
6667 }
6669 }
6676 }
6678 static gboolean
6679 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
6680 {
6681 gboolean supported_tail_call;
6684 #ifdef MONO_ARCH_HAVE_OP_TAIL_CALL
6685 supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
6686 #else
6687 supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6688 #endif
6691 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
6692 /* These can point to the current method's stack */
6694 }
6696 /* this might point to the current method's stack */
6707 /* Debugging support */
6708 #if 0
6712 }
6713 #endif
6716 }
6718 /* the JIT intercepts ldflda instructions to the tlsdata field in ThreadLocal<T> and redirects
6719 * it to the thread local value based on the tls_offset field. Every other kind of access to
6720 * the field causes an assert.
6721 */
6722 static gboolean
6724 {
6730 }
6732 /* emits the code needed to access a managed tls var (like ThreadStatic)
6733 * with the value of the tls offset in offset_reg. thread_ins represents the MonoInternalThread
6734 * pointer for the current thread.
6735 * Returns the MonoInst* representing the address of the tls var.
6736 */
6739 {
6743 // inlined access to the tls data
6744 // idx = (offset >> 24) - 1;
6745 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
6747 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
6760 }
6762 /*
6763 * redirect access to the tlsdata field to the tls var given by the tls_offset field.
6764 * this address is cached per-method in cached_tls_addr.
6765 */
6767 create_magic_tls_access (MonoCompile *cfg, MonoClassField *tls_field, MonoInst **cached_tls_addr, MonoInst *thread_local)
6768 {
6775 }
6779 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, offset_field->type, thread_local->dreg, offset_field->offset);
6784 thread_method = mono_class_get_method_from_name (mono_get_thread_class(), "CurrentInternalThread_internal", 0);
6786 }
6790 *cached_tls_addr = temp = mono_compile_create_var (cfg, type_from_stack_type (addr), OP_LOCAL);
6795 }
6797 /*
6798 * mono_method_to_ir:
6799 *
6800 * Translate the .net IL into linear IR.
6801 */
6802 int
6803 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
6806 {
6807 MonoError error;
6826 guint num_args;
6829 MonoDeclSecurityActions actions;
6842 /* serialization and xdomain stuff may need access to private fields and methods */
6852 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
6867 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
6868 }
6870 }
6880 #ifdef PLATFORM_ANDROID
6882 #endif
6885 /* We could hit a seq point before attaching to the JIT (#8338) */
6887 }
6896 mono_debug_symfile_get_line_numbers_full (minfo, NULL, NULL, &n_il_offsets, &il_offsets, &line_numbers, NULL, NULL, NULL, NULL);
6897 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6898 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);
6903 }
6906 }
6907 }
6909 /*
6910 * Methods without init_locals set could cause asserts in various passes
6911 * (#497220). To work around this, we emit dummy initialization opcodes
6912 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
6913 * on some platforms.
6914 */
6917 else
6924 }
6926 /* SkipVerification is not allowed if core-clr is enabled */
6930 }
6944 }
6952 }
6954 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
6975 /* ENTRY BLOCK */
6980 #if defined(__native_client_codegen__)
6984 #endif
6986 /* EXIT BLOCK */
6999 }
7000 /* handle exception clauses */
7012 /*
7013 * Linking the try block with the EH block hinders inlining as we won't be able to
7014 * merge the bblocks from inlining and produce an artificial hole for no good reason.
7015 */
7029 /* finally clauses already have a seq point */
7032 }
7034 /* todo: is a fault block unsafe to optimize? */
7037 }
7040 /*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);
7041 while (p < end) {
7042 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
7043 }*/
7044 /* catch and filter blocks get the exception object on the stack */
7049 /* mostly like handle_stack_args (), but just sets the input args */
7050 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
7055 /*
7056 * Add a dummy use for the exvar so its liveness info will be
7057 * correct.
7058 */
7068 /* The filter block shares the exvar with the handler block */
7072 }
7073 }
7079 /*
7080 * In shared generic code with catch
7081 * clauses containing type variables
7082 * the exception handling code has to
7083 * be able to get to the rgctx.
7084 * Therefore we have to make sure that
7085 * the vtable/mrgctx argument (for
7086 * static or generic methods) or the
7087 * "this" argument (for non-static
7088 * methods) are live.
7089 */
7098 }
7099 }
7100 }
7106 }
7108 /* FIRST CODE BLOCK */
7121 }
7122 }
7128 /* at this point having security doesn't mean we have any code to generate */
7130 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
7131 * And we do not want to enter the next section (with allocation) if we
7132 * have nothing to generate */
7134 }
7136 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
7143 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
7146 }
7154 }
7157 }
7159 /* not a P/Invoke after all */
7161 }
7162 }
7164 /* we use a separate basic block for the initialization code */
7183 info->entries = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
7187 /* prevent it from being register allocated */
7188 //var->flags |= MONO_INST_VOLATILE;
7191 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
7194 /* Allocate locals */
7196 /* prevent it from being register allocated */
7197 //locals_var->flags |= MONO_INST_VOLATILE;
7201 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, G_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
7210 /*
7211 if (init_locals)
7212 ins->flags |= MONO_INST_INIT;
7213 */
7214 }
7216 /* at this point we know, if security is TRUE, that some code needs to be generated */
7223 /* Add code for SecurityAction.Demand */
7226 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
7228 }
7230 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
7231 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
7234 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
7236 }
7238 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
7241 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
7243 }
7244 }
7246 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
7249 }
7252 /* check if this is native code, e.g. an icall or a p/invoke */
7259 /* if this ia a native call then it can only be JITted from platform code */
7265 }
7266 }
7267 }
7268 }
7269 }
7271 CHECK_CFG_EXCEPTION;
7274 UNVERIFIED;
7278 UNVERIFIED;
7279 }
7286 UNVERIFIED;
7287 }
7290 /* We force the vtable variable here for all shared methods
7291 for the possibility that they might show up in a stack
7292 trace where their exact instantiation is needed. */
7299 /* FIXME: Is there a better way to do this?
7300 We need the variable live for the duration
7301 of the whole method. */
7303 }
7304 }
7306 /* add a check for this != NULL to inlined methods */
7313 }
7320 UNVERIFIED;
7321 }
7323 }
7325 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
7326 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
7334 else
7346 }
7356 }
7367 }
7376 }
7379 }
7380 }
7398 }
7402 }
7403 }
7404 /*
7405 * Sequence points are points where the debugger can place a breakpoint.
7406 * Currently, we generate these automatically at points where the IL
7407 * stack is empty.
7408 */
7409 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
7410 /*
7411 * Make methods interruptable at the beginning, and at the targets of
7412 * backward branches.
7413 * Also, do this at the start of every bblock in methods with clauses too,
7414 * to be able to handle instructions with inprecise control flow like
7415 * throw/endfinally.
7416 * Backward branches are handled at the end of method-to-ir ().
7417 */
7420 /* Avoid sequence points on empty IL like .volatile */
7421 // FIXME: Enable this
7422 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
7430 }
7438 /* TODO: Use an increment here */
7439 #if defined(TARGET_X86)
7444 #else
7447 #endif
7448 }
7451 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
7456 /*
7457 * The C# compiler uses these nops to notify the JIT that it should
7458 * insert seq points.
7459 */
7462 }
7465 else
7467 ip++;
7475 }
7476 ip++;
7487 ip++;
7498 ip++;
7510 UNVERIFIED;
7515 }
7542 UNVERIFIED;
7565 }
7571 }
7578 UNVERIFIED;
7641 #ifdef TARGET_POWERPC
7642 /* FIXME: Clean this up */
7645 #endif
7647 /* FIXME: we should really allocate this only late in the compilation process */
7667 }
7673 }
7678 #ifdef TARGET_POWERPC
7679 /* FIXME: Clean this up */
7682 #endif
7684 /* FIXME: we should really allocate this only late in the compilation process */
7704 }
7710 }
7715 sp--;
7730 }
7733 ip++;
7736 #ifdef TARGET_X86
7738 /* we need to pop the value from the x86 FP stack */
7740 #endif
7750 UNVERIFIED;
7752 /* FIXME: check the signature matches */
7756 LOAD_ERROR;
7762 CHECK_CFG_EXCEPTION;
7770 /* Handle tail calls similarly to calls */
7789 /* Prevent arguments from being optimized away */
7796 }
7801 }
7832 //GSHAREDVT_FAILURE (*ip);
7843 /*
7844 * This is a call through a function pointer using a pinvoke
7845 * signature. Have to create a wrapper and call that instead.
7846 * FIXME: This is very slow, need to create a wrapper at JIT time
7847 * instead based on the signature.
7848 */
7853 }
7867 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_call, generic_context);
7868 }
7873 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
7874 /*
7875 * This is needed since get_method_constrained can't find
7876 * the method in klass representing a type var.
7877 * The type var is guaranteed to be a reference type in this
7878 * case.
7879 */
7883 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
7884 }
7885 }
7886 }
7889 LOAD_ERROR;
7893 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
7894 }
7897 METHOD_ACCESS_FAILURE;
7898 }
7904 /* MS.NET seems to silently convert this to a callvirt */
7907 {
7908 /*
7909 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
7910 * converts to a callvirt.
7911 *
7912 * tests/bug-515884.il is an example of this behavior
7913 */
7914 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
7916 if (!virtual && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
7918 }
7932 LOAD_ERROR;
7942 }
7943 }
7948 /*
7949 * Need to emit an implicit seq point after every non-void call so single stepping through nested calls like
7950 * foo (bar (), baz ())
7951 * works correctly. MS does this also:
7952 * http://stackoverflow.com/questions/6937198/making-your-net-language-step-correctly-in-the-debugger
7953 * The problem with this approach is that the debugger will stop after all calls returning a value,
7954 * even for simple cases, like:
7955 * int i = foo ();
7956 */
7957 /* Special case a few common successor opcodes */
7958 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)))
7960 }
7964 /* Don't support calls made using type arguments for now */
7965 /*
7966 if (cfg->gsharedvt) {
7967 if (mini_is_gsharedvt_signature (cfg, fsig))
7968 GSHAREDVT_FAILURE (*ip);
7969 }
7970 */
7975 CHECK_CFG_EXCEPTION;
7976 }
7980 }
7983 UNVERIFIED;
7990 //g_assert (!virtual || fsig->hasthis);
7996 /*
7997 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
7998 */
7999 if ((cmethod->klass != mono_defaults.object_class) && constrained_call->valuetype && cmethod->klass->valuetype) {
8000 /* The 'Own method' case below */
8001 } else if (cmethod->klass->image != mono_defaults.corlib && !(cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) && !cmethod->klass->valuetype) {
8002 /* 'The type parameter is instantiated as a reference type' case below. */
8003 } else if (((cmethod->klass == mono_defaults.object_class) || (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
8004 (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)) &&
8005 (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]))))) {
8008 /*
8009 * This case handles calls to
8010 * - object:ToString()/Equals()/GetHashCode(),
8011 * - System.IComparable<T>:CompareTo()
8012 * - System.IEquatable<T>:Equals ()
8013 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
8014 */
8018 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
8019 else
8021 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_call), constrained_call, MONO_RGCTX_INFO_KLASS);
8023 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
8025 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
8035 args [3] = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
8043 }
8047 }
8056 /* Unbox */
8057 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
8059 /* Load value */
8062 /* ins represents the call result */
8063 }
8068 }
8069 }
8070 /*
8071 * We have the `constrained.' prefix opcode.
8072 */
8073 if (constrained_call->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
8074 /*
8075 * The type parameter is instantiated as a valuetype,
8076 * but that type doesn't override the method we're
8077 * calling, so we need to box `this'.
8078 */
8081 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call), &bblock);
8082 CHECK_CFG_EXCEPTION;
8086 /*
8087 * The type parameter is instantiated as a reference
8088 * type. We have a managed pointer on the stack, so
8089 * we need to dereference it here.
8090 */
8096 /* Own method */
8098 /* Interface method */
8112 /* Enum implements some interfaces, so treat this as the first case */
8115 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call), &bblock);
8116 CHECK_CFG_EXCEPTION;
8117 }
8118 }
8120 }
8122 }
8125 UNVERIFIED;
8127 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
8128 if (cmethod && (cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
8130 #endif
8132 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
8137 }
8140 }
8142 /*
8143 * If the callee is a shared method, then its static cctor
8144 * might not get called after the call was patched.
8145 */
8146 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)) {
8149 }
8160 /* Generic method interface
8161 calls are resolved via a
8162 helper function and don't
8163 need an imt. */
8166 }
8168 /*
8169 * If a shared method calls another
8170 * shared method then the caller must
8171 * have a generic sharing context
8172 * because the magic trampoline
8173 * requires it. FIXME: We shouldn't
8174 * have to force the vtable/mrgctx
8175 * variable here. Instead there
8176 * should be a flag in the cfg to
8177 * request a generic sharing context.
8178 */
8182 }
8192 }
8193 }
8199 /*
8200 * emit_get_rgctx_method () calls mono_class_vtable () so check
8201 * for type load errors before.
8202 */
8205 }
8209 /* !marshalbyref is needed to properly handle generic methods + remoting */
8216 }
8217 }
8225 }
8230 /* Calling virtual generic methods */
8243 /* Prevent inlining of methods that contain indirect calls */
8249 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
8252 #endif
8266 /* FIXME: This should be a managed pointer */
8279 }
8282 }
8284 /*
8285 * Implement a workaround for the inherent races involved in locking:
8286 * Monitor.Enter ()
8287 * try {
8288 * } finally {
8289 * Monitor.Exit ()
8290 * }
8291 * If a thread abort happens between the call to Monitor.Enter () and the start of the
8292 * try block, the Exit () won't be executed, see:
8293 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
8294 * To work around this, we extend such try blocks to include the last x bytes
8295 * of the Monitor.Enter () call.
8296 */
8297 if (cmethod && cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
8301 /*
8302 * Only extend try blocks with a finally, to avoid catching exceptions thrown
8303 * from Monitor.Enter like ArgumentNullException.
8304 */
8306 /* Mark this bblock as needing to be extended */
8308 }
8309 }
8311 /* Conversion to a JIT intrinsic */
8312 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
8317 }
8319 }
8321 /* Inlining */
8323 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
8331 /* Prevent inlining of methods that call wrappers */
8335 }
8343 /* *sp is already set by inline_method */
8344 sp++;
8346 }
8351 }
8352 }
8354 /* Tail recursion elimination */
8355 if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
8359 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
8362 /* keep it simple */
8366 }
8378 /* skip the CEE_RET, too */
8383 }
8384 }
8388 /*
8389 * Making generic calls out of gsharedvt methods.
8390 */
8392 MonoRgctxInfoType info_type;
8395 //if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
8396 //GSHAREDVT_FAILURE (*ip);
8397 // disable for possible remoting calls
8398 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
8401 /* virtual generic call */
8404 /* Same as the virtual generic case above */
8407 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
8409 }
8410 }
8413 /* test_0_multi_dim_arrays () in gshared.cs */
8416 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
8421 else
8428 /*
8429 * We pass the address to the gsharedvt trampoline in the rgctx reg
8430 */
8434 /* Not tested */
8441 }
8443 /* Generic sharing */
8444 /* FIXME: only do this for generic methods if
8445 they are not shared! */
8456 /*
8457 * We are compiling a call to a
8458 * generic method from shared code,
8459 * which means that we have to look up
8460 * the method in the rgctx and do an
8461 * indirect call.
8462 */
8466 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8469 }
8471 /* Indirect calls */
8477 else
8478 /* FIXME: what the hell is this??? */
8482 /* Prevent inlining of methods with indirect calls */
8485 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
8487 gpointer info_data;
8489 /*
8490 * Instead of emitting an indirect call, emit a direct call
8491 * with the contents of the aotconst as the patch info.
8492 */
8499 }
8505 }
8506 }
8509 }
8511 /* Array methods */
8525 }
8528 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
8529 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
8545 }
8549 }
8555 /* Tail prefix / tail call optimization */
8557 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
8558 /* FIXME: runtime generic context pointer for jumps? */
8559 /* FIXME: handle this for generic sharing eventually */
8561 !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
8567 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
8570 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
8573 /* Handle tail calls similarly to normal calls */
8583 /*
8584 * We implement tail calls by storing the actual arguments into the
8585 * argument variables, then emitting a CEE_JMP.
8586 */
8588 /* Prevent argument from being register allocated */
8591 }
8599 // FIXME: Eliminate unreachable epilogs
8601 /*
8602 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
8603 * only reachable from this call.
8604 */
8611 }
8612 }
8614 /*
8615 * Synchronized wrappers.
8616 * Its hard to determine where to replace a method with its synchronized
8617 * wrapper without causing an infinite recursion. The current solution is
8618 * to add the synchronized wrapper in the trampolines, and to
8619 * change the called method to a dummy wrapper, and resolve that wrapper
8620 * to the real method in mono_jit_compile_method ().
8621 */
8624 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
8626 }
8628 /* Common call */
8637 // FIXME: Eliminate unreachable epilogs
8639 /*
8640 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
8641 * only reachable from this call.
8642 */
8647 }
8649 call_end:
8651 /* End of call, INS should contain the result of the call, if any */
8657 else
8659 }
8664 /* See mono_emit_method_call_full () */
8666 }
8668 CHECK_CFG_EXCEPTION;
8674 }
8680 }
8683 /* return from inlined method */
8684 /*
8685 * If in_count == 0, that means the ret is unreachable due to
8686 * being preceeded by a throw. In that case, inline_method () will
8687 * handle setting the return value
8688 * (test case: test_0_inline_throw ()).
8689 */
8697 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
8698 UNVERIFIED;
8700 //g_assert (returnvar != -1);
8703 }
8714 /*
8715 * Place a seq point here too even through the IL stack is not
8716 * empty, so a step over on
8717 * call <FOO>
8718 * ret
8719 * will work correctly.
8720 */
8723 }
8729 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
8730 UNVERIFIED;
8744 }
8746 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8756 }
8757 #else
8759 #endif
8760 }
8761 }
8762 }
8764 UNVERIFIED;
8766 ip++;
8775 ip++;
8785 }
8803 ip++;
8805 ip++;
8815 ip++;
8826 }
8845 UNVERIFIED;
8846 ip ++;
8850 sp--;
8860 }
8867 #if SIZEOF_REGISTER == 4
8869 /* Convert it to OP_LCOMPARE */
8877 }
8878 #endif
8894 }
8908 ip++;
8926 gboolean use_op_switch;
8934 UNVERIFIED;
8949 }
8952 /*
8953 * Link the current bb with the targets as well, so handle_stack_args
8954 * will set their in_stack correctly.
8955 */
8963 }
8977 #ifdef TARGET_ARM
8978 /* ARM implements SWITCH statements differently */
8979 /* FIXME: Make it use the generic implementation */
8982 #endif
8999 else
9002 #if SIZEOF_REGISTER == 8
9003 /* The upper word might not be zero, and we add it to a 64 bit address later */
9005 #endif
9015 }
9017 /* FIXME: Use load_memindex */
9021 }
9025 }
9053 }
9061 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9062 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9064 }
9080 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
9081 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9083 }
9091 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)))
9109 /* Use the immediate opcodes if possible */
9118 }
9119 }
9124 ip++;
9149 /* FIXME: Pass opcode to is_inst_imm */
9151 /* Use the immediate opcodes if possible */
9152 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)) {
9156 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
9157 /* Keep emulated opcodes which are optimized away later */
9158 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) {
9160 }
9161 #endif
9165 #if SIZEOF_REGISTER == 8
9167 #else
9170 #endif
9171 }
9172 else
9176 /* Might be followed by an instruction added by ADD_WIDEN_OP */
9179 }
9180 }
9184 ip++;
9201 /* Special case this earlier so we have long constants in the IR */
9206 #if SIZEOF_REGISTER == 8
9209 else
9211 #else
9215 else
9217 #endif
9219 }
9222 }
9223 ip++;
9237 }
9238 ip++;
9250 }
9251 ip++;
9269 CHECK_CFG_EXCEPTION;
9270 ip++;
9280 ip++;
9306 }
9321 /* Optimize the common ldobj+stloc combination */
9336 }
9347 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9348 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9350 }
9353 }
9355 /* Optimize the ldobj+stobj combination */
9356 /* The reference case ends up being a load+store anyway */
9357 /* Skip this if the operation is volatile. */
9358 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)) {
9361 sp --;
9368 }
9375 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9376 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
9378 }
9384 }
9394 }
9406 }
9417 /*
9418 * Avoid relocations in AOT and save some space by using a
9419 * version of helper_ldstr specialized to mscorlib.
9420 */
9424 /* Avoid creating the string object */
9428 }
9429 }
9430 else
9435 }
9441 OUT_OF_MEMORY_FAILURE;
9445 }
9446 }
9447 }
9449 sp++;
9455 MonoInst this_ins;
9463 LOAD_ERROR;
9466 LOAD_ERROR;
9478 CHECK_CFG_EXCEPTION;
9481 }
9483 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)) {
9486 }
9488 /*
9489 if (cfg->gsharedvt) {
9490 if (mini_is_gsharedvt_variable_signature (sig))
9491 GSHAREDVT_FAILURE (*ip);
9492 }
9493 */
9512 }
9513 }
9514 }
9519 /*
9520 * Generate smaller code for the common newobj <exception> instruction in
9521 * argument checking code.
9522 */
9549 }
9554 }
9556 /* move the args to allow room for 'this' in the first position */
9560 }
9562 /* check_call_signature () requires sp[0] to be set */
9566 UNVERIFIED;
9576 /* Avoid varargs in the common case */
9585 else
9590 /* we simply pass a null pointer */
9592 /* now call the string ctor */
9604 /*
9605 * The code generated by mini_emit_virtual_call () expects
9606 * iargs [0] to be a boxed instance, but luckily the vcall
9607 * will be transformed into a normal call there.
9608 */
9619 /*
9620 * TypeInitializationExceptions thrown from the mono_runtime_class_init
9621 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
9622 * As a workaround, we call class cctors before allocating objects.
9623 */
9624 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
9625 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, cmethod->klass, helper_sig_class_init_trampoline, NULL);
9627 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
9629 }
9633 }
9639 /* Now call the actual ctor */
9640 /* Avoid virtual calls to ctors if possible */
9645 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
9649 sp++;
9650 }
9652 CHECK_CFG_EXCEPTION;
9659 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
9666 // FIXME-VT: Clean this up
9670 }
9674 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
9681 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
9691 }
9692 }
9695 /* Valuetype */
9699 }
9700 else
9706 }
9715 UNVERIFIED;
9719 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9722 /* obj */
9725 /* klass */
9728 /* inline cache*/
9731 else
9734 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
9739 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9751 CHECK_CFG_EXCEPTION;
9761 }
9764 CHECK_CFG_EXCEPTION;
9768 }
9778 UNVERIFIED;
9782 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9786 /* obj */
9789 /* klass */
9792 /* inline cache*/
9795 else
9801 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9811 CHECK_CFG_EXCEPTION;
9821 }
9824 CHECK_CFG_EXCEPTION;
9828 }
9830 }
9845 sp ++;
9850 }
9853 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
9854 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
9857 /* obj */
9860 /* klass */
9863 /* inline cache*/
9864 /*FIXME AOT support*/
9867 else
9870 /* The wrapper doesn't inline well so the bloat of inlining doesn't pay off. */
9874 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9884 CHECK_CFG_EXCEPTION;
9895 CHECK_CFG_EXCEPTION;
9899 }
9901 }
9908 }
9910 /* UNBOX */
9916 /* LDOBJ */
9922 }
9942 }
9945 UNVERIFIED;
9947 UNVERIFIED;
9948 /* frequent check in generic code: box (struct), brtrue */
9950 // FIXME: LLVM can't handle the inconsistent bb linking
9964 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9966 }
9972 ip++;
9974 ip++;
9979 ip++;
9985 }
9987 /*
9988 * We need to link both bblocks, since it is needed for handling stack
9989 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
9990 * Branching to only one of them would lead to inconsistencies, so
9991 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
9992 */
10003 }
10012 /* The JIT can't eliminate the iconst+compare */
10016 }
10020 }
10024 CHECK_CFG_EXCEPTION;
10028 }
10051 }
10055 }
10063 #ifndef DISABLE_REMOTING
10065 #endif
10066 guint foffset;
10067 gboolean is_instance;
10070 gboolean is_special_static;
10085 }
10087 UNVERIFIED;
10089 UNVERIFIED;
10093 sp--;
10095 }
10096 }
10103 }
10106 }
10108 LOAD_ERROR;
10110 FIELD_ACCESS_FAILURE;
10114 UNVERIFIED;
10116 /* if the class is Critical then transparent code cannot access it's fields */
10120 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
10121 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
10122 if (mono_security_core_clr_enabled ())
10123 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
10124 */
10126 /*
10127 * LDFLD etc. is usable on static fields as well, so convert those cases to
10128 * the static case.
10129 */
10143 }
10145 }
10149 /* INSTANCE CASE */
10154 UNVERIFIED;
10155 #ifndef DISABLE_REMOTING
10156 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
10172 CHECK_CFG_EXCEPTION;
10181 }
10183 #endif
10184 {
10197 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
10201 }
10205 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)) {
10206 /* insert call to write barrier */
10213 }
10216 }
10220 }
10222 #ifndef DISABLE_REMOTING
10223 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
10224 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
10232 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
10236 CHECK_CFG_EXCEPTION;
10248 }
10250 #endif
10255 /* Have to compute the address of the variable */
10260 else
10265 }
10276 }
10287 }
10291 }
10306 }
10311 }
10312 }
10318 }
10320 /* STATIC CASE */
10322 /*
10323 * We can only support shared generic static
10324 * field access on architectures where the
10325 * trampoline code has been extended to handle
10326 * the generic class init.
10327 */
10328 #ifndef MONO_ARCH_VTABLE_REG
10330 #endif
10337 UNVERIFIED;
10339 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
10340 * to be called here.
10341 */
10345 }
10355 else
10358 /* Generate IR to compute the field address */
10359 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
10360 /*
10361 * Fast access to TLS data
10362 * Inline version of get_thread_static_data () in
10363 * threads.c.
10364 */
10365 guint32 offset;
10370 // offset &= 0x7fffffff;
10371 // idx = (offset >> 24) - 1;
10372 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
10375 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
10380 /* For TLS variables, this will return the TLS offset */
10403 }
10416 }
10421 /*
10422 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
10423 method->klass->name_space, method->klass->name, method->name,
10424 depth, field->offset);
10425 */
10430 /*
10431 * The pointer we're computing here is
10432 *
10433 * super_info.static_data + field->offset
10434 */
10449 }
10467 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, klass, helper_sig_class_init_trampoline, NULL);
10469 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
10471 }
10475 /* This makes so that inline cannot trigger */
10476 /* .cctors: too many apps depend on them */
10477 /* running with a specific order... */
10485 }
10486 }
10487 }
10495 }
10500 }
10501 }
10503 /* Generate IR to do the actual load/store operation */
10506 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10507 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10509 }
10528 }
10529 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
10530 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
10536 }
10540 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
10546 sp++;
10550 sp++;
10555 sp++;
10559 sp++;
10564 sp++;
10568 sp++;
10576 sp++;
10586 sp++;
10589 }
10594 sp++;
10602 }
10603 }
10614 }
10615 }
10618 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10619 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10621 }
10626 }
10635 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10636 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
10638 }
10639 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
10644 /* insert call to write barrier */
10646 }
10652 /*
10653 * Array opcodes
10654 */
10659 guint32 field_token;
10679 }
10686 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
10688 /* vtable */
10691 /* array len */
10696 else
10700 /* Decompose now to avoid problems with references to the domainvar */
10709 /* Decompose later since it is needed by abcrem */
10724 /* Needed so mono_emit_load_get_addr () gets called */
10726 }
10727 }
10734 /*
10735 * we inline/optimize the initialization sequence if possible.
10736 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
10737 * for small sizes open code the memcpy
10738 * ensure the rva field is big enough
10739 */
10740 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))) {
10745 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
10747 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
10750 }
10754 }
10757 }
10762 UNVERIFIED;
10768 /* This flag will be inherited by the decomposition */
10773 ip ++;
10781 UNVERIFIED;
10787 /* we need to make sure that this array is exactly the type it needs
10788 * to be for correctness. the wrappers are lax with their usage
10789 * so we need to ignore them here
10790 */
10795 }
10825 }
10826 else
10830 UNVERIFIED;
10835 // FIXME-VT: OP_ICONST optimization
10842 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
10849 }
10853 else
10856 }
10877 }
10878 else
10882 UNVERIFIED;
10888 else
10892 }
10907 }
10926 // FIXME:
10929 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
10931 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass));
10939 // FIXME:
10944 }
10945 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
10950 }
10966 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
10974 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
10975 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
10976 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10982 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
10983 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
10984 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10986 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
10987 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
10988 }
10989 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
10997 }
10999 gpointer handle;
11013 }
11016 }
11018 LOAD_ERROR;
11023 /* This case handles ldtoken
11024 of an open type, like for
11025 typeof(Gen<>). */
11028 /* If we get a MONO_TYPE_CLASS
11029 then we need to provide the
11030 open type, not an
11031 instantiation of it. */
11034 else
11040 else
11042 }
11063 }
11084 /* Special case for static synchronized wrappers */
11085 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
11087 /* FIXME: n is not a normal token */
11090 }
11093 }
11096 }
11109 MONO_RGCTX_INFO_TYPE);
11118 }
11123 }
11127 }
11128 }
11133 }
11139 ip++;
11150 /* mono_save_seq_point_info () depends on this */
11155 ip++;
11158 /*
11159 * Control will leave the method so empty the stack, otherwise
11160 * the next basic block will start with a nonempty stack.
11161 */
11163 sp--;
11164 }
11176 }
11178 /* empty the stack */
11180 sp--;
11181 }
11183 /*
11184 * If this leave statement is in a catch block, check for a
11185 * pending exception, and rethrow it if necessary.
11186 * We avoid doing this in runtime invoke wrappers, since those are called
11187 * by native code which excepts the wrapper to catch all exceptions.
11188 */
11192 /*
11193 * Use <= in the final comparison to handle clauses with multiple
11194 * leave statements, like in bug #78024.
11195 * The ordering of the exception clauses guarantees that we find the
11196 * innermost clause.
11197 */
11198 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) {
11202 /*
11203 MonoInst *load;
11205 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
11206 */
11212 /*
11213 * Currently, we always rethrow the abort exception, despite the
11214 * fact that this is not correct. See thread6.cs for an example.
11215 * But propagating the abort exception is more important than
11216 * getting the sematics right.
11217 */
11224 }
11225 }
11244 /*
11245 * Link the finally bblock with the target, since it will
11246 * conceptually branch there.
11247 * FIXME: Have to link the bblock containing the endfinally.
11248 */
11251 }
11252 }
11254 }
11265 else
11269 }
11271 /*
11272 * Mono specific opcodes
11273 */
11281 gpointer func;
11302 }
11304 gpointer ptr;
11311 /* FIXME: Generalize this */
11317 }
11322 /* Can't embed random pointers into AOT code */
11325 }
11328 gpointer ptr;
11342 }
11345 gpointer ptr;
11359 }
11363 }
11370 // FIXME:
11376 }
11393 }
11406 /*
11407 * Similar to LDOBJ, but instead load the unmanaged
11408 * representation of the vtype to the stack.
11409 */
11418 {
11433 }
11436 /*
11437 * Same as RET, but return the native representation of a vtype
11438 * to the caller.
11439 */
11455 }
11459 UNVERIFIED;
11468 }
11479 else
11485 }
11488 #ifdef MONO_ARCH_HAVE_LMF_OPS
11492 #endif
11525 }
11526 }
11532 }
11536 /* It would be easier to call a trampoline, but that would put an
11537 * extra frame on the stack, confusing exception handling. So
11538 * implement it inline using an opcode for now.
11539 */
11542 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
11543 /* prevent it from being register allocated */
11545 }
11547 /* Has to use a call inst since it local regalloc expects it */
11561 }
11567 }
11573 cfg->orig_domain_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
11578 #if TARGET_WIN32
11581 #else
11584 #endif
11596 }
11599 /* AOT code is only used in the root domain */
11603 }
11610 }
11613 }
11617 /* Restore the original domain */
11623 }
11627 }
11629 }
11635 /* somewhat similar to LDTOKEN */
11638 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
11649 }
11657 /*
11658 * The following transforms:
11659 * CEE_CEQ into OP_CEQ
11660 * CEE_CGT into OP_CGT
11661 * CEE_CGT_UN into OP_CGT_UN
11662 * CEE_CLT into OP_CLT
11663 * CEE_CLT_UN into OP_CLT_UN
11664 */
11673 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))))
11677 else
11685 /*
11686 * The backends expect the fceq opcodes to do the
11687 * comparison too.
11688 */
11692 }
11697 }
11707 LOAD_ERROR;
11715 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
11716 METHOD_ACCESS_FAILURE;
11721 CHECK_CFG_EXCEPTION;
11724 }
11726 /*
11727 * Optimize the common case of ldftn+delegate creation
11728 */
11729 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
11730 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
11738 LOAD_ERROR;
11748 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
11749 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
11752 }
11753 }
11755 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
11756 /* FIXME: SGEN support */
11760 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11761 sp --;
11763 CHECK_CFG_EXCEPTION;
11765 sp ++;
11767 }
11768 #endif
11769 }
11770 }
11779 }
11788 LOAD_ERROR;
11796 CHECK_CFG_EXCEPTION;
11799 }
11809 else
11815 }
11842 UNVERIFIED;
11866 }
11872 }
11880 UNVERIFIED;
11889 UNVERIFIED;
11891 /*
11892 * Inlining this into a loop in a parent could lead to
11893 * stack overflows which is different behavior than the
11894 * non-inlined case, thus disable inlining in this case.
11895 */
11918 UNVERIFIED;
11930 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
11934 }
11935 }
11938 UNVERIFIED;
11941 }
11944 /* FIXME: record alignment? we can assume 1 for now */
11955 /* Can't inline tail calls at this time */
11968 else
11986 /* Skip optimized paths for volatile operations. */
11987 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)) {
11989 } 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)) {
11990 /* emit_memset only works when val == 0 */
11998 /*
11999 * FIXME: It's unclear whether we should be emitting both the acquire
12000 * and release barriers for cpblk. It is technically both a load and
12001 * store operation, so it seems like that's the sensible thing to do.
12002 */
12005 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
12006 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12008 }
12012 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
12013 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12015 }
12019 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
12020 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
12022 }
12025 }
12026 }
12031 }
12038 /* we ignore the no-nullcheck for now since we
12039 * really do it explicitly only when doing callvirt->call
12040 */
12049 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
12052 }
12053 }
12072 }
12074 guint32 val;
12082 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic && !generic_context) {
12090 }
12095 }
12104 // FIXME:
12107 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12109 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
12113 }
12124 UNVERIFIED;
12128 UNVERIFIED;
12129 }
12131 }
12134 UNVERIFIED;
12138 UNVERIFIED;
12139 }
12140 }
12142 UNVERIFIED;
12146 /* This could already be set because of inlining, #693905 */
12154 }
12166 }
12169 }
12171 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
12173 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
12175 #endif
12185 }
12186 }
12189 /* Emit initialization for ref vars */
12190 // FIXME: Avoid duplication initialization for IL locals.
12196 }
12197 }
12202 }
12210 /*
12211 * Make seq points at backward branch targets interruptable.
12212 */
12216 }
12218 /* Add a sequence point for method entry/exit events */
12224 }
12226 /*
12227 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
12228 * the code they refer to was dead (#11880).
12229 */
12232 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
12237 }
12238 }
12239 }
12251 }
12252 }
12260 /* Method is too large */
12268 }
12277 exception_exit:
12281 inline_failure:
12284 load_error:
12288 unverified:
12292 cleanup:
12298 }
12300 static int
12302 {
12316 }
12319 }
12321 int
12323 {
12368 #if SIZEOF_REGISTER == 8
12371 #endif
12389 #if defined(TARGET_X86) || defined (TARGET_AMD64)
12394 #endif
12395 #if defined(TARGET_AMD64)
12398 #endif
12409 }
12412 }
12414 static int
12416 {
12442 }
12445 }
12447 static int
12449 {
12468 }
12471 }
12473 int
12475 {
12476 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
12477 #if defined(TARGET_X86) || defined(TARGET_AMD64)
12489 #if SIZEOF_REGISTER == 8
12492 #endif
12493 }
12494 #endif
12497 }
12501 {
12502 #if defined(TARGET_X86)
12534 }
12535 #endif
12537 #if defined(TARGET_AMD64)
12538 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
12589 }
12590 #endif
12593 }
12597 {
12598 #if defined(TARGET_X86) || defined(TARGET_AMD64)
12606 }
12607 #endif
12610 }
12614 {
12615 #ifdef TARGET_X86
12616 /* FIXME: This has sign extension issues */
12617 /*
12618 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
12619 return OP_X86_COMPARE_MEMBASE8_IMM;
12620 */
12622 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
12634 }
12635 #endif
12637 #ifdef TARGET_AMD64
12638 /* FIXME: This has sign extension issues */
12639 /*
12640 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
12641 return OP_X86_COMPARE_MEMBASE8_IMM;
12642 */
12646 #ifdef __mono_ilp32__
12648 #else
12650 #endif
12653 /* FIXME: This only works for 32 bit immediates
12654 case OP_COMPARE_IMM:
12655 case OP_LCOMPARE_IMM:
12656 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
12657 return OP_AMD64_COMPARE_MEMBASE_IMM;
12658 */
12665 #ifdef __mono_ilp32__
12669 #else
12671 #endif
12678 }
12679 #endif
12682 }
12686 {
12687 #ifdef TARGET_X86
12688 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
12705 }
12706 #endif
12708 #ifdef TARGET_AMD64
12709 #ifdef __mono_ilp32__
12710 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE) ) {
12711 #else
12713 #endif
12727 }
12728 #ifdef __mono_ilp32__
12730 #else
12732 #endif
12747 }
12748 }
12749 #endif
12752 }
12754 int
12756 {
12758 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
12763 #endif
12764 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
12770 #endif
12771 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
12774 #endif
12777 }
12778 }
12780 /**
12781 * mono_handle_global_vregs:
12782 *
12783 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
12784 * for them.
12785 */
12786 void
12788 {
12795 #ifdef MONO_ARCH_SIMD_INTRINSICS
12798 #endif
12800 /* Find local vregs used in more than one bb */
12812 gint32 prev_bb;
12842 }
12844 #if SIZEOF_REGISTER == 4
12845 /* In the LLVM case, the long opcodes are not decomposed */
12847 /*
12848 * Since some instructions reference the original long vreg,
12849 * and some reference the two component vregs, it is quite hard
12850 * to determine when it needs to be global. So be conservative.
12851 */
12853 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
12857 }
12859 /*
12860 * Make the component vregs volatile since the optimizations can
12861 * get confused otherwise.
12862 */
12865 }
12866 #endif
12872 /* 0 is a valid block num */
12875 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
12885 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
12886 else
12890 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
12893 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
12900 }
12901 }
12903 /* Flag as having been used in more than one bb */
12905 }
12906 }
12907 }
12908 }
12910 /* If a variable is used in only one bblock, convert it into a local vreg */
12921 #if SIZEOF_REGISTER == 8
12923 #endif
12924 #if !defined(TARGET_X86)
12925 /* Enabling this screws up the fp stack on x86 */
12927 #endif
12931 /* Arguments are implicitly global */
12932 /* Putting R4 vars into registers doesn't work currently */
12933 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
12934 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) {
12935 /*
12936 * Make that the variable's liveness interval doesn't contain a call, since
12937 * that would cause the lvreg to be spilled, making the whole optimization
12938 * useless.
12939 */
12940 /* This is too slow for JIT compilation */
12941 #if 0
12961 }
12962 }
12967 ins_index ++;
12968 }
12972 }
12973 #endif
12979 }
12981 }
12982 }
12984 /*
12985 * Compress the varinfo and vars tables so the liveness computation is faster and
12986 * takes up less space.
12987 */
12999 #if SIZEOF_REGISTER == 4
13001 /* Modify the two component vars too */
13008 }
13009 #endif
13010 }
13011 pos ++;
13012 }
13013 }
13017 }
13019 /**
13020 * mono_spill_global_vars:
13021 *
13022 * Generate spill code for variables which are not allocated to registers,
13023 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
13024 * code is generated which could be optimized by the local optimization passes.
13025 */
13026 void
13028 {
13045 /* FIXME: Move this function to mini.c */
13049 #ifdef MONO_ARCH_SIMD_INTRINSICS
13051 #endif
13053 #if SIZEOF_REGISTER == 4
13054 /* Create MonoInsts for longs */
13081 }
13084 }
13085 }
13086 }
13087 #endif
13090 /* registers need liveness info even for !non refs */
13096 }
13097 }
13108 /* Local */
13114 /* Arg */
13117 }
13118 }
13119 }
13120 }
13122 /* FIXME: widening and truncation */
13124 /*
13125 * As an optimization, when a variable allocated to the stack is first loaded into
13126 * an lvreg, we will remember the lvreg and use it the next time instead of loading
13127 * the variable again.
13128 */
13134 /*
13135 * These arrays contain the first and last instructions accessing a given
13136 * variable.
13137 * Since we emit bblocks in the same order we process them here, and we
13138 * don't split live ranges, these will precisely describe the live range of
13139 * the variable, i.e. the instruction range where a valid value can be found
13140 * in the variables location.
13141 * The live range is computed using the liveness info computed by the liveness pass.
13142 * We can't use vmv->range, since that is an abstract live range, and we need
13143 * one which is instruction precise.
13144 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
13145 */
13146 /* FIXME: Only do this if debugging info is requested */
13152 /* Add spill loads/stores */
13159 /* Clear vreg_to_lvreg array */
13177 /*
13178 * We handle LDADDR here as well, since it can only be decomposed
13179 * when variable addresses are known.
13180 */
13185 /* Happens on SPARC/S390 where vtypes are passed by reference */
13190 }
13196 NOT_IMPLEMENTED;
13198 /* gsharedvt arg passed by ref */
13211 /*
13212 * gsharedvt local.
13213 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
13214 */
13221 /* Mark the instruction used to compute the locals var as used */
13224 /* Load the offset */
13227 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
13233 }
13235 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, G_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
13236 /* Load the locals area address */
13239 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
13244 }
13245 /* Compute the address */
13260 }
13264 }
13269 }
13271 /*
13272 * Store opcodes have destbasereg in the dreg, but in reality, it is an
13273 * src register.
13274 * FIXME:
13275 */
13289 else
13299 }
13301 /***************/
13302 /* DREG */
13303 /***************/
13305 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
13319 } 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)) {
13320 /*
13321 * Instead of emitting a load+store, use a _membase opcode.
13322 */
13332 }
13335 guint32 lvreg;
13341 /* Invalidate any previous lvreg for this vreg */
13349 }
13353 #if SIZEOF_REGISTER != 8
13355 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
13357 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
13360 }
13361 else
13362 #endif
13363 {
13366 /* Try to fuse the store into the instruction itself */
13367 /* FIXME: Add more instructions */
13368 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
13374 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
13392 // FIXME: The backends expect the base reg to be in inst_basereg
13399 /* printf ("INS: "); mono_print_ins (ins); */
13400 /* Create a store instruction */
13401 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
13403 /* Insert it after the instruction */
13408 /*
13409 * We can't assign ins->dreg to var->dreg here, since the
13410 * sregs could use it. So set a flag, and do it after
13411 * the sregs.
13412 */
13413 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)))
13415 }
13416 }
13417 }
13422 }
13430 }
13431 }
13433 /************/
13434 /* SREGS */
13435 /************/
13446 guint32 load_opcode;
13450 //mono_inst_set_src_registers (ins, sregs);
13454 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
13458 /* var->dreg is a hreg */
13461 }
13464 }
13475 /* The variable is already loaded to an lvreg */
13479 //mono_inst_set_src_registers (ins, sregs);
13481 }
13483 /* Try to fuse the load into the instruction */
13487 //mono_inst_set_src_registers (ins, sregs);
13492 //mono_inst_set_src_registers (ins, sregs);
13499 //printf ("%d ", srcindex); mono_print_ins (ins);
13503 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) {
13505 /*
13506 * sreg refers to the value loaded by the load
13507 * emitted below, but we need to use ins->dreg
13508 * since it refers to the store emitted earlier.
13509 */
13511 }
13516 }
13517 }
13520 //mono_inst_set_src_registers (ins, sregs);
13522 #if SIZEOF_REGISTER != 8
13524 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
13526 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
13529 }
13530 else
13531 #endif
13532 {
13533 #if SIZEOF_REGISTER == 4
13535 #endif
13539 }
13540 }
13545 }
13547 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
13553 }
13554 }
13555 }
13564 }
13570 }
13573 /* Clear vreg_to_lvreg array */
13580 }
13584 }
13586 /* Extend the live range based on the liveness info */
13592 /* The liveness info is incomplete */
13596 /* Live from at least the first ins of this bb */
13599 }
13602 /* Live at least until the last ins of this bb */
13605 }
13606 }
13607 }
13608 }
13610 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
13611 /*
13612 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
13613 * by storing the current native offset into MonoMethodVar->live_range_start/end.
13614 */
13625 }
13632 else
13634 }
13635 }
13636 }
13637 #endif
13640 /* Nullify if unused */
13643 }
13649 }
13651 /**
13652 * FIXME:
13653 * - use 'iadd' instead of 'int_add'
13654 * - handling ovf opcodes: decompose in method_to_ir.
13655 * - unify iregs/fregs
13656 * -> partly done, the missing parts are:
13657 * - a more complete unification would involve unifying the hregs as well, so
13658 * code wouldn't need if (fp) all over the place. but that would mean the hregs
13659 * would no longer map to the machine hregs, so the code generators would need to
13660 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
13661 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
13662 * fp/non-fp branches speeds it up by about 15%.
13663 * - use sext/zext opcodes instead of shifts
13664 * - add OP_ICALL
13665 * - get rid of TEMPLOADs if possible and use vregs instead
13666 * - clean up usage of OP_P/OP_ opcodes
13667 * - cleanup usage of DUMMY_USE
13668 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
13669 * stack
13670 * - set the stack type and allocate a dreg in the EMIT_NEW macros
13671 * - get rid of all the <foo>2 stuff when the new JIT is ready.
13672 * - make sure handle_stack_args () is called before the branch is emitted
13673 * - when the new IR is done, get rid of all unused stuff
13674 * - COMPARE/BEQ as separate instructions or unify them ?
13675 * - keeping them separate allows specialized compare instructions like
13676 * compare_imm, compare_membase
13677 * - most back ends unify fp compare+branch, fp compare+ceq
13678 * - integrate mono_save_args into inline_method
13679 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
13680 * - handle long shift opts on 32 bit platforms somehow: they require
13681 * 3 sregs (2 for arg1 and 1 for arg2)
13682 * - make byref a 'normal' type.
13683 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
13684 * variable if needed.
13685 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
13686 * like inline_method.
13687 * - remove inlining restrictions
13688 * - fix LNEG and enable cfold of INEG
13689 * - generalize x86 optimizations like ldelema as a peephole optimization
13690 * - add store_mem_imm for amd64
13691 * - optimize the loading of the interruption flag in the managed->native wrappers
13692 * - avoid special handling of OP_NOP in passes
13693 * - move code inserting instructions into one function/macro.
13694 * - try a coalescing phase after liveness analysis
13695 * - add float -> vreg conversion + local optimizations on !x86
13696 * - figure out how to handle decomposed branches during optimizations, ie.
13697 * compare+branch, op_jump_table+op_br etc.
13698 * - promote RuntimeXHandles to vregs
13699 * - vtype cleanups:
13700 * - add a NEW_VARLOADA_VREG macro
13701 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
13702 * accessing vtype fields.
13703 * - get rid of I8CONST on 64 bit platforms
13704 * - dealing with the increase in code size due to branches created during opcode
13705 * decomposition:
13706 * - use extended basic blocks
13707 * - all parts of the JIT
13708 * - handle_global_vregs () && local regalloc
13709 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
13710 * - sources of increase in code size:
13711 * - vtypes
13712 * - long compares
13713 * - isinst and castclass
13714 * - lvregs not allocated to global registers even if used multiple times
13715 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
13716 * meaningful.
13717 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
13718 * - add all micro optimizations from the old JIT
13719 * - put tree optimizations into the deadce pass
13720 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
13721 * specific function.
13722 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
13723 * fcompare + branchCC.
13724 * - create a helper function for allocating a stack slot, taking into account
13725 * MONO_CFG_HAS_SPILLUP.
13726 * - merge r68207.
13727 * - merge the ia64 switch changes.
13728 * - optimize mono_regstate2_alloc_int/float.
13729 * - fix the pessimistic handling of variables accessed in exception handler blocks.
13730 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
13731 * parts of the tree could be separated by other instructions, killing the tree
13732 * arguments, or stores killing loads etc. Also, should we fold loads into other
13733 * instructions if the result of the load is used multiple times ?
13734 * - make the REM_IMM optimization in mini-x86.c arch-independent.
13735 * - LAST MERGE: 108395.
13736 * - when returning vtypes in registers, generate IR and append it to the end of the
13737 * last bb instead of doing it in the epilog.
13738 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
13739 */
13741 /*
13743 NOTES
13744 -----
13746 - When to decompose opcodes:
13747 - earlier: this makes some optimizations hard to implement, since the low level IR
13748 no longer contains the neccessary information. But it is easier to do.
13749 - later: harder to implement, enables more optimizations.
13750 - Branches inside bblocks:
13751 - created when decomposing complex opcodes.
13752 - branches to another bblock: harmless, but not tracked by the branch
13753 optimizations, so need to branch to a label at the start of the bblock.
13754 - branches to inside the same bblock: very problematic, trips up the local
13755 reg allocator. Can be fixed by spitting the current bblock, but that is a
13756 complex operation, since some local vregs can become global vregs etc.
13757 - Local/global vregs:
13758 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
13759 local register allocator.
13760 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
13761 structure, created by mono_create_var (). Assigned to hregs or the stack by
13762 the global register allocator.
13763 - When to do optimizations like alu->alu_imm:
13764 - earlier -> saves work later on since the IR will be smaller/simpler
13765 - later -> can work on more instructions
13766 - Handling of valuetypes:
13767 - When a vtype is pushed on the stack, a new temporary is created, an
13768 instruction computing its address (LDADDR) is emitted and pushed on
13769 the stack. Need to optimize cases when the vtype is used immediately as in
13770 argument passing, stloc etc.
13771 - Instead of the to_end stuff in the old JIT, simply call the function handling
13772 the values on the stack before emitting the last instruction of the bb.
13773 */