| blob | 491a25364e35b3da3b49b5d3e8d6fe59cf7e5945 |
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>
14 #include <signal.h>
16 #ifdef HAVE_UNISTD_H
17 #include <unistd.h>
18 #endif
20 #include <math.h>
21 #include <string.h>
22 #include <ctype.h>
24 #ifdef HAVE_SYS_TIME_H
25 #include <sys/time.h>
26 #endif
28 #ifdef HAVE_ALLOCA_H
29 #include <alloca.h>
30 #endif
32 #include <mono/utils/memcheck.h>
34 #include <mono/metadata/assembly.h>
35 #include <mono/metadata/attrdefs.h>
36 #include <mono/metadata/loader.h>
37 #include <mono/metadata/tabledefs.h>
38 #include <mono/metadata/class.h>
39 #include <mono/metadata/object.h>
40 #include <mono/metadata/exception.h>
41 #include <mono/metadata/opcodes.h>
42 #include <mono/metadata/mono-endian.h>
43 #include <mono/metadata/tokentype.h>
44 #include <mono/metadata/tabledefs.h>
45 #include <mono/metadata/marshal.h>
46 #include <mono/metadata/debug-helpers.h>
47 #include <mono/metadata/mono-debug.h>
48 #include <mono/metadata/gc-internal.h>
49 #include <mono/metadata/security-manager.h>
50 #include <mono/metadata/threads-types.h>
51 #include <mono/metadata/security-core-clr.h>
52 #include <mono/metadata/monitor.h>
53 #include <mono/metadata/profiler-private.h>
54 #include <mono/metadata/profiler.h>
55 #include <mono/metadata/debug-mono-symfile.h>
56 #include <mono/utils/mono-compiler.h>
57 #include <mono/utils/mono-memory-model.h>
58 #include <mono/metadata/mono-basic-block.h>
69 #define BRANCH_COST 10
70 #define INLINE_LENGTH_LIMIT 20
71 #define INLINE_FAILURE(msg) do { \
72 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE)) { \
73 if (cfg->verbose_level >= 2) \
75 goto inline_failure; \
76 } \
77 } while (0)
78 #define CHECK_CFG_EXCEPTION do {\
79 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
80 goto exception_exit;\
81 } while (0)
82 #define METHOD_ACCESS_FAILURE do { \
83 char *method_fname = mono_method_full_name (method, TRUE); \
84 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
85 mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); \
86 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
87 g_free (method_fname); \
88 g_free (cil_method_fname); \
89 goto exception_exit; \
90 } while (0)
91 #define FIELD_ACCESS_FAILURE do { \
92 char *method_fname = mono_method_full_name (method, TRUE); \
93 char *field_fname = mono_field_full_name (field); \
94 mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); \
95 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
96 g_free (method_fname); \
97 g_free (field_fname); \
98 goto exception_exit; \
99 } while (0)
100 #define GENERIC_SHARING_FAILURE(opcode) do { \
101 if (cfg->generic_sharing_context) { \
102 if (cfg->verbose_level > 2) \
103 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__); \
104 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
105 goto exception_exit; \
106 } \
107 } while (0)
108 #define GSHAREDVT_FAILURE(opcode) do { \
109 if (cfg->gsharedvt) { \
110 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__); \
111 if (cfg->verbose_level >= 2) \
113 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
114 goto exception_exit; \
115 } \
116 } while (0)
117 #define OUT_OF_MEMORY_FAILURE do { \
118 mono_cfg_set_exception (cfg, MONO_EXCEPTION_OUT_OF_MEMORY); \
119 goto exception_exit; \
120 } while (0)
121 /* Determine whenever 'ins' represents a load of the 'this' argument */
122 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
130 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
132 /* helper methods signatures */
141 /*
142 * Instruction metadata
143 */
144 #ifdef MINI_OP
145 #undef MINI_OP
146 #endif
147 #ifdef MINI_OP3
148 #undef MINI_OP3
149 #endif
151 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
157 #if SIZEOF_REGISTER == 8
158 #define LREG IREG
159 #else
161 #endif
162 /* keep in sync with the enum in mini.h */
163 const char
164 ins_info[] = {
166 };
167 #undef MINI_OP
168 #undef MINI_OP3
170 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
171 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
172 /*
173 * This should contain the index of the last sreg + 1. This is not the same
174 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
175 */
178 };
179 #undef MINI_OP
180 #undef MINI_OP3
182 #define MONO_INIT_VARINFO(vi,id) do { \
183 (vi)->range.first_use.pos.bid = 0xffff; \
184 (vi)->reg = -1; \
185 (vi)->idx = (id); \
186 } while (0)
188 void
190 {
194 }
196 guint32
198 {
200 }
202 guint32
204 {
206 }
208 guint32
210 {
212 }
214 guint32
216 {
218 }
220 /*
221 * mono_alloc_ireg_ref:
222 *
223 * Allocate an IREG, and mark it as holding a GC ref.
224 */
225 guint32
227 {
229 }
231 /*
232 * mono_alloc_ireg_mp:
233 *
234 * Allocate an IREG, and mark it as holding a managed pointer.
235 */
236 guint32
238 {
240 }
242 /*
243 * mono_alloc_ireg_copy:
244 *
245 * Allocate an IREG with the same GC type as VREG.
246 */
247 guint32
249 {
254 else
256 }
258 guint
260 {
264 handle_enum:
290 #if SIZEOF_REGISTER == 8
292 #else
294 #endif
303 }
317 else
321 }
323 }
325 void
327 {
340 }
342 void
344 {
352 }
354 /*
355 * Can't put this at the beginning, since other files reference stuff from this
356 * file.
357 */
358 #ifndef DISABLE_JIT
360 /*
361 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
362 * foo<T> (int i) { ldarg.0; box T; }
363 */
364 #define UNVERIFIED do { \
365 if (cfg->gsharedvt) { \
366 if (cfg->verbose_level > 2) \
368 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
369 goto exception_exit; \
370 } \
371 if (mini_get_debug_options ()->break_on_unverified) \
372 G_BREAKPOINT (); \
373 else \
374 goto unverified; \
375 } while (0)
377 #define LOAD_ERROR do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto load_error; } while (0)
379 #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)
381 #define GET_BBLOCK(cfg,tblock,ip) do { \
382 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
383 if (!(tblock)) { \
384 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
385 NEW_BBLOCK (cfg, (tblock)); \
386 (tblock)->cil_code = (ip); \
387 ADD_BBLOCK (cfg, (tblock)); \
388 } \
389 } while (0)
391 #if defined(TARGET_X86) || defined(TARGET_AMD64)
392 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
393 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
394 (dest)->dreg = alloc_ireg_mp ((cfg)); \
395 (dest)->sreg1 = (sr1); \
396 (dest)->sreg2 = (sr2); \
397 (dest)->inst_imm = (imm); \
398 (dest)->backend.shift_amount = (shift); \
399 MONO_ADD_INS ((cfg)->cbb, (dest)); \
400 } while (0)
401 #endif
403 #if SIZEOF_REGISTER == 8
404 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
406 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
407 MonoInst *widen; \
408 int dr = alloc_preg (cfg); \
409 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
410 (ins)->sreg2 = widen->dreg; \
411 } \
412 } while (0)
413 #else
414 #define ADD_WIDEN_OP(ins, arg1, arg2)
415 #endif
417 #define ADD_BINOP(op) do { \
418 MONO_INST_NEW (cfg, ins, (op)); \
419 sp -= 2; \
420 ins->sreg1 = sp [0]->dreg; \
421 ins->sreg2 = sp [1]->dreg; \
422 type_from_op (ins, sp [0], sp [1]); \
423 CHECK_TYPE (ins); \
425 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
426 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
427 MONO_ADD_INS ((cfg)->cbb, (ins)); \
428 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
429 } while (0)
431 #define ADD_UNOP(op) do { \
432 MONO_INST_NEW (cfg, ins, (op)); \
433 sp--; \
434 ins->sreg1 = sp [0]->dreg; \
435 type_from_op (ins, sp [0], NULL); \
436 CHECK_TYPE (ins); \
437 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
438 MONO_ADD_INS ((cfg)->cbb, (ins)); \
439 *sp++ = mono_decompose_opcode (cfg, ins); \
440 } while (0)
442 #define ADD_BINCOND(next_block) do { \
443 MonoInst *cmp; \
444 sp -= 2; \
445 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
446 cmp->sreg1 = sp [0]->dreg; \
447 cmp->sreg2 = sp [1]->dreg; \
448 type_from_op (cmp, sp [0], sp [1]); \
449 CHECK_TYPE (cmp); \
450 type_from_op (ins, sp [0], sp [1]); \
451 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
452 GET_BBLOCK (cfg, tblock, target); \
453 link_bblock (cfg, bblock, tblock); \
454 ins->inst_true_bb = tblock; \
455 if ((next_block)) { \
456 link_bblock (cfg, bblock, (next_block)); \
457 ins->inst_false_bb = (next_block); \
458 start_new_bblock = 1; \
459 } else { \
460 GET_BBLOCK (cfg, tblock, ip); \
461 link_bblock (cfg, bblock, tblock); \
462 ins->inst_false_bb = tblock; \
463 start_new_bblock = 2; \
464 } \
465 if (sp != stack_start) { \
466 handle_stack_args (cfg, stack_start, sp - stack_start); \
467 CHECK_UNVERIFIABLE (cfg); \
468 } \
469 MONO_ADD_INS (bblock, cmp); \
470 MONO_ADD_INS (bblock, ins); \
471 } while (0)
473 /* *
474 * link_bblock: Links two basic blocks
475 *
476 * links two basic blocks in the control flow graph, the 'from'
477 * argument is the starting block and the 'to' argument is the block
478 * the control flow ends to after 'from'.
479 */
480 static void
482 {
486 #if 0
489 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
490 else
495 else
497 }
498 #endif
505 }
506 }
511 }
515 }
522 }
523 }
528 }
532 }
533 }
535 void
537 {
539 }
541 /**
542 * mono_find_block_region:
543 *
544 * We mark each basic block with a region ID. We use that to avoid BB
545 * optimizations when blocks are in different regions.
546 *
547 * Returns:
548 * A region token that encodes where this region is, and information
549 * about the clause owner for this block.
550 *
551 * The region encodes the try/catch/filter clause that owns this block
552 * as well as the type. -1 is a special value that represents a block
553 * that is in none of try/catch/filter.
554 */
555 static int
557 {
564 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
573 else
575 }
579 }
582 }
586 {
598 }
599 }
601 }
603 static void
605 {
613 /* prevent it from being register allocated */
617 }
619 MonoInst *
621 {
623 }
627 {
635 /* prevent it from being register allocated */
641 }
643 /*
644 * Returns the type used in the eval stack when @type is loaded.
645 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
646 */
647 void
649 {
656 }
658 handle_enum:
702 }
718 }
722 }
723 }
725 /*
726 * The following tables are used to quickly validate the IL code in type_from_op ().
727 */
728 static const char
738 };
740 static const char
741 neg_table [] = {
743 };
745 /* reduce the size of this table */
746 static const char
756 };
758 static const char
760 /* Inv i L p F & O vt */
769 };
771 /* reduce the size of this table */
772 static const char
782 };
784 /*
785 * Tables to map from the non-specific opcode to the matching
786 * type-specific opcode.
787 */
788 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
789 static const guint16
792 };
794 /* handles from CEE_NEG to CEE_CONV_U8 */
795 static const guint16
798 };
800 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
801 static const guint16
803 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
804 };
806 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
807 static const guint16
809 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
810 };
812 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
813 static const guint16
815 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
816 };
818 /* handles from CEE_BEQ to CEE_BLT_UN */
819 static const guint16
821 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
822 };
824 /* handles from CEE_CEQ to CEE_CLT_UN */
825 static const guint16
827 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
828 };
830 /*
831 * Sets ins->type (the type on the eval stack) according to the
832 * type of the opcode and the arguments to it.
833 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
834 *
835 * FIXME: this function sets ins->type unconditionally in some cases, but
836 * it should set it to invalid for some types (a conv.x on an object)
837 */
838 static void
842 /* binops */
848 /* FIXME: check unverifiable args for STACK_MP */
870 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
874 else
879 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
905 /* unops */
913 else
934 }
967 #if SIZEOF_VOID_P == 8
969 #else
971 #endif
979 }
1047 }
1051 }
1053 static const char
1054 ldind_type [] = {
1055 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1056 };
1058 #if 0
1060 static const char
1063 };
1065 static int
1077 }
1078 args++;
1079 }
1100 }
1113 }
1114 /*if (!param_table [args [i].type] [sig->params [i]->type])
1115 return 0;*/
1116 }
1118 }
1119 #endif
1121 /*
1122 * When we need a pointer to the current domain many times in a method, we
1123 * call mono_domain_get() once and we store the result in a local variable.
1124 * This function returns the variable that represents the MonoDomain*.
1125 */
1128 {
1132 }
1134 /*
1135 * The got_var contains the address of the Global Offset Table when AOT
1136 * compiling.
1137 */
1138 MonoInst *
1140 {
1141 #ifdef MONO_ARCH_NEED_GOT_VAR
1146 }
1148 #else
1150 #endif
1151 }
1155 {
1160 /* force the var to be stack allocated */
1162 }
1165 }
1180 }
1182 }
1186 {
1221 else
1226 }
1229 }
1233 {
1267 }
1269 }
1271 /*
1272 * We try to share variables when possible
1273 */
1276 {
1280 /* inlining can result in deeper stacks */
1300 }
1302 }
1304 static void
1306 {
1307 /*
1308 * Don't use this if a generic_context is set, since that means AOT can't
1309 * look up the method using just the image+token.
1310 * table == 0 means this is a reference made from a wrapper.
1311 */
1313 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1317 }
1318 }
1320 /*
1321 * This function is called to handle items that are left on the evaluation stack
1322 * at basic block boundaries. What happens is that we save the values to local variables
1323 * and we reload them later when first entering the target basic block (with the
1324 * handle_loaded_temps () function).
1325 * A single joint point will use the same variables (stored in the array bb->out_stack or
1326 * bb->in_stack, if the basic block is before or after the joint point).
1327 *
1328 * This function needs to be called _before_ emitting the last instruction of
1329 * the bb (i.e. before emitting a branch).
1330 * If the stack merge fails at a join point, cfg->unverifiable is set.
1331 */
1332 static void
1334 {
1339 gboolean found;
1347 //printf ("bblock %d has out:", bb->block_num);
1351 /* exception handlers are linked, but they should not be considered for stack args */
1354 //printf (" %d", outb->block_num);
1359 }
1360 }
1361 //printf ("\n");
1365 /*
1366 * try to reuse temps already allocated for this purpouse, if they occupy the same
1367 * stack slot and if they are of the same type.
1368 * This won't cause conflicts since if 'local' is used to
1369 * store one of the values in the in_stack of a bblock, then
1370 * the same variable will be used for the same outgoing stack
1371 * slot as well.
1372 * This doesn't work when inlining methods, since the bblocks
1373 * in the inlined methods do not inherit their in_stack from
1374 * the bblock they are inlined to. See bug #58863 for an
1375 * example.
1376 */
1379 else
1381 }
1382 }
1383 }
1387 /* exception handlers are linked, but they should not be considered for stack args */
1394 }
1396 }
1399 }
1409 }
1411 /*
1412 * It is possible that the out bblocks already have in_stack assigned, and
1413 * the in_stacks differ. In this case, we will store to all the different
1414 * in_stacks.
1415 */
1420 /* Find a bblock which has a different in_stack */
1424 /* exception handlers are linked, but they should not be considered for stack args */
1426 bindex++;
1428 }
1436 }
1440 }
1441 bindex ++;
1442 }
1443 }
1444 }
1446 /* Emit code which loads interface_offsets [klass->interface_id]
1447 * The array is stored in memory before vtable.
1448 */
1449 static void
1450 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1451 {
1459 }
1461 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1462 }
1463 }
1465 static void
1466 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1467 {
1469 #ifdef COMPRESSED_INTERFACE_BITMAP
1477 else
1481 #else
1496 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1502 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1503 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1504 }
1505 #endif
1506 }
1508 /*
1509 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1510 * stored in "klass_reg" implements the interface "klass".
1511 */
1512 static void
1513 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1514 {
1515 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1516 }
1518 /*
1519 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1520 * stored in "vtable_reg" implements the interface "klass".
1521 */
1522 static void
1523 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1524 {
1525 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1526 }
1528 /*
1529 * Emit code which checks whenever the interface id of @klass is smaller than
1530 * than the value given by max_iid_reg.
1531 */
1532 static void
1535 {
1540 }
1541 else
1545 else
1547 }
1549 /* Same as above, but obtains max_iid from a vtable */
1550 static void
1553 {
1556 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1558 }
1560 /* Same as above, but obtains max_iid from a klass */
1561 static void
1564 {
1567 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1569 }
1571 static void
1572 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1573 {
1581 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1584 }
1585 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1595 }
1597 }
1599 static void
1600 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1601 {
1603 }
1605 static void
1606 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1607 {
1615 else
1617 }
1619 /*
1620 * Variant of the above that takes a register to the class, not the vtable.
1621 */
1622 static void
1623 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1624 {
1632 else
1634 }
1637 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1638 {
1647 }
1649 }
1653 {
1655 }
1658 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1659 {
1666 }
1668 }
1670 static void
1671 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1673 static void
1674 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1675 {
1681 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1684 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1685 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1689 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1692 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1699 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1701 }
1704 /* Check that the object is a vector too */
1709 }
1718 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1721 }
1722 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1725 }
1726 }
1728 static void
1729 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1730 {
1732 }
1734 static void
1736 {
1755 #if SIZEOF_REGISTER == 8
1759 #endif
1760 }
1761 }
1767 else
1771 /* This could be optimized further if neccesary */
1776 }
1778 }
1780 #if !NO_UNALIGNED_ACCESS
1786 }
1791 }
1792 }
1793 #endif
1799 }
1804 }
1809 }
1810 }
1812 void
1813 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1814 {
1820 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1824 /* This could be optimized further if neccesary */
1832 }
1833 }
1835 #if !NO_UNALIGNED_ACCESS
1844 }
1845 }
1846 #endif
1855 }
1863 }
1871 }
1872 }
1874 static int
1875 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1876 {
1880 handle_enum:
1924 }
1926 }
1928 /*
1929 * target_type_is_incompatible:
1930 * @cfg: MonoCompile context
1931 *
1932 * Check that the item @arg on the evaluation stack can be stored
1933 * in the target type (can be a local, or field, etc).
1934 * The cfg arg can be used to check if we need verification or just
1935 * validity checks.
1936 *
1937 * Returns: non-0 value if arg can't be stored on a target.
1938 */
1939 static int
1941 {
1946 /* FIXME: check that the pointed to types match */
1952 }
1970 /* STACK_MP is needed when setting pinned locals */
1977 /*
1978 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
1979 * in native int. (#688008).
1980 */
1991 /* FIXME: check type compatibility */
2028 /* FIXME: check type compatibility */
2030 }
2040 }
2044 }
2046 }
2048 /*
2049 * Prepare arguments for passing to a function call.
2050 * Return a non-zero value if the arguments can't be passed to the given
2051 * signature.
2052 * The type checks are not yet complete and some conversions may need
2053 * casts on 32 or 64 bit architectures.
2054 *
2055 * FIXME: implement this using target_type_is_incompatible ()
2056 */
2057 static int
2059 {
2066 args++;
2067 }
2073 }
2076 handle_enum:
2096 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2121 }
2136 }
2137 }
2139 }
2141 static int
2143 {
2157 }
2160 }
2162 static int
2164 {
2178 }
2181 }
2183 #ifdef MONO_ARCH_HAVE_IMT
2184 static void
2185 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2186 {
2202 }
2204 #ifdef ENABLE_LLVM
2206 #endif
2207 #ifdef MONO_ARCH_IMT_REG
2209 #else
2210 /* Need this to keep the IMT arg alive */
2212 #endif
2214 }
2216 #ifdef MONO_ARCH_IMT_REG
2229 }
2232 #else
2234 #endif
2235 }
2236 #endif
2240 {
2248 }
2253 {
2255 #ifdef MONO_ARCH_SOFT_FLOAT
2257 #endif
2261 else
2262 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2273 //g_assert_not_reached ();
2274 }
2281 /*
2282 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2283 * address of return value to increase optimization opportunities.
2284 * Before vtype decomposition, the dreg of the call ins itself represents the
2285 * fact the call modifies the return value. After decomposition, the call will
2286 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2287 * will be transformed into an LDADDR.
2288 */
2292 /* We reference the call too since call->dreg could change during optimization */
2302 #ifdef MONO_ARCH_SOFT_FLOAT
2304 /*
2305 * If the call has a float argument, we would need to do an r8->r4 conversion using
2306 * an icall, but that cannot be done during the call sequence since it would clobber
2307 * the call registers + the stack. So we do it before emitting the call.
2308 */
2315 else
2326 /* The result will be in an int vreg */
2328 }
2329 }
2330 }
2331 #endif
2335 #ifdef ENABLE_LLVM
2338 else
2340 #else
2342 #endif
2348 }
2350 static void
2352 {
2353 #ifdef MONO_ARCH_RGCTX_REG
2357 #ifdef ENABLE_LLVM
2359 #endif
2360 #else
2361 NOT_IMPLEMENTED;
2362 #endif
2363 }
2366 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2367 {
2374 }
2376 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2386 }
2388 /* This is like calli, but we pass rgctx/imt arguments as well */
2390 emit_gsharedvt_call (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoMethod *method, MonoInst *imt_arg, MonoInst *rgctx_arg)
2391 {
2398 }
2400 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2413 }
2416 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2418 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2423 {
2424 gboolean might_be_remote;
2430 gboolean need_unbox_trampoline;
2435 }
2438 /* Create the real signature */
2439 /* FIXME: Cache these */
2444 }
2457 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2460 }
2462 need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
2464 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, FALSE, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2468 else
2478 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2479 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2484 /* Make a call to delegate->invoke_impl */
2490 /* We must emit a dummy use here because the delegate trampoline will
2491 replace the 'this' argument with the delegate target making this activation
2492 no longer a root for the delegate.
2493 This is an issue for delegates that target collectible code such as dynamic
2494 methods of GC'able assemblies.
2496 For a test case look into #667921.
2498 FIXME: a dummy use is not the best way to do it as the local register allocator
2499 will put it on a caller save register and spil it around the call.
2500 Ideally, we would either put it on a callee save register or only do the store part.
2501 */
2505 }
2506 #endif
2513 /*
2514 * the method is not virtual, we just need to ensure this is not null
2515 * and then we can call the method directly.
2516 */
2518 /*
2519 * The check above ensures method is not gshared, this is needed since
2520 * gshared methods can't have wrappers.
2521 */
2523 }
2530 /*
2531 * the method is virtual, but we can statically dispatch since either
2532 * it's class or the method itself are sealed.
2533 * But first we need to ensure it's not a null reference.
2534 */
2542 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2545 #ifdef MONO_ARCH_HAVE_IMT
2551 }
2552 #endif
2557 }
2562 #ifdef MONO_ARCH_HAVE_IMT
2566 }
2567 #endif
2568 }
2572 }
2573 }
2581 }
2583 MonoInst*
2585 {
2586 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL, NULL);
2587 }
2589 MonoInst*
2592 {
2603 }
2605 MonoInst*
2607 {
2613 }
2615 /*
2616 * mono_emit_abs_call:
2617 *
2618 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2619 */
2623 {
2627 /*
2628 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2629 * handle it.
2630 */
2637 }
2641 {
2646 /*
2647 * Native code might return non register sized integers
2648 * without initializing the upper bits.
2649 */
2665 }
2674 }
2675 }
2676 }
2679 }
2683 {
2689 }
2691 }
2693 static void
2694 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
2695 {
2712 }
2713 }
2714 }
2716 static void
2718 {
2720 gpointer card_table_mask;
2734 #ifdef MONO_ARCH_HAVE_CARD_TABLE_WBARRIER
2736 #endif
2745 else
2757 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
2758 * IMM's larger than 32bits.
2759 */
2767 }
2774 }
2782 }
2783 }
2785 static gboolean
2786 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
2787 {
2794 /*types with references can't have alignment smaller than sizeof(void*) */
2798 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
2804 /* We don't unroll more than 5 stores to avoid code bloat. */
2806 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
2814 }
2823 /*tmp = dreg*/
2837 /*tmp += sizeof (void*)*/
2841 }
2842 }
2844 /* Those cannot be references since size < sizeof (void*) */
2850 }
2857 }
2864 }
2867 }
2869 /*
2870 * Emit code to copy a valuetype of type @klass whose address is stored in
2871 * @src->dreg to memory whose address is stored at @dest->dreg.
2872 */
2873 void
2874 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2875 {
2883 /*
2884 * This check breaks with spilled vars... need to handle it during verification anyway.
2885 * g_assert (klass && klass == src->klass && klass == dest->klass);
2886 */
2892 }
2896 else
2899 /* if native is true there should be no references in the struct */
2901 /* Avoid barriers when storing to the stack */
2912 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
2913 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
2923 }
2924 }
2928 }
2929 }
2932 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2939 else
2944 }
2945 }
2949 {
2955 }
2957 }
2959 void
2961 {
2964 guint32 align;
2968 /* FIXME: Optimize this for the case when dest is an LDADDR */
2977 }
2981 }
2988 else
2991 }
2992 }
2996 {
3029 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3031 }
3039 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3041 }
3042 }
3045 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3046 {
3056 }
3060 {
3061 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3062 }
3067 {
3068 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);
3072 }
3074 /*
3075 * emit_get_rgctx_method:
3076 *
3077 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3078 * normal constants, else emit a load from the rgctx.
3079 */
3083 {
3096 }
3098 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);
3102 }
3103 }
3108 {
3109 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);
3113 }
3115 /*
3116 * On return the caller must check @klass for load errors.
3117 */
3118 static void
3120 {
3137 }
3140 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
3141 else
3142 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
3143 #ifdef MONO_ARCH_VTABLE_REG
3146 #else
3147 NOT_IMPLEMENTED;
3148 #endif
3149 }
3151 static void
3153 {
3159 }
3160 }
3162 static void
3164 {
3174 }
3180 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3182 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3183 }
3184 }
3186 static void
3188 {
3189 /* Reset the variables holding the cast details */
3194 /* It is enough to reset the from field */
3195 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3196 }
3197 }
3199 /*
3200 * On return the caller must check @array_class for load errors
3201 */
3202 static void
3204 {
3213 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3224 }
3245 }
3246 }
3251 }
3253 /**
3254 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3255 * generic code is generated.
3256 */
3259 {
3265 /* FIXME: What if the class is shared? We might not
3266 have to get the address of the method from the
3267 RGCTX. */
3269 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3276 }
3277 }
3281 {
3290 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3291 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3293 /* FIXME: generics */
3296 // Check rank == 0
3301 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3306 /* This assertion is from the unboxcast insn */
3318 }
3320 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
3326 }
3328 /*
3329 * Returns NULL and set the cfg exception on error.
3330 */
3333 {
3342 /*
3343 FIXME: we cannot get managed_alloc here because we can't get
3344 the class's vtable (because it's not a closed class)
3346 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3347 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3348 */
3352 else
3363 }
3366 }
3373 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3374 /* This happens often in argument checking code, eg. throw new FooException... */
3375 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3381 gboolean pass_lw;
3387 }
3389 #ifndef MONO_CROSS_COMPILE
3391 #endif
3396 }
3403 }
3406 }
3407 }
3410 }
3412 /*
3413 * Returns NULL and set the cfg exception on error.
3414 */
3417 {
3424 /* FIXME: What if the class is shared? We might not
3425 have to get the method address from the RGCTX. */
3427 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3433 }
3434 }
3441 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3444 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3445 }
3448 }
3451 static gboolean
3452 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
3453 {
3466 }
3470 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
3475 }
3477 }
3479 // FIXME: This doesn't work yet (class libs tests fail?)
3480 #define is_complex_isinst(klass) (TRUE || (klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || klass->marshalbyref || (klass->flags & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
3482 /*
3483 * Returns NULL and set the cfg exception on error.
3484 */
3487 {
3502 /* obj */
3505 /* klass - it's the second element of the cache entry*/
3506 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3508 /* cache */
3512 }
3517 /* Complex case, handle by an icall */
3519 /* obj */
3522 /* klass */
3527 /* Simple case, handled by the code below */
3528 }
3529 }
3546 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3547 /* the remoting code is broken, access the class for now */
3548 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3554 }
3559 }
3564 }
3565 }
3572 }
3574 /*
3575 * Returns NULL and set the cfg exception on error.
3576 */
3579 {
3596 /* obj */
3599 /* klass - it's the second element of the cache entry*/
3600 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3602 /* cache */
3606 }
3611 /* Complex case, handle by an icall */
3613 /* obj */
3616 /* klass */
3621 /* Simple case, the code below can handle it */
3622 }
3623 }
3629 /* Do the assignment at the beginning, so the other assignment can be if converted */
3641 /* the is_null_bb target simply copies the input register to the output */
3651 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3655 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3659 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3663 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3673 /* Check that the object is a vector too */
3678 }
3680 /* the is_null_bb target simply copies the input register to the output */
3682 }
3686 /* the is_null_bb target simply copies the input register to the output */
3689 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3691 /* the remoting code is broken, access the class for now */
3692 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3698 }
3703 }
3708 /* the is_null_bb target simply copies the input register to the output */
3710 }
3711 }
3712 }
3724 }
3728 {
3729 /* This opcode takes as input an object reference and a class, and returns:
3730 0) if the object is an instance of the class,
3731 1) if the object is not instance of the class,
3732 2) if the object is a proxy whose type cannot be determined */
3759 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3762 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3770 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3772 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3773 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3776 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3786 }
3804 /* FIXME: */
3810 }
3814 {
3815 /* This opcode takes as input an object reference and a class, and returns:
3816 0) if the object is an instance of the class,
3817 1) if the object is a proxy whose type cannot be determined
3818 an InvalidCastException exception is thrown otherwhise*/
3846 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3858 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3861 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3862 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3865 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3881 }
3889 /* FIXME: */
3895 }
3897 /*
3898 * Returns NULL and set the cfg exception on error.
3899 */
3901 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3902 {
3914 /* Inline the contents of mono_delegate_ctor */
3916 /* Set target field */
3917 /* Optimize away setting of NULL target */
3919 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3922 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target));
3924 }
3925 }
3927 /* Set method field */
3929 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3932 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method));
3934 }
3935 /*
3936 * To avoid looking up the compiled code belonging to the target method
3937 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3938 * store it, and we fill it after the method has been compiled.
3939 */
3944 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3954 }
3958 }
3959 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3960 }
3962 /* Set invoke_impl field */
3968 }
3969 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3971 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3974 }
3978 {
3981 /* Need to register the icall so it gets an icall wrapper */
3986 /* mono_array_new_va () needs a vararg calling convention */
3989 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3991 }
3993 static void
3995 {
4005 /* Add it to the start of the first bblock */
4009 }
4010 else
4015 /*
4016 * Add a dummy use to keep the got_var alive, since real uses might
4017 * only be generated by the back ends.
4018 * Add it to end_bblock, so the variable's lifetime covers the whole
4019 * method.
4020 * It would be better to make the usage of the got var explicit in all
4021 * cases when the backend needs it (i.e. calls, throw etc.), so this
4022 * wouldn't be needed.
4023 */
4026 }
4031 static gboolean
4033 {
4034 MonoMethodHeaderSummary header;
4036 #ifdef MONO_ARCH_SOFT_FLOAT
4039 #endif
4047 #ifdef MONO_ARCH_HAVE_LMF_OPS
4052 #endif
4058 /*runtime, icall and pinvoke are checked by summary call*/
4065 /* also consider num_locals? */
4066 /* Do the size check early to avoid creating vtables */
4070 else
4073 }
4074 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
4077 /*
4078 * if we can initialize the class of the method right away, we do,
4079 * otherwise we don't allow inlining if the class needs initialization,
4080 * since it would mean inserting a call to mono_runtime_class_init()
4081 * inside the inlined code
4082 */
4086 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
4088 /* No vtable created yet */
4093 /* This makes so that inline cannot trigger */
4094 /* .cctors: too many apps depend on them */
4095 /* running with a specific order... */
4099 }
4102 /* No vtable created yet */
4109 }
4111 /*
4112 * If we're compiling for shared code
4113 * the cctor will need to be run at aot method load time, for example,
4114 * or at the end of the compilation of the inlining method.
4115 */
4116 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
4118 }
4120 /*
4121 * CAS - do not inline methods with declarative security
4122 * Note: this has to be before any possible return TRUE;
4123 */
4127 #ifdef MONO_ARCH_SOFT_FLOAT
4128 /* FIXME: */
4134 #endif
4137 }
4139 static gboolean
4141 {
4152 /* The initialization is already done before the method is called */
4156 }
4159 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4160 {
4162 guint32 size;
4171 }
4177 #if SIZEOF_REGISTER == 8
4178 /* The array reg is 64 bits but the index reg is only 32 */
4180 /* Not needed */
4185 }
4186 #else
4192 }
4193 #endif
4198 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4202 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
4207 }
4208 #endif
4215 /* gsharedvt */
4219 rgctx_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE);
4223 }
4231 }
4233 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4235 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4236 {
4250 guint32 size;
4258 #if SIZEOF_REGISTER == 8
4259 /* The array reg is 64 bits but the index reg is only 32 */
4261 /* Not needed */
4269 }
4270 #else
4271 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
4273 #endif
4275 /* range checking */
4306 }
4307 #endif
4310 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
4311 {
4322 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4323 /* emit_ldelema_2 depends on OP_LMUL */
4326 }
4327 #endif
4334 }
4336 static MonoBreakPolicy
4338 {
4340 }
4344 /**
4345 * mono_set_break_policy:
4346 * policy_callback: the new callback function
4347 *
4348 * Allow embedders to decide wherther to actually obey breakpoint instructions
4349 * (both break IL instructions and Debugger.Break () method calls), for example
4350 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4351 * untrusted or semi-trusted code.
4352 *
4353 * @policy_callback will be called every time a break point instruction needs to
4354 * be inserted with the method argument being the method that calls Debugger.Break()
4355 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4356 * if it wants the breakpoint to not be effective in the given method.
4357 * #MONO_BREAK_POLICY_ALWAYS is the default.
4358 */
4359 void
4361 {
4364 else
4366 }
4368 static gboolean
4380 }
4381 }
4383 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
4385 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4386 {
4390 /* the bounds check is already done by the callers */
4400 }
4402 }
4405 static gboolean
4407 {
4409 }
4413 {
4440 // FIXME-VT: OP_ICONST optimization
4447 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
4457 }
4459 }
4460 }
4463 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4464 {
4469 else
4479 }
4480 }
4483 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4484 {
4486 #ifdef MONO_ARCH_SIMD_INTRINSICS
4491 }
4492 #endif
4495 }
4499 {
4506 }
4509 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4510 {
4514 /* The LLVM backend supports these intrinsics */
4524 }
4532 }
4554 }
4555 }
4564 }
4565 }
4568 }
4571 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4572 {
4578 }
4581 }
4584 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4585 {
4600 #if SIZEOF_REGISTER == 8
4601 /* The array reg is 64 bits but the index reg is only 32 */
4603 #else
4605 #endif
4608 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4609 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
4611 /* Avoid a warning */
4615 #else
4620 #endif
4625 /* Decompose later to allow more optimizations */
4637 /* The corlib functions check for oob already. */
4640 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4649 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4650 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4654 #if !defined(MONO_ARCH_EMULATE_MUL_DIV)
4664 #endif
4675 #ifndef MONO_BIG_ARRAYS
4676 /*
4677 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
4678 * Array methods.
4679 */
4680 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
4693 /* Non-szarray case */
4697 else
4702 /* Szarray case */
4706 else
4714 }
4715 #endif
4754 }
4757 /* FIXME this should be integrated to the check below once we support the trampoline version */
4758 #if defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4762 /* Avoid infinite recursion */
4763 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN && !strcmp (cfg->method->name, "FastMonitorEnterV4"))
4771 }
4772 #endif
4774 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4779 /*
4780 * Pass the argument normally, the LLVM backend will handle the
4781 * calling convention problems.
4782 */
4783 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4789 }
4796 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4802 }
4805 }
4806 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4807 {
4810 /* Avoid infinite recursion */
4823 }
4824 #endif
4830 #if SIZEOF_REGISTER == 8
4832 /* 64 bit reads are already atomic */
4838 }
4839 #endif
4841 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4848 #if SIZEOF_REGISTER == 8
4851 #endif
4865 }
4872 #if SIZEOF_REGISTER == 8
4875 #endif
4889 }
4895 #if SIZEOF_REGISTER == 8
4898 #endif
4908 }
4909 }
4912 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4914 guint32 opcode;
4919 #if SIZEOF_REGISTER == 8
4923 #else
4926 #endif
4927 else
4950 }
4954 }
4957 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4984 /* g_assert_not_reached (); */
4985 }
4988 }
5001 }
5003 }
5006 #ifdef TARGET_WIN32
5008 #else
5010 #endif
5012 }
5014 /*
5015 * There is general branches code for Min/Max, but it does not work for
5016 * all inputs:
5017 * http://everything2.com/?node_id=1051618
5018 */
5019 }
5021 #ifdef MONO_ARCH_SIMD_INTRINSICS
5026 }
5027 #endif
5033 }
5036 }
5038 /*
5039 * This entry point could be used later for arbitrary method
5040 * redirection.
5041 */
5045 {
5047 /* managed string allocation support */
5048 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
5054 #ifndef MONO_CROSS_COMPILE
5056 #endif
5062 }
5063 }
5065 }
5067 static void
5069 {
5074 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
5076 /*
5077 * FIXME: We should use *args++ = sp [0], but that would mean the arg
5078 * would be different than the MonoInst's used to represent arguments, and
5079 * the ldelema implementation can't deal with that.
5080 * Solution: When ldelema is used on an inline argument, create a var for
5081 * it, emit ldelema on that var, and emit the saving code below in
5082 * inline_method () if needed.
5083 */
5086 /* This uses cfg->args [i] which is set by the preceeding line */
5089 sp++;
5090 }
5091 }
5093 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
5094 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
5096 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5097 static gboolean
5099 {
5108 else
5110 }
5118 //return (strncmp_result <= 0);
5122 }
5123 }
5124 #endif
5126 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5127 static gboolean
5129 {
5139 }
5140 }
5148 //return (strncmp_result <= 0);
5152 }
5153 }
5154 #endif
5156 static void
5158 {
5186 }
5187 }
5189 static int
5190 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
5192 {
5200 guint prev_real_offset;
5205 guint32 prev_cil_offset_to_bb_len;
5212 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
5215 #endif
5216 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
5219 #endif
5222 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
5227 }
5229 /* allocate local variables */
5242 }
5244 /*Must verify before creating locals as it can cause the JIT to assert.*/
5248 }
5250 /* allocate space to store the return value */
5253 }
5260 /* allocate start and end blocks */
5261 /* This is needed so if the inline is aborted, we can clean up */
5288 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
5308 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
5312 /* always add some code to avoid block split failures */
5319 /*
5320 * Get rid of the begin and end bblocks if possible to aid local
5321 * optimizations.
5322 */
5325 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
5332 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
5335 }
5337 /*
5338 * Its possible that the rvar is set in some prev bblock, but not in others.
5339 * (#1835).
5340 */
5351 }
5352 }
5353 }
5356 }
5359 /*
5360 * If the inlined method contains only a throw, then the ret var is not
5361 * set, so set it to a dummy value.
5362 */
5368 }
5377 /* This gets rid of the newly added bblocks */
5379 }
5382 }
5384 /*
5385 * Some of these comments may well be out-of-date.
5386 * Design decisions: we do a single pass over the IL code (and we do bblock
5387 * splitting/merging in the few cases when it's required: a back jump to an IL
5388 * address that was not already seen as bblock starting point).
5389 * Code is validated as we go (full verification is still better left to metadata/verify.c).
5390 * Complex operations are decomposed in simpler ones right away. We need to let the
5391 * arch-specific code peek and poke inside this process somehow (except when the
5392 * optimizations can take advantage of the full semantic info of coarse opcodes).
5393 * All the opcodes of the form opcode.s are 'normalized' to opcode.
5394 * MonoInst->opcode initially is the IL opcode or some simplification of that
5395 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
5396 * opcode with value bigger than OP_LAST.
5397 * At this point the IR can be handed over to an interpreter, a dumb code generator
5398 * or to the optimizing code generator that will translate it to SSA form.
5399 *
5400 * Profiling directed optimizations.
5401 * We may compile by default with few or no optimizations and instrument the code
5402 * or the user may indicate what methods to optimize the most either in a config file
5403 * or through repeated runs where the compiler applies offline the optimizations to
5404 * each method and then decides if it was worth it.
5405 */
5407 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
5408 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
5409 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
5410 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
5411 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
5412 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
5413 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
5414 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; LOAD_ERROR;}
5416 /* offset from br.s -> br like opcodes */
5417 #define BIG_BRANCH_OFFSET 13
5419 static gboolean
5421 {
5425 }
5427 static int
5428 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
5429 {
5433 guint cli_addr;
5441 UNVERIFIED;
5445 ip++;
5480 guint32 j;
5490 }
5492 }
5499 }
5504 /* Find the start of the bblock containing the throw */
5508 bb_start --;
5509 }
5512 }
5513 }
5515 unverified:
5516 exception_exit:
5519 }
5522 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5523 {
5532 }
5535 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5536 {
5539 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
5543 }
5547 {
5552 else
5557 }
5559 /*
5560 * Returns TRUE if the JIT should abort inlining because "callee"
5561 * is influenced by security attributes.
5562 */
5563 static
5565 {
5566 guint32 result;
5570 }
5577 /* Generate code to throw a SecurityException before the actual call/link */
5585 /* don't hide previous results */
5589 }
5592 }
5596 {
5602 }
5605 }
5607 static void
5609 {
5615 }
5617 /*
5618 * Return the original method is a wrapper is specified. We can only access
5619 * the custom attributes from the original method.
5620 */
5623 {
5627 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
5631 /* in other cases we need to find the original method */
5633 }
5635 static void
5636 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
5638 {
5639 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5640 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
5643 }
5645 static void
5646 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
5648 {
5649 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5650 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
5653 }
5655 /*
5656 * Check that the IL instructions at ip are the array initialization
5657 * sequence and return the pointer to the data and the size.
5658 */
5660 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
5661 {
5662 /*
5663 * newarr[System.Int32]
5664 * dup
5665 * ldtoken field valuetype ...
5666 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5667 */
5672 guint32 rva;
5677 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
5688 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
5695 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5696 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5706 #ifdef ARM_FPU_FPA
5708 #endif
5712 #endif
5715 }
5720 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5725 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5726 /* for aot code we do the lookup on load */
5730 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5733 }
5735 }
5737 }
5739 static void
5741 {
5748 else
5751 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5755 }
5757 static void
5759 {
5763 }
5765 static void
5767 {
5772 /* Optimize reg-reg moves away */
5773 /*
5774 * Can't optimize other opcodes, since sp[0] might point to
5775 * the last ins of a decomposed opcode.
5776 */
5780 }
5781 }
5783 /*
5784 * ldloca inhibits many optimizations so try to get rid of it in common
5785 * cases.
5786 */
5789 {
5799 }
5801 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5804 /* From the INITOBJ case */
5814 }
5818 }
5819 load_error:
5821 }
5823 static gboolean
5825 {
5830 }
5832 }
5834 /*
5835 * is_jit_optimizer_disabled:
5836 *
5837 * Determine whenever M's assembly has a DebuggableAttribute with the
5838 * IsJITOptimizerDisabled flag set.
5839 */
5840 static gboolean
5842 {
5854 klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
5856 /* Linked away */
5861 }
5873 /* Decode the attribute. See reflection.c */
5879 // FIXME: Support named parameters
5881 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
5883 /* Two boolean arguments */
5884 p ++;
5886 }
5888 }
5895 }
5897 static gboolean
5898 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig)
5899 {
5900 gboolean supported_tail_call;
5903 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
5904 supported_tail_call = MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
5905 #else
5906 supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
5907 #endif
5910 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
5911 /* These can point to the current method's stack */
5913 }
5915 /* this might point to the current method's stack */
5924 /* Debugging support */
5925 #if 0
5929 }
5930 #endif
5933 }
5935 /* the JIT intercepts ldflda instructions to the tlsdata field in ThreadLocal<T> and redirects
5936 * it to the thread local value based on the tls_offset field. Every other kind of access to
5937 * the field causes an assert.
5938 */
5939 static gboolean
5941 {
5947 }
5949 /* emits the code needed to access a managed tls var (like ThreadStatic)
5950 * with the value of the tls offset in offset_reg. thread_ins represents the MonoInternalThread
5951 * pointer for the current thread.
5952 * Returns the MonoInst* representing the address of the tls var.
5953 */
5956 {
5960 // inlined access to the tls data
5961 // idx = (offset >> 24) - 1;
5962 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
5964 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
5977 }
5979 /*
5980 * redirect access to the tlsdata field to the tls var given by the tls_offset field.
5981 * this address is cached per-method in cached_tls_addr.
5982 */
5984 create_magic_tls_access (MonoCompile *cfg, MonoClassField *tls_field, MonoInst **cached_tls_addr, MonoInst *thread_local)
5985 {
5992 }
5996 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, offset_field->type, thread_local->dreg, offset_field->offset);
6001 thread_method = mono_class_get_method_from_name (mono_get_thread_class(), "CurrentInternalThread_internal", 0);
6003 }
6007 *cached_tls_addr = temp = mono_compile_create_var (cfg, type_from_stack_type (addr), OP_LOCAL);
6012 }
6014 /*
6015 * mono_method_to_ir:
6016 *
6017 * Translate the .net IL into linear IR.
6018 */
6019 int
6020 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
6023 {
6024 MonoError error;
6044 guint num_args;
6047 MonoDeclSecurityActions actions;
6059 /* serialization and xdomain stuff may need access to private fields and methods */
6069 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
6084 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
6085 }
6087 }
6098 #ifdef PLATFORM_ANDROID
6100 #endif
6109 mono_debug_symfile_get_line_numbers_full (minfo, NULL, NULL, &n_il_offsets, &il_offsets, &line_numbers, NULL, NULL);
6110 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6115 }
6116 }
6117 }
6119 /*
6120 * Methods without init_locals set could cause asserts in various passes
6121 * (#497220).
6122 */
6129 }
6131 /* SkipVerification is not allowed if core-clr is enabled */
6135 }
6152 }
6160 }
6162 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
6183 /* ENTRY BLOCK */
6188 #if defined(__native_client_codegen__)
6192 #endif
6194 /* EXIT BLOCK */
6207 }
6208 /* handle exception clauses */
6232 /* finally clauses already have a seq point */
6235 }
6237 /* todo: is a fault block unsafe to optimize? */
6240 }
6243 /*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);
6244 while (p < end) {
6245 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
6246 }*/
6247 /* catch and filter blocks get the exception object on the stack */
6252 /* mostly like handle_stack_args (), but just sets the input args */
6253 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
6258 /*
6259 * Add a dummy use for the exvar so its liveness info will be
6260 * correct.
6261 */
6271 /* The filter block shares the exvar with the handler block */
6275 }
6276 }
6282 /*
6283 * In shared generic code with catch
6284 * clauses containing type variables
6285 * the exception handling code has to
6286 * be able to get to the rgctx.
6287 * Therefore we have to make sure that
6288 * the vtable/mrgctx argument (for
6289 * static or generic methods) or the
6290 * "this" argument (for non-static
6291 * methods) are live.
6292 */
6301 }
6302 }
6303 }
6309 }
6311 /* FIRST CODE BLOCK */
6324 }
6325 }
6331 /* at this point having security doesn't mean we have any code to generate */
6333 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
6334 * And we do not want to enter the next section (with allocation) if we
6335 * have nothing to generate */
6337 }
6339 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
6346 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
6349 }
6357 }
6360 }
6362 /* not a P/Invoke after all */
6364 }
6365 }
6367 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
6368 /* we use a separate basic block for the initialization code */
6381 }
6383 /* at this point we know, if security is TRUE, that some code needs to be generated */
6390 /* Add code for SecurityAction.Demand */
6393 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6395 }
6397 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
6398 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
6401 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6403 }
6405 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
6408 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
6410 }
6411 }
6413 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
6416 }
6419 /* check if this is native code, e.g. an icall or a p/invoke */
6426 /* if this ia a native call then it can only be JITted from platform code */
6432 }
6433 }
6434 }
6435 }
6436 }
6439 UNVERIFIED;
6443 UNVERIFIED;
6444 }
6451 UNVERIFIED;
6452 }
6455 /* We force the vtable variable here for all shared methods
6456 for the possibility that they might show up in a stack
6457 trace where their exact instantiation is needed. */
6464 /* FIXME: Is there a better way to do this?
6465 We need the variable live for the duration
6466 of the whole method. */
6468 }
6469 }
6471 /* add a check for this != NULL to inlined methods */
6478 }
6485 UNVERIFIED;
6486 }
6488 }
6490 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
6491 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
6499 else
6511 }
6521 }
6532 }
6541 }
6544 }
6545 }
6563 }
6567 }
6568 }
6569 /*
6570 * Sequence points are points where the debugger can place a breakpoint.
6571 * Currently, we generate these automatically at points where the IL
6572 * stack is empty.
6573 */
6574 if (seq_points && ((sp == stack_start) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
6575 /*
6576 * Make methods interruptable at the beginning, and at the targets of
6577 * backward branches.
6578 * Also, do this at the start of every bblock in methods with clauses too,
6579 * to be able to handle instructions with inprecise control flow like
6580 * throw/endfinally.
6581 * Backward branches are handled at the end of method-to-ir ().
6582 */
6585 /* Avoid sequence points on empty IL like .volatile */
6586 // FIXME: Enable this
6587 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
6590 }
6598 /* TODO: Use an increment here */
6599 #if defined(TARGET_X86)
6604 #else
6607 #endif
6608 }
6611 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
6616 /*
6617 * The C# compiler uses these nops to notify the JIT that it should
6618 * insert seq points.
6619 */
6622 }
6625 else
6627 ip++;
6635 }
6636 ip++;
6647 ip++;
6658 ip++;
6670 UNVERIFIED;
6675 }
6702 UNVERIFIED;
6725 }
6731 }
6738 UNVERIFIED;
6801 #ifdef TARGET_POWERPC
6802 /* FIXME: Clean this up */
6805 #endif
6807 /* FIXME: we should really allocate this only late in the compilation process */
6827 }
6833 }
6838 #ifdef TARGET_POWERPC
6839 /* FIXME: Clean this up */
6842 #endif
6844 /* FIXME: we should really allocate this only late in the compilation process */
6864 }
6870 }
6875 sp--;
6890 }
6893 ip++;
6896 #ifdef TARGET_X86
6898 /* we need to pop the value from the x86 FP stack */
6900 #endif
6910 UNVERIFIED;
6912 /* FIXME: check the signature matches */
6916 LOAD_ERROR;
6922 CHECK_CFG_EXCEPTION;
6924 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6925 {
6929 /* Handle tail calls similarly to calls */
6943 }
6944 #else
6946 /* Prevent arguments from being optimized away */
6953 #endif
6958 }
6987 else
6995 /*
6996 * This is a call through a function pointer using a pinvoke
6997 * signature. Have to create a wrapper and call that instead.
6998 * FIXME: This is very slow, need to create a wrapper at JIT time
6999 * instead based on the signature.
7000 */
7005 }
7017 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_call, generic_context);
7018 }
7025 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
7026 /*
7027 * This is needed since get_method_constrained can't find
7028 * the method in klass representing a type var.
7029 * The type var is guaranteed to be a reference type in this
7030 * case.
7031 */
7036 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
7037 }
7041 }
7044 LOAD_ERROR;
7048 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
7049 }
7052 METHOD_ACCESS_FAILURE;
7053 }
7059 /* MS.NET seems to silently convert this to a callvirt */
7062 {
7063 /*
7064 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
7065 * converts to a callvirt.
7066 *
7067 * tests/bug-515884.il is an example of this behavior
7068 */
7069 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
7071 if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
7073 }
7087 LOAD_ERROR;
7097 }
7098 }
7103 /*
7104 * Need to emit an implicit seq point after every non-void call so single stepping through nested calls like
7105 * foo (bar (), baz ())
7106 * works correctly. MS does this also:
7107 * http://stackoverflow.com/questions/6937198/making-your-net-language-step-correctly-in-the-debugger
7108 * The problem with this approach is that the debugger will stop after all calls returning a value,
7109 * even for simple cases, like:
7110 * int i = foo ();
7111 */
7112 /* Special case a few common successor opcodes */
7115 }
7119 /* Don't support calls made using type arguments for now */
7120 /*
7121 if (cfg->gsharedvt) {
7122 if (mini_is_gsharedvt_signature (cfg, fsig))
7123 GSHAREDVT_FAILURE (*ip);
7124 }
7125 */
7130 CHECK_CFG_EXCEPTION;
7131 }
7135 }
7138 UNVERIFIED;
7145 //g_assert (!virtual || fsig->hasthis);
7150 /*
7151 * We have the `constrained.' prefix opcode.
7152 */
7153 if (constrained_call->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
7154 /*
7155 * The type parameter is instantiated as a valuetype,
7156 * but that type doesn't override the method we're
7157 * calling, so we need to box `this'.
7158 */
7161 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
7162 CHECK_CFG_EXCEPTION;
7166 /*
7167 * The type parameter is instantiated as a reference
7168 * type. We have a managed pointer on the stack, so
7169 * we need to dereference it here.
7170 */
7176 /* Own method */
7178 /* Interface method */
7192 /* Enum implements some interfaces, so treat this as the first case */
7195 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
7196 CHECK_CFG_EXCEPTION;
7197 }
7198 }
7200 }
7202 }
7205 UNVERIFIED;
7207 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
7212 sp++;
7213 }
7215 CHECK_CFG_EXCEPTION;
7222 }
7224 /*
7225 * If the callee is a shared method, then its static cctor
7226 * might not get called after the call was patched.
7227 */
7228 if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
7231 }
7245 }
7247 /*
7248 * Pass vtable iff target method might
7249 * be shared, which means that sharing
7250 * is enabled for its class and its
7251 * context is sharable (and it's not a
7252 * generic method).
7253 */
7254 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
7256 }
7273 }
7274 }
7282 /* Generic method interface
7283 calls are resolved via a
7284 helper function and don't
7285 need an imt. */
7288 }
7290 /*
7291 * If a shared method calls another
7292 * shared method then the caller must
7293 * have a generic sharing context
7294 * because the magic trampoline
7295 * requires it. FIXME: We shouldn't
7296 * have to force the vtable/mrgctx
7297 * variable here. Instead there
7298 * should be a flag in the cfg to
7299 * request a generic sharing context.
7300 */
7304 }
7314 }
7315 }
7321 /*
7322 * emit_get_rgctx_method () calls mono_class_vtable () so check
7323 * for type load errors before.
7324 */
7327 }
7331 /* !marshalbyref is needed to properly handle generic methods + remoting */
7338 }
7339 }
7347 }
7352 /* Calling virtual generic methods */
7363 /* Prevent inlining of methods that contain indirect calls */
7369 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
7378 #endif
7379 {
7384 /* FIXME: This should be a managed pointer */
7397 }
7402 CHECK_CFG_EXCEPTION;
7409 }
7411 /*
7412 * Implement a workaround for the inherent races involved in locking:
7413 * Monitor.Enter ()
7414 * try {
7415 * } finally {
7416 * Monitor.Exit ()
7417 * }
7418 * If a thread abort happens between the call to Monitor.Enter () and the start of the
7419 * try block, the Exit () won't be executed, see:
7420 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
7421 * To work around this, we extend such try blocks to include the last x bytes
7422 * of the Monitor.Enter () call.
7423 */
7424 if (cmethod && cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
7428 /*
7429 * Only extend try blocks with a finally, to avoid catching exceptions thrown
7430 * from Monitor.Enter like ArgumentNullException.
7431 */
7433 /* Mark this bblock as needing to be extended */
7435 }
7436 }
7438 /* Conversion to a JIT intrinsic */
7439 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
7444 sp++;
7445 }
7447 CHECK_CFG_EXCEPTION;
7454 }
7456 /* Inlining */
7458 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
7466 /* Prevent inlining of methods that call wrappers */
7470 }
7472 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, always))) {
7478 /* *sp is already set by inline_method */
7479 sp++;
7480 }
7487 }
7488 }
7490 /*
7491 * Making generic calls out of gsharedvt methods.
7492 */
7497 //if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
7498 //GSHAREDVT_FAILURE (*ip);
7499 // disable for possible remoting calls
7500 if (fsig->hasthis && (method->klass->marshalbyref || method->klass == mono_defaults.object_class))
7502 // virtual generic calls were disabled earlier
7503 }
7506 /* test_0_multi_dim_arrays () in gshared.cs */
7512 else
7520 CHECK_CFG_EXCEPTION;
7527 }
7532 // FIXME: How can this happen ?
7534 }
7538 /* Tail recursion elimination */
7539 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
7543 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7546 /* keep it simple */
7550 }
7562 /* skip the CEE_RET, too */
7565 else
7570 }
7571 }
7573 /* Generic sharing */
7574 /* FIXME: only do this for generic methods if
7575 they are not shared! */
7586 /*
7587 * We are compiling a call to a
7588 * generic method from shared code,
7589 * which means that we have to look up
7590 * the method in the rgctx and do an
7591 * indirect call.
7592 */
7593 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
7594 }
7596 /* Indirect calls */
7604 else
7605 /* FIXME: what the hell is this??? */
7609 /* Prevent inlining of methods with indirect calls */
7616 /*
7617 * Instead of emitting an indirect call, emit a direct call
7618 * with the contents of the aotconst as the patch info.
7619 */
7620 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
7622 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
7623 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
7627 }
7628 }
7632 CHECK_CFG_EXCEPTION;
7639 }
7641 /* Array methods */
7655 }
7658 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
7659 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
7677 }
7679 CHECK_CFG_EXCEPTION;
7685 }
7692 CHECK_CFG_EXCEPTION;
7699 }
7701 /* Tail prefix / tail call optimization */
7703 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
7704 /* FIXME: runtime generic context pointer for jumps? */
7705 /* FIXME: handle this for generic sharing eventually */
7709 && !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig);
7714 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7717 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7719 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
7720 /* Handle tail calls similarly to calls */
7721 call = mono_emit_call_args (cfg, mono_method_signature (cmethod), sp, FALSE, FALSE, TRUE, FALSE, FALSE);
7722 #else
7728 /*
7729 * We implement tail calls by storing the actual arguments into the
7730 * argument variables, then emitting a CEE_JMP.
7731 */
7733 /* Prevent argument from being register allocated */
7736 }
7737 #endif
7746 CHECK_CFG_EXCEPTION;
7751 // FIXME: Eliminate unreachable epilogs
7753 /*
7754 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
7755 * only reachable from this call.
7756 */
7761 }
7763 /*
7764 * Synchronized wrappers.
7765 * Its hard to determine where to replace a method with its synchronized
7766 * wrapper without causing an infinite recursion. The current solution is
7767 * to add the synchronized wrapper in the trampolines, and to
7768 * change the called method to a dummy wrapper, and resolve that wrapper
7769 * to the real method in mono_jit_compile_method ().
7770 */
7771 if (cfg->method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED && mono_marshal_method_from_wrapper (cfg->method) == cmethod) {
7773 }
7775 /* Common call */
7783 CHECK_CFG_EXCEPTION;
7790 }
7793 /* return from inlined method */
7794 /*
7795 * If in_count == 0, that means the ret is unreachable due to
7796 * being preceeded by a throw. In that case, inline_method () will
7797 * handle setting the return value
7798 * (test case: test_0_inline_throw ()).
7799 */
7807 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7808 UNVERIFIED;
7810 //g_assert (returnvar != -1);
7813 }
7819 /*
7820 * Place a seq point here too even through the IL stack is not
7821 * empty, so a step over on
7822 * call <FOO>
7823 * ret
7824 * will work correctly.
7825 */
7828 }
7834 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7835 UNVERIFIED;
7849 }
7851 #ifdef MONO_ARCH_SOFT_FLOAT
7861 }
7862 #else
7864 #endif
7865 }
7866 }
7867 }
7869 UNVERIFIED;
7871 ip++;
7880 ip++;
7890 }
7908 ip++;
7910 ip++;
7920 ip++;
7931 }
7950 UNVERIFIED;
7951 ip ++;
7955 sp--;
7965 }
7972 #if SIZEOF_REGISTER == 4
7974 /* Convert it to OP_LCOMPARE */
7982 }
7983 #endif
7999 }
8013 ip++;
8031 gboolean use_op_switch;
8039 UNVERIFIED;
8054 }
8057 /*
8058 * Link the current bb with the targets as well, so handle_stack_args
8059 * will set their in_stack correctly.
8060 */
8068 }
8082 #ifdef TARGET_ARM
8083 /* ARM implements SWITCH statements differently */
8084 /* FIXME: Make it use the generic implementation */
8087 #endif
8104 else
8107 #if SIZEOF_REGISTER == 8
8108 /* The upper word might not be zero, and we add it to a 64 bit address later */
8110 #endif
8120 }
8122 /* FIXME: Use load_memindex */
8126 }
8130 }
8158 }
8167 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
8168 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
8170 }
8189 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
8190 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
8192 }
8196 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)))
8214 /* Use the immediate opcodes if possible */
8223 }
8224 }
8229 ip++;
8254 /* FIXME: Pass opcode to is_inst_imm */
8256 /* Use the immediate opcodes if possible */
8257 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)) {
8264 #if SIZEOF_REGISTER == 8
8266 #else
8269 #endif
8270 }
8271 else
8275 /* Might be followed by an instruction added by ADD_WIDEN_OP */
8278 }
8279 }
8283 ip++;
8300 /* Special case this earlier so we have long constants in the IR */
8305 #if SIZEOF_REGISTER == 8
8308 else
8310 #else
8314 else
8316 #endif
8318 }
8321 }
8322 ip++;
8336 }
8337 ip++;
8349 }
8350 ip++;
8368 CHECK_CFG_EXCEPTION;
8369 ip++;
8379 ip++;
8405 }
8420 /* Optimize the common ldobj+stloc combination */
8435 }
8445 }
8447 /* Optimize the ldobj+stobj combination */
8448 /* The reference case ends up being a load+store anyway */
8449 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
8452 sp --;
8459 }
8468 }
8478 }
8490 }
8501 /*
8502 * Avoid relocations in AOT and save some space by using a
8503 * version of helper_ldstr specialized to mscorlib.
8504 */
8508 /* Avoid creating the string object */
8512 }
8513 }
8514 else
8519 }
8525 OUT_OF_MEMORY_FAILURE;
8529 }
8530 }
8531 }
8533 sp++;
8539 MonoInst this_ins;
8547 LOAD_ERROR;
8550 LOAD_ERROR;
8563 CHECK_CFG_EXCEPTION;
8566 }
8568 if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
8571 }
8576 /*
8577 if (cfg->gsharedvt) {
8578 if (mini_is_gsharedvt_variable_signature (sig))
8579 GSHAREDVT_FAILURE (*ip);
8580 }
8581 */
8600 }
8601 }
8602 }
8607 /*
8608 * Generate smaller code for the common newobj <exception> instruction in
8609 * argument checking code.
8610 */
8637 }
8642 }
8644 /* move the args to allow room for 'this' in the first position */
8648 }
8650 /* check_call_signature () requires sp[0] to be set */
8654 UNVERIFIED;
8664 /* Avoid varargs in the common case */
8671 else
8676 /* we simply pass a null pointer */
8678 /* now call the string ctor */
8690 /*
8691 * The code generated by mini_emit_virtual_call () expects
8692 * iargs [0] to be a boxed instance, but luckily the vcall
8693 * will be transformed into a normal call there.
8694 */
8703 /*
8704 * TypeInitializationExceptions thrown from the mono_runtime_class_init
8705 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
8706 * As a workaround, we call class cctors before allocating objects.
8707 */
8708 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8709 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8711 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
8713 }
8717 }
8723 /* Now call the actual ctor */
8724 /* Avoid virtual calls to ctors if possible */
8729 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8733 sp++;
8734 }
8736 CHECK_CFG_EXCEPTION;
8743 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
8750 // FIXME-VT: Clean this up
8754 }
8774 }
8775 }
8778 /* Valuetype */
8782 }
8783 else
8789 }
8798 UNVERIFIED;
8803 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8807 /* obj */
8810 /* klass */
8813 /* inline cache*/
8816 else
8819 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8823 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8833 CHECK_CFG_EXCEPTION;
8843 }
8846 CHECK_CFG_EXCEPTION;
8850 }
8860 UNVERIFIED;
8865 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8869 /* obj */
8872 /* klass */
8875 /* inline cache*/
8878 else
8884 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8894 CHECK_CFG_EXCEPTION;
8904 }
8907 CHECK_CFG_EXCEPTION;
8911 }
8913 }
8928 /* Need to check for nullable types at runtime */
8932 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
8933 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8937 /* obj */
8940 /* klass */
8943 /* inline cache*/
8944 /*FIXME AOT support*/
8947 else
8950 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8954 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8964 CHECK_CFG_EXCEPTION;
8975 CHECK_CFG_EXCEPTION;
8979 }
8981 }
8988 }
8990 /* UNBOX */
8996 /* LDOBJ */
9002 }
9023 }
9026 UNVERIFIED;
9028 UNVERIFIED;
9029 /* frequent check in generic code: box (struct), brtrue */
9031 // FIXME: LLVM can't handle the inconsistent bb linking
9045 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9047 }
9053 ip++;
9055 ip++;
9060 ip++;
9066 }
9068 /*
9069 * We need to link both bblocks, since it is needed for handling stack
9070 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
9071 * Branching to only one of them would lead to inconsistencies, so
9072 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
9073 */
9084 }
9093 /* The JIT can't eliminate the iconst+compare */
9097 }
9101 }
9105 CHECK_CFG_EXCEPTION;
9109 }
9133 }
9137 }
9146 guint foffset;
9147 gboolean is_instance;
9150 gboolean is_special_static;
9164 }
9166 UNVERIFIED;
9168 UNVERIFIED;
9172 sp--;
9174 }
9175 }
9182 }
9185 }
9187 LOAD_ERROR;
9189 FIELD_ACCESS_FAILURE;
9193 UNVERIFIED;
9195 /* if the class is Critical then transparent code cannot access it's fields */
9199 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
9200 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
9201 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
9202 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
9203 */
9205 /*
9206 * LDFLD etc. is usable on static fields as well, so convert those cases to
9207 * the static case.
9208 */
9222 }
9224 }
9229 /* INSTANCE CASE */
9234 UNVERIFIED;
9235 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
9251 CHECK_CFG_EXCEPTION;
9260 }
9276 // FIXME-VT: wbarriers ?
9279 }
9283 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)) {
9284 /* insert call to write barrier */
9291 }
9294 }
9298 }
9300 if (is_instance && ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class)) {
9301 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
9309 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
9313 CHECK_CFG_EXCEPTION;
9325 }
9330 /* Have to compute the address of the variable */
9335 else
9340 }
9351 }
9362 }
9366 }
9381 }
9386 }
9387 }
9393 }
9395 /* STATIC CASE */
9397 /*
9398 * We can only support shared generic static
9399 * field access on architectures where the
9400 * trampoline code has been extended to handle
9401 * the generic class init.
9402 */
9403 #ifndef MONO_ARCH_VTABLE_REG
9405 #endif
9413 UNVERIFIED;
9415 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
9416 * to be called here.
9417 */
9421 }
9429 /* Generate IR to compute the field address */
9430 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
9431 /*
9432 * Fast access to TLS data
9433 * Inline version of get_thread_static_data () in
9434 * threads.c.
9435 */
9436 guint32 offset;
9442 // offset &= 0x7fffffff;
9443 // idx = (offset >> 24) - 1;
9444 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
9449 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
9454 /* For TLS variables, this will return the TLS offset */
9477 }
9490 }
9495 /*
9496 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
9497 method->klass->name_space, method->klass->name, method->name,
9498 depth, field->offset);
9499 */
9504 /*
9505 * The pointer we're computing here is
9506 *
9507 * super_info.static_data + field->offset
9508 */
9523 }
9538 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
9540 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
9542 }
9546 /* This makes so that inline cannot trigger */
9547 /* .cctors: too many apps depend on them */
9548 /* running with a specific order... */
9555 }
9556 }
9557 }
9562 else
9568 }
9569 }
9571 /* Generate IR to do the actual load/store operation */
9590 }
9591 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
9592 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
9598 }
9602 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
9608 sp++;
9612 sp++;
9617 sp++;
9621 sp++;
9626 sp++;
9630 sp++;
9638 sp++;
9648 sp++;
9651 }
9656 sp++;
9664 }
9665 }
9676 }
9677 }
9681 }
9689 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
9693 /* insert call to write barrier */
9695 }
9701 /*
9702 * Array opcodes
9703 */
9708 guint32 field_token;
9729 }
9734 /* FIXME: we cannot get a managed
9735 allocator because we can't get the
9736 open generic class's vtable. We
9737 have the same problem in
9738 handle_alloc(). This
9739 needs to be solved so that we can
9740 have managed allocs of shared
9741 generic classes. */
9742 /*
9743 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
9744 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
9745 */
9748 /* FIXME: Decompose later to help abcrem */
9750 /* vtable */
9753 /* array len */
9758 else
9762 /* Decompose now to avoid problems with references to the domainvar */
9771 /* Decompose later since it is needed by abcrem */
9786 /* Needed so mono_emit_load_get_addr () gets called */
9788 }
9789 }
9796 /*
9797 * we inline/optimize the initialization sequence if possible.
9798 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
9799 * for small sizes open code the memcpy
9800 * ensure the rva field is big enough
9801 */
9802 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))) {
9807 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
9809 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
9812 }
9816 }
9819 }
9824 UNVERIFIED;
9830 /* This flag will be inherited by the decomposition */
9835 ip ++;
9843 UNVERIFIED;
9849 /* we need to make sure that this array is exactly the type it needs
9850 * to be for correctness. the wrappers are lax with their usage
9851 * so we need to ignore them here
9852 */
9857 }
9887 }
9888 else
9892 UNVERIFIED;
9897 // FIXME-VT: OP_ICONST optimization
9904 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
9911 }
9915 else
9918 }
9939 }
9940 else
9944 UNVERIFIED;
9950 else
9954 }
9969 }
9989 // FIXME:
9992 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
10002 // FIXME:
10007 }
10008 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
10013 }
10030 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
10038 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
10039 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
10040 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10046 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
10047 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
10048 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
10050 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
10051 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
10052 }
10053 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
10061 }
10063 gpointer handle;
10077 }
10080 }
10082 LOAD_ERROR;
10087 /* This case handles ldtoken
10088 of an open type, like for
10089 typeof(Gen<>). */
10092 /* If we get a MONO_TYPE_CLASS
10093 then we need to provide the
10094 open type, not an
10095 instantiation of it. */
10098 else
10104 else
10106 }
10116 else
10130 }
10151 /* Special case for static synchronized wrappers */
10152 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
10154 /* FIXME: n is not a normal token */
10157 }
10160 }
10163 }
10176 MONO_RGCTX_INFO_TYPE);
10185 }
10190 }
10194 }
10195 }
10200 }
10206 ip++;
10217 /* mono_save_seq_point_info () depends on this */
10222 ip++;
10225 /*
10226 * Control will leave the method so empty the stack, otherwise
10227 * the next basic block will start with a nonempty stack.
10228 */
10230 sp--;
10231 }
10243 }
10245 /* empty the stack */
10247 sp--;
10248 }
10250 /*
10251 * If this leave statement is in a catch block, check for a
10252 * pending exception, and rethrow it if necessary.
10253 * We avoid doing this in runtime invoke wrappers, since those are called
10254 * by native code which excepts the wrapper to catch all exceptions.
10255 */
10259 /*
10260 * Use <= in the final comparison to handle clauses with multiple
10261 * leave statements, like in bug #78024.
10262 * The ordering of the exception clauses guarantees that we find the
10263 * innermost clause.
10264 */
10265 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) {
10269 /*
10270 MonoInst *load;
10272 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
10273 */
10279 /*
10280 * Currently, we always rethrow the abort exception, despite the
10281 * fact that this is not correct. See thread6.cs for an example.
10282 * But propagating the abort exception is more important than
10283 * getting the sematics right.
10284 */
10291 }
10292 }
10311 /*
10312 * Link the finally bblock with the target, since it will
10313 * conceptually branch there.
10314 * FIXME: Have to link the bblock containing the endfinally.
10315 */
10318 }
10319 }
10321 }
10332 else
10336 }
10338 /*
10339 * Mono specific opcodes
10340 */
10348 gpointer func;
10369 }
10371 gpointer ptr;
10378 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
10388 /* Will be transformed into an AOTCONST later */
10393 }
10394 }
10395 /* FIXME: Generalize this */
10401 }
10406 /* Can't embed random pointers into AOT code */
10409 }
10412 gpointer ptr;
10426 }
10430 }
10437 // FIXME:
10443 }
10460 }
10473 /*
10474 * Similar to LDOBJ, but instead load the unmanaged
10475 * representation of the vtype to the stack.
10476 */
10485 {
10500 }
10503 /*
10504 * Same as RET, but return the native representation of a vtype
10505 * to the caller.
10506 */
10522 }
10526 UNVERIFIED;
10535 }
10546 else
10552 }
10555 #ifdef MONO_ARCH_HAVE_LMF_OPS
10559 #endif
10589 /* It would be easier to call a trampoline, but that would put an
10590 * extra frame on the stack, confusing exception handling. So
10591 * implement it inline using an opcode for now.
10592 */
10595 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
10596 /* prevent it from being register allocated */
10598 }
10600 /* Has to use a call inst since it local regalloc expects it */
10608 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
10610 #endif
10616 }
10622 }
10628 cfg->orig_domain_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
10633 #if TARGET_WIN32
10636 #else
10639 #endif
10641 #ifdef MONO_ARCH_HAVE_TLS_GET
10652 }
10653 #endif
10656 /* AOT code is only used in the root domain */
10660 }
10667 }
10670 }
10674 /* Restore the original domain */
10680 }
10684 }
10686 }
10692 /* somewhat similar to LDTOKEN */
10695 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
10706 }
10714 /*
10715 * The following transforms:
10716 * CEE_CEQ into OP_CEQ
10717 * CEE_CGT into OP_CGT
10718 * CEE_CGT_UN into OP_CGT_UN
10719 * CEE_CLT into OP_CLT
10720 * CEE_CLT_UN into OP_CLT_UN
10721 */
10730 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))))
10734 else
10742 /*
10743 * The backends expect the fceq opcodes to do the
10744 * comparison too.
10745 */
10749 }
10754 }
10766 LOAD_ERROR;
10775 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
10776 METHOD_ACCESS_FAILURE;
10781 CHECK_CFG_EXCEPTION;
10784 }
10786 /*
10787 * Optimize the common case of ldftn+delegate creation
10788 */
10789 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
10790 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
10798 LOAD_ERROR;
10809 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
10810 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
10813 }
10814 }
10816 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
10817 /* FIXME: SGEN support */
10821 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
10822 sp --;
10824 CHECK_CFG_EXCEPTION;
10826 sp ++;
10828 }
10829 #endif
10830 }
10831 }
10840 }
10851 LOAD_ERROR;
10860 CHECK_CFG_EXCEPTION;
10863 }
10873 else
10879 }
10906 UNVERIFIED;
10930 }
10936 }
10944 UNVERIFIED;
10953 UNVERIFIED;
10955 /*
10956 * Inlining this into a loop in a parent could lead to
10957 * stack overflows which is different behavior than the
10958 * non-inlined case, thus disable inlining in this case.
10959 */
10982 UNVERIFIED;
10994 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
10998 }
10999 }
11002 UNVERIFIED;
11005 }
11008 /* FIXME: record alignment? we can assume 1 for now */
11019 /* Can't inline tail calls at this time */
11032 else
11042 else
11053 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
11055 } else if ((ip [1] == CEE_INITBLK) && (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)) {
11056 /* emit_memset only works when val == 0 */
11068 }
11069 }
11073 }
11080 /* we ignore the no-nullcheck for now since we
11081 * really do it explicitly only when doing callvirt->call
11082 */
11091 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
11094 }
11095 }
11114 }
11116 guint32 val;
11124 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic && !generic_context) {
11132 }
11137 }
11146 // FIXME:
11149 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
11151 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
11155 }
11166 UNVERIFIED;
11170 UNVERIFIED;
11171 }
11173 }
11176 UNVERIFIED;
11180 UNVERIFIED;
11181 }
11182 }
11184 UNVERIFIED;
11188 /* This could already be set because of inlining, #693905 */
11196 }
11206 }
11210 }
11213 }
11215 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
11217 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
11219 #endif
11252 } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (cfg, ptype)) {
11256 }
11257 }
11258 }
11261 /* Emit initialization for ref vars */
11262 // FIXME: Avoid duplication initialization for IL locals.
11268 }
11269 }
11274 /*
11275 * Make seq points at backward branch targets interruptable.
11276 */
11280 }
11282 /* Add a sequence point for method entry/exit events */
11288 }
11300 }
11301 }
11309 /* Method is too large */
11317 }
11326 exception_exit:
11330 inline_failure:
11333 load_error:
11337 unverified:
11341 cleanup:
11347 }
11349 static int
11351 {
11365 }
11368 }
11372 int
11374 {
11436 #if defined(TARGET_X86) || defined (TARGET_AMD64)
11441 #endif
11442 #if defined(TARGET_AMD64)
11445 #endif
11456 }
11459 }
11461 static int
11463 {
11489 }
11492 }
11494 static int
11496 {
11515 }
11518 }
11520 int
11522 {
11523 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
11524 #if defined(TARGET_X86) || defined(TARGET_AMD64)
11536 #if SIZEOF_REGISTER == 8
11539 #endif
11540 }
11541 #endif
11544 }
11548 {
11549 #if defined(TARGET_X86)
11581 }
11582 #endif
11584 #if defined(TARGET_AMD64)
11585 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
11636 }
11637 #endif
11640 }
11644 {
11645 #if defined(TARGET_X86) || defined(TARGET_AMD64)
11653 }
11654 #endif
11657 }
11661 {
11662 #ifdef TARGET_X86
11663 /* FIXME: This has sign extension issues */
11664 /*
11665 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
11666 return OP_X86_COMPARE_MEMBASE8_IMM;
11667 */
11669 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11681 }
11682 #endif
11684 #ifdef TARGET_AMD64
11685 /* FIXME: This has sign extension issues */
11686 /*
11687 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
11688 return OP_X86_COMPARE_MEMBASE8_IMM;
11689 */
11693 #ifdef __mono_ilp32__
11695 #else
11697 #endif
11700 /* FIXME: This only works for 32 bit immediates
11701 case OP_COMPARE_IMM:
11702 case OP_LCOMPARE_IMM:
11703 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
11704 return OP_AMD64_COMPARE_MEMBASE_IMM;
11705 */
11712 #ifdef __mono_ilp32__
11716 #else
11718 #endif
11725 }
11726 #endif
11729 }
11733 {
11734 #ifdef TARGET_X86
11735 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11752 }
11753 #endif
11755 #ifdef TARGET_AMD64
11756 #ifdef __mono_ilp32__
11757 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE) ) {
11758 #else
11760 #endif
11774 }
11775 #ifdef __mono_ilp32__
11777 #else
11779 #endif
11794 }
11795 }
11796 #endif
11799 }
11801 int
11803 {
11805 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
11810 #endif
11811 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
11817 #endif
11818 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
11821 #endif
11824 }
11825 }
11827 #ifndef DISABLE_JIT
11829 /**
11830 * mono_handle_global_vregs:
11831 *
11832 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
11833 * for them.
11834 */
11835 void
11837 {
11844 #ifdef MONO_ARCH_SIMD_INTRINSICS
11847 #endif
11849 /* Find local vregs used in more than one bb */
11861 gint32 prev_bb;
11891 }
11893 #if SIZEOF_REGISTER == 4
11894 /* In the LLVM case, the long opcodes are not decomposed */
11896 /*
11897 * Since some instructions reference the original long vreg,
11898 * and some reference the two component vregs, it is quite hard
11899 * to determine when it needs to be global. So be conservative.
11900 */
11902 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11906 }
11908 /*
11909 * Make the component vregs volatile since the optimizations can
11910 * get confused otherwise.
11911 */
11914 }
11915 #endif
11921 /* 0 is a valid block num */
11924 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
11934 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
11935 else
11939 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11942 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
11949 }
11950 }
11952 /* Flag as having been used in more than one bb */
11954 }
11955 }
11956 }
11957 }
11959 /* If a variable is used in only one bblock, convert it into a local vreg */
11970 #if SIZEOF_REGISTER == 8
11972 #endif
11973 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
11974 /* Enabling this screws up the fp stack on x86 */
11976 #endif
11977 /* Arguments are implicitly global */
11978 /* Putting R4 vars into registers doesn't work currently */
11979 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) {
11980 /*
11981 * Make that the variable's liveness interval doesn't contain a call, since
11982 * that would cause the lvreg to be spilled, making the whole optimization
11983 * useless.
11984 */
11985 /* This is too slow for JIT compilation */
11986 #if 0
12006 }
12007 }
12012 ins_index ++;
12013 }
12017 }
12018 #endif
12024 }
12026 }
12027 }
12029 /*
12030 * Compress the varinfo and vars tables so the liveness computation is faster and
12031 * takes up less space.
12032 */
12044 #if SIZEOF_REGISTER == 4
12046 /* Modify the two component vars too */
12053 }
12054 #endif
12055 }
12056 pos ++;
12057 }
12058 }
12062 }
12064 /**
12065 * mono_spill_global_vars:
12066 *
12067 * Generate spill code for variables which are not allocated to registers,
12068 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
12069 * code is generated which could be optimized by the local optimization passes.
12070 */
12071 void
12073 {
12089 /* FIXME: Move this function to mini.c */
12093 #ifdef MONO_ARCH_SIMD_INTRINSICS
12095 #endif
12097 #if SIZEOF_REGISTER == 4
12098 /* Create MonoInsts for longs */
12125 }
12128 }
12129 }
12130 }
12131 #endif
12134 /* registers need liveness info even for !non refs */
12140 }
12141 }
12143 /* FIXME: widening and truncation */
12145 /*
12146 * As an optimization, when a variable allocated to the stack is first loaded into
12147 * an lvreg, we will remember the lvreg and use it the next time instead of loading
12148 * the variable again.
12149 */
12155 /*
12156 * These arrays contain the first and last instructions accessing a given
12157 * variable.
12158 * Since we emit bblocks in the same order we process them here, and we
12159 * don't split live ranges, these will precisely describe the live range of
12160 * the variable, i.e. the instruction range where a valid value can be found
12161 * in the variables location.
12162 * The live range is computed using the liveness info computed by the liveness pass.
12163 * We can't use vmv->range, since that is an abstract live range, and we need
12164 * one which is instruction precise.
12165 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
12166 */
12167 /* FIXME: Only do this if debugging info is requested */
12173 /* Add spill loads/stores */
12180 /* Clear vreg_to_lvreg array */
12198 /*
12199 * We handle LDADDR here as well, since it can only be decomposed
12200 * when variable addresses are known.
12201 */
12206 /* Happens on SPARC/S390 where vtypes are passed by reference */
12211 }
12217 NOT_IMPLEMENTED;
12224 }
12228 }
12233 }
12235 /*
12236 * Store opcodes have destbasereg in the dreg, but in reality, it is an
12237 * src register.
12238 * FIXME:
12239 */
12253 else
12263 }
12265 /***************/
12266 /* DREG */
12267 /***************/
12269 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
12283 } 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)) {
12284 /*
12285 * Instead of emitting a load+store, use a _membase opcode.
12286 */
12296 }
12299 guint32 lvreg;
12305 /* Invalidate any previous lvreg for this vreg */
12313 }
12318 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
12320 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
12323 }
12327 /* Try to fuse the store into the instruction itself */
12328 /* FIXME: Add more instructions */
12329 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
12335 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
12353 // FIXME: The backends expect the base reg to be in inst_basereg
12360 /* printf ("INS: "); mono_print_ins (ins); */
12361 /* Create a store instruction */
12362 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
12364 /* Insert it after the instruction */
12369 /*
12370 * We can't assign ins->dreg to var->dreg here, since the
12371 * sregs could use it. So set a flag, and do it after
12372 * the sregs.
12373 */
12374 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)))
12376 }
12377 }
12378 }
12383 }
12391 }
12392 }
12394 /************/
12395 /* SREGS */
12396 /************/
12407 guint32 load_opcode;
12411 //mono_inst_set_src_registers (ins, sregs);
12415 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
12419 /* var->dreg is a hreg */
12422 }
12425 }
12436 /* The variable is already loaded to an lvreg */
12440 //mono_inst_set_src_registers (ins, sregs);
12442 }
12444 /* Try to fuse the load into the instruction */
12448 //mono_inst_set_src_registers (ins, sregs);
12453 //mono_inst_set_src_registers (ins, sregs);
12460 //printf ("%d ", srcindex); mono_print_ins (ins);
12464 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) {
12466 /*
12467 * sreg refers to the value loaded by the load
12468 * emitted below, but we need to use ins->dreg
12469 * since it refers to the store emitted earlier.
12470 */
12472 }
12477 }
12478 }
12481 //mono_inst_set_src_registers (ins, sregs);
12484 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
12486 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
12489 }
12491 #if SIZEOF_REGISTER == 4
12493 #endif
12497 }
12498 }
12503 }
12505 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
12511 }
12512 }
12513 }
12522 }
12528 }
12531 /* Clear vreg_to_lvreg array */
12538 }
12542 }
12544 /* Extend the live range based on the liveness info */
12550 /* The liveness info is incomplete */
12554 /* Live from at least the first ins of this bb */
12557 }
12560 /* Live at least until the last ins of this bb */
12563 }
12564 }
12565 }
12566 }
12568 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
12569 /*
12570 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
12571 * by storing the current native offset into MonoMethodVar->live_range_start/end.
12572 */
12583 }
12590 else
12592 }
12593 }
12594 }
12595 #endif
12601 }
12603 /**
12604 * FIXME:
12605 * - use 'iadd' instead of 'int_add'
12606 * - handling ovf opcodes: decompose in method_to_ir.
12607 * - unify iregs/fregs
12608 * -> partly done, the missing parts are:
12609 * - a more complete unification would involve unifying the hregs as well, so
12610 * code wouldn't need if (fp) all over the place. but that would mean the hregs
12611 * would no longer map to the machine hregs, so the code generators would need to
12612 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
12613 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
12614 * fp/non-fp branches speeds it up by about 15%.
12615 * - use sext/zext opcodes instead of shifts
12616 * - add OP_ICALL
12617 * - get rid of TEMPLOADs if possible and use vregs instead
12618 * - clean up usage of OP_P/OP_ opcodes
12619 * - cleanup usage of DUMMY_USE
12620 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
12621 * stack
12622 * - set the stack type and allocate a dreg in the EMIT_NEW macros
12623 * - get rid of all the <foo>2 stuff when the new JIT is ready.
12624 * - make sure handle_stack_args () is called before the branch is emitted
12625 * - when the new IR is done, get rid of all unused stuff
12626 * - COMPARE/BEQ as separate instructions or unify them ?
12627 * - keeping them separate allows specialized compare instructions like
12628 * compare_imm, compare_membase
12629 * - most back ends unify fp compare+branch, fp compare+ceq
12630 * - integrate mono_save_args into inline_method
12631 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
12632 * - handle long shift opts on 32 bit platforms somehow: they require
12633 * 3 sregs (2 for arg1 and 1 for arg2)
12634 * - make byref a 'normal' type.
12635 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
12636 * variable if needed.
12637 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
12638 * like inline_method.
12639 * - remove inlining restrictions
12640 * - fix LNEG and enable cfold of INEG
12641 * - generalize x86 optimizations like ldelema as a peephole optimization
12642 * - add store_mem_imm for amd64
12643 * - optimize the loading of the interruption flag in the managed->native wrappers
12644 * - avoid special handling of OP_NOP in passes
12645 * - move code inserting instructions into one function/macro.
12646 * - try a coalescing phase after liveness analysis
12647 * - add float -> vreg conversion + local optimizations on !x86
12648 * - figure out how to handle decomposed branches during optimizations, ie.
12649 * compare+branch, op_jump_table+op_br etc.
12650 * - promote RuntimeXHandles to vregs
12651 * - vtype cleanups:
12652 * - add a NEW_VARLOADA_VREG macro
12653 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
12654 * accessing vtype fields.
12655 * - get rid of I8CONST on 64 bit platforms
12656 * - dealing with the increase in code size due to branches created during opcode
12657 * decomposition:
12658 * - use extended basic blocks
12659 * - all parts of the JIT
12660 * - handle_global_vregs () && local regalloc
12661 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
12662 * - sources of increase in code size:
12663 * - vtypes
12664 * - long compares
12665 * - isinst and castclass
12666 * - lvregs not allocated to global registers even if used multiple times
12667 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
12668 * meaningful.
12669 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
12670 * - add all micro optimizations from the old JIT
12671 * - put tree optimizations into the deadce pass
12672 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
12673 * specific function.
12674 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
12675 * fcompare + branchCC.
12676 * - create a helper function for allocating a stack slot, taking into account
12677 * MONO_CFG_HAS_SPILLUP.
12678 * - merge r68207.
12679 * - merge the ia64 switch changes.
12680 * - optimize mono_regstate2_alloc_int/float.
12681 * - fix the pessimistic handling of variables accessed in exception handler blocks.
12682 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
12683 * parts of the tree could be separated by other instructions, killing the tree
12684 * arguments, or stores killing loads etc. Also, should we fold loads into other
12685 * instructions if the result of the load is used multiple times ?
12686 * - make the REM_IMM optimization in mini-x86.c arch-independent.
12687 * - LAST MERGE: 108395.
12688 * - when returning vtypes in registers, generate IR and append it to the end of the
12689 * last bb instead of doing it in the epilog.
12690 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
12691 */
12693 /*
12695 NOTES
12696 -----
12698 - When to decompose opcodes:
12699 - earlier: this makes some optimizations hard to implement, since the low level IR
12700 no longer contains the neccessary information. But it is easier to do.
12701 - later: harder to implement, enables more optimizations.
12702 - Branches inside bblocks:
12703 - created when decomposing complex opcodes.
12704 - branches to another bblock: harmless, but not tracked by the branch
12705 optimizations, so need to branch to a label at the start of the bblock.
12706 - branches to inside the same bblock: very problematic, trips up the local
12707 reg allocator. Can be fixed by spitting the current bblock, but that is a
12708 complex operation, since some local vregs can become global vregs etc.
12709 - Local/global vregs:
12710 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
12711 local register allocator.
12712 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
12713 structure, created by mono_create_var (). Assigned to hregs or the stack by
12714 the global register allocator.
12715 - When to do optimizations like alu->alu_imm:
12716 - earlier -> saves work later on since the IR will be smaller/simpler
12717 - later -> can work on more instructions
12718 - Handling of valuetypes:
12719 - When a vtype is pushed on the stack, a new temporary is created, an
12720 instruction computing its address (LDADDR) is emitted and pushed on
12721 the stack. Need to optimize cases when the vtype is used immediately as in
12722 argument passing, stloc etc.
12723 - Instead of the to_end stuff in the old JIT, simply call the function handling
12724 the values on the stack before emitting the last instruction of the bb.
12725 */