| blob | b11a4cc4a305c3f455f0537aa4247463796181f3 |
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 */
11 #include <config.h>
12 #include <signal.h>
14 #ifdef HAVE_UNISTD_H
15 #include <unistd.h>
16 #endif
18 #include <math.h>
19 #include <string.h>
20 #include <ctype.h>
22 #ifdef HAVE_SYS_TIME_H
23 #include <sys/time.h>
24 #endif
26 #ifdef HAVE_ALLOCA_H
27 #include <alloca.h>
28 #endif
30 #include <mono/utils/memcheck.h>
32 #include <mono/metadata/assembly.h>
33 #include <mono/metadata/attrdefs.h>
34 #include <mono/metadata/loader.h>
35 #include <mono/metadata/tabledefs.h>
36 #include <mono/metadata/class.h>
37 #include <mono/metadata/object.h>
38 #include <mono/metadata/exception.h>
39 #include <mono/metadata/opcodes.h>
40 #include <mono/metadata/mono-endian.h>
41 #include <mono/metadata/tokentype.h>
42 #include <mono/metadata/tabledefs.h>
43 #include <mono/metadata/marshal.h>
44 #include <mono/metadata/debug-helpers.h>
45 #include <mono/metadata/mono-debug.h>
46 #include <mono/metadata/gc-internal.h>
47 #include <mono/metadata/security-manager.h>
48 #include <mono/metadata/threads-types.h>
49 #include <mono/metadata/security-core-clr.h>
50 #include <mono/metadata/monitor.h>
51 #include <mono/metadata/profiler-private.h>
52 #include <mono/metadata/profiler.h>
53 #include <mono/utils/mono-compiler.h>
54 #include <mono/utils/mono-memory-model.h>
55 #include <mono/metadata/mono-basic-block.h>
66 #define BRANCH_COST 10
67 #define INLINE_LENGTH_LIMIT 20
68 #define INLINE_FAILURE do {\
69 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
70 goto inline_failure;\
71 } while (0)
72 #define CHECK_CFG_EXCEPTION do {\
73 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
74 goto exception_exit;\
75 } while (0)
76 #define METHOD_ACCESS_FAILURE do { \
77 char *method_fname = mono_method_full_name (method, TRUE); \
78 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
79 mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); \
80 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
81 g_free (method_fname); \
82 g_free (cil_method_fname); \
83 goto exception_exit; \
84 } while (0)
85 #define FIELD_ACCESS_FAILURE do { \
86 char *method_fname = mono_method_full_name (method, TRUE); \
87 char *field_fname = mono_field_full_name (field); \
88 mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); \
89 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
90 g_free (method_fname); \
91 g_free (field_fname); \
92 goto exception_exit; \
93 } while (0)
94 #define GENERIC_SHARING_FAILURE(opcode) do { \
95 if (cfg->generic_sharing_context) { \
96 if (cfg->verbose_level > 2) \
97 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__); \
98 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
99 goto exception_exit; \
100 } \
101 } while (0)
102 #define OUT_OF_MEMORY_FAILURE do { \
103 mono_cfg_set_exception (cfg, MONO_EXCEPTION_OUT_OF_MEMORY); \
104 goto exception_exit; \
105 } while (0)
106 /* Determine whenever 'ins' represents a load of the 'this' argument */
107 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
115 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
116 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
119 /* helper methods signatures */
128 /*
129 * Instruction metadata
130 */
131 #ifdef MINI_OP
132 #undef MINI_OP
133 #endif
134 #ifdef MINI_OP3
135 #undef MINI_OP3
136 #endif
138 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
144 #if SIZEOF_REGISTER == 8
145 #define LREG IREG
146 #else
148 #endif
149 /* keep in sync with the enum in mini.h */
150 const char
151 ins_info[] = {
153 };
154 #undef MINI_OP
155 #undef MINI_OP3
157 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
158 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
159 /*
160 * This should contain the index of the last sreg + 1. This is not the same
161 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
162 */
165 };
166 #undef MINI_OP
167 #undef MINI_OP3
169 #define MONO_INIT_VARINFO(vi,id) do { \
170 (vi)->range.first_use.pos.bid = 0xffff; \
171 (vi)->reg = -1; \
172 (vi)->idx = (id); \
173 } while (0)
175 void
177 {
181 }
183 guint32
185 {
187 }
189 guint32
191 {
193 }
195 guint32
197 {
199 }
201 guint32
203 {
205 }
207 /*
208 * mono_alloc_ireg_ref:
209 *
210 * Allocate an IREG, and mark it as holding a GC ref.
211 */
212 guint32
214 {
216 }
218 /*
219 * mono_alloc_ireg_mp:
220 *
221 * Allocate an IREG, and mark it as holding a managed pointer.
222 */
223 guint32
225 {
227 }
229 /*
230 * mono_alloc_ireg_copy:
231 *
232 * Allocate an IREG with the same GC type as VREG.
233 */
234 guint32
236 {
241 else
243 }
245 guint
247 {
251 handle_enum:
277 #if SIZEOF_REGISTER == 8
279 #else
281 #endif
290 }
305 }
307 }
309 void
311 {
324 }
326 void
328 {
336 }
338 /*
339 * Can't put this at the beginning, since other files reference stuff from this
340 * file.
341 */
342 #ifndef DISABLE_JIT
344 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
346 #define LOAD_ERROR do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto load_error; } while (0)
348 #define GET_BBLOCK(cfg,tblock,ip) do { \
349 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
350 if (!(tblock)) { \
351 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
352 NEW_BBLOCK (cfg, (tblock)); \
353 (tblock)->cil_code = (ip); \
354 ADD_BBLOCK (cfg, (tblock)); \
355 } \
356 } while (0)
358 #if defined(TARGET_X86) || defined(TARGET_AMD64)
359 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
360 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
361 (dest)->dreg = alloc_ireg_mp ((cfg)); \
362 (dest)->sreg1 = (sr1); \
363 (dest)->sreg2 = (sr2); \
364 (dest)->inst_imm = (imm); \
365 (dest)->backend.shift_amount = (shift); \
366 MONO_ADD_INS ((cfg)->cbb, (dest)); \
367 } while (0)
368 #endif
370 #if SIZEOF_REGISTER == 8
371 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
373 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
374 MonoInst *widen; \
375 int dr = alloc_preg (cfg); \
376 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
377 (ins)->sreg2 = widen->dreg; \
378 } \
379 } while (0)
380 #else
381 #define ADD_WIDEN_OP(ins, arg1, arg2)
382 #endif
384 #define ADD_BINOP(op) do { \
385 MONO_INST_NEW (cfg, ins, (op)); \
386 sp -= 2; \
387 ins->sreg1 = sp [0]->dreg; \
388 ins->sreg2 = sp [1]->dreg; \
389 type_from_op (ins, sp [0], sp [1]); \
390 CHECK_TYPE (ins); \
392 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
393 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
394 MONO_ADD_INS ((cfg)->cbb, (ins)); \
395 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
396 } while (0)
398 #define ADD_UNOP(op) do { \
399 MONO_INST_NEW (cfg, ins, (op)); \
400 sp--; \
401 ins->sreg1 = sp [0]->dreg; \
402 type_from_op (ins, sp [0], NULL); \
403 CHECK_TYPE (ins); \
404 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
405 MONO_ADD_INS ((cfg)->cbb, (ins)); \
406 *sp++ = mono_decompose_opcode (cfg, ins); \
407 } while (0)
409 #define ADD_BINCOND(next_block) do { \
410 MonoInst *cmp; \
411 sp -= 2; \
412 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
413 cmp->sreg1 = sp [0]->dreg; \
414 cmp->sreg2 = sp [1]->dreg; \
415 type_from_op (cmp, sp [0], sp [1]); \
416 CHECK_TYPE (cmp); \
417 type_from_op (ins, sp [0], sp [1]); \
418 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
419 GET_BBLOCK (cfg, tblock, target); \
420 link_bblock (cfg, bblock, tblock); \
421 ins->inst_true_bb = tblock; \
422 if ((next_block)) { \
423 link_bblock (cfg, bblock, (next_block)); \
424 ins->inst_false_bb = (next_block); \
425 start_new_bblock = 1; \
426 } else { \
427 GET_BBLOCK (cfg, tblock, ip); \
428 link_bblock (cfg, bblock, tblock); \
429 ins->inst_false_bb = tblock; \
430 start_new_bblock = 2; \
431 } \
432 if (sp != stack_start) { \
433 handle_stack_args (cfg, stack_start, sp - stack_start); \
434 CHECK_UNVERIFIABLE (cfg); \
435 } \
436 MONO_ADD_INS (bblock, cmp); \
437 MONO_ADD_INS (bblock, ins); \
438 } while (0)
440 /* *
441 * link_bblock: Links two basic blocks
442 *
443 * links two basic blocks in the control flow graph, the 'from'
444 * argument is the starting block and the 'to' argument is the block
445 * the control flow ends to after 'from'.
446 */
447 static void
449 {
453 #if 0
456 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
457 else
462 else
464 }
465 #endif
472 }
473 }
478 }
482 }
489 }
490 }
495 }
499 }
500 }
502 void
504 {
506 }
508 /**
509 * mono_find_block_region:
510 *
511 * We mark each basic block with a region ID. We use that to avoid BB
512 * optimizations when blocks are in different regions.
513 *
514 * Returns:
515 * A region token that encodes where this region is, and information
516 * about the clause owner for this block.
517 *
518 * The region encodes the try/catch/filter clause that owns this block
519 * as well as the type. -1 is a special value that represents a block
520 * that is in none of try/catch/filter.
521 */
522 static int
524 {
531 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
540 else
542 }
546 }
549 }
553 {
565 }
566 }
568 }
570 static void
572 {
580 /* prevent it from being register allocated */
584 }
586 MonoInst *
588 {
590 }
594 {
602 /* prevent it from being register allocated */
608 }
610 /*
611 * Returns the type used in the eval stack when @type is loaded.
612 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
613 */
614 void
616 {
623 }
625 handle_enum:
669 }
679 /* FIXME: all the arguments must be references for now,
680 * later look inside cfg and see if the arg num is
681 * really a reference
682 */
688 }
689 }
691 /*
692 * The following tables are used to quickly validate the IL code in type_from_op ().
693 */
694 static const char
704 };
706 static const char
707 neg_table [] = {
709 };
711 /* reduce the size of this table */
712 static const char
722 };
724 static const char
726 /* Inv i L p F & O vt */
735 };
737 /* reduce the size of this table */
738 static const char
748 };
750 /*
751 * Tables to map from the non-specific opcode to the matching
752 * type-specific opcode.
753 */
754 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
755 static const guint16
758 };
760 /* handles from CEE_NEG to CEE_CONV_U8 */
761 static const guint16
764 };
766 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
767 static const guint16
769 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
770 };
772 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
773 static const guint16
775 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
776 };
778 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
779 static const guint16
781 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
782 };
784 /* handles from CEE_BEQ to CEE_BLT_UN */
785 static const guint16
787 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
788 };
790 /* handles from CEE_CEQ to CEE_CLT_UN */
791 static const guint16
793 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
794 };
796 /*
797 * Sets ins->type (the type on the eval stack) according to the
798 * type of the opcode and the arguments to it.
799 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
800 *
801 * FIXME: this function sets ins->type unconditionally in some cases, but
802 * it should set it to invalid for some types (a conv.x on an object)
803 */
804 static void
808 /* binops */
814 /* FIXME: check unverifiable args for STACK_MP */
836 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
840 else
845 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
871 /* unops */
879 else
900 }
933 #if SIZEOF_VOID_P == 8
935 #else
937 #endif
945 }
1013 }
1017 }
1019 static const char
1020 ldind_type [] = {
1021 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1022 };
1024 #if 0
1026 static const char
1029 };
1031 static int
1043 }
1044 args++;
1045 }
1066 }
1079 }
1080 /*if (!param_table [args [i].type] [sig->params [i]->type])
1081 return 0;*/
1082 }
1084 }
1085 #endif
1087 /*
1088 * When we need a pointer to the current domain many times in a method, we
1089 * call mono_domain_get() once and we store the result in a local variable.
1090 * This function returns the variable that represents the MonoDomain*.
1091 */
1094 {
1098 }
1100 /*
1101 * The got_var contains the address of the Global Offset Table when AOT
1102 * compiling.
1103 */
1104 MonoInst *
1106 {
1107 #ifdef MONO_ARCH_NEED_GOT_VAR
1112 }
1114 #else
1116 #endif
1117 }
1121 {
1126 /* force the var to be stack allocated */
1128 }
1131 }
1146 }
1148 }
1152 {
1187 else
1192 }
1195 }
1199 {
1233 }
1235 }
1237 /*
1238 * We try to share variables when possible
1239 */
1242 {
1246 /* inlining can result in deeper stacks */
1266 }
1268 }
1270 static void
1272 {
1273 /*
1274 * Don't use this if a generic_context is set, since that means AOT can't
1275 * look up the method using just the image+token.
1276 * table == 0 means this is a reference made from a wrapper.
1277 */
1279 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1283 }
1284 }
1286 /*
1287 * This function is called to handle items that are left on the evaluation stack
1288 * at basic block boundaries. What happens is that we save the values to local variables
1289 * and we reload them later when first entering the target basic block (with the
1290 * handle_loaded_temps () function).
1291 * A single joint point will use the same variables (stored in the array bb->out_stack or
1292 * bb->in_stack, if the basic block is before or after the joint point).
1293 *
1294 * This function needs to be called _before_ emitting the last instruction of
1295 * the bb (i.e. before emitting a branch).
1296 * If the stack merge fails at a join point, cfg->unverifiable is set.
1297 */
1298 static void
1300 {
1305 gboolean found;
1313 //printf ("bblock %d has out:", bb->block_num);
1317 /* exception handlers are linked, but they should not be considered for stack args */
1320 //printf (" %d", outb->block_num);
1325 }
1326 }
1327 //printf ("\n");
1331 /*
1332 * try to reuse temps already allocated for this purpouse, if they occupy the same
1333 * stack slot and if they are of the same type.
1334 * This won't cause conflicts since if 'local' is used to
1335 * store one of the values in the in_stack of a bblock, then
1336 * the same variable will be used for the same outgoing stack
1337 * slot as well.
1338 * This doesn't work when inlining methods, since the bblocks
1339 * in the inlined methods do not inherit their in_stack from
1340 * the bblock they are inlined to. See bug #58863 for an
1341 * example.
1342 */
1345 else
1347 }
1348 }
1349 }
1353 /* exception handlers are linked, but they should not be considered for stack args */
1360 }
1362 }
1365 }
1375 }
1377 /*
1378 * It is possible that the out bblocks already have in_stack assigned, and
1379 * the in_stacks differ. In this case, we will store to all the different
1380 * in_stacks.
1381 */
1386 /* Find a bblock which has a different in_stack */
1390 /* exception handlers are linked, but they should not be considered for stack args */
1392 bindex++;
1394 }
1402 }
1406 }
1407 bindex ++;
1408 }
1409 }
1410 }
1412 /* Emit code which loads interface_offsets [klass->interface_id]
1413 * The array is stored in memory before vtable.
1414 */
1415 static void
1416 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1417 {
1425 }
1427 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1428 }
1429 }
1431 static void
1432 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1433 {
1435 #ifdef COMPRESSED_INTERFACE_BITMAP
1443 else
1447 #else
1462 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1468 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1469 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1470 }
1471 #endif
1472 }
1474 /*
1475 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1476 * stored in "klass_reg" implements the interface "klass".
1477 */
1478 static void
1479 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1480 {
1481 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1482 }
1484 /*
1485 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1486 * stored in "vtable_reg" implements the interface "klass".
1487 */
1488 static void
1489 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1490 {
1491 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1492 }
1494 /*
1495 * Emit code which checks whenever the interface id of @klass is smaller than
1496 * than the value given by max_iid_reg.
1497 */
1498 static void
1501 {
1506 }
1507 else
1511 else
1513 }
1515 /* Same as above, but obtains max_iid from a vtable */
1516 static void
1519 {
1522 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1524 }
1526 /* Same as above, but obtains max_iid from a klass */
1527 static void
1530 {
1533 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1535 }
1537 static void
1538 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1539 {
1545 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1548 }
1549 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1559 }
1561 }
1563 static void
1564 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1565 {
1567 }
1569 static void
1570 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1571 {
1579 else
1581 }
1583 /*
1584 * Variant of the above that takes a register to the class, not the vtable.
1585 */
1586 static void
1587 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1588 {
1596 else
1598 }
1601 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1602 {
1611 }
1613 }
1617 {
1619 }
1622 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1623 {
1630 }
1632 }
1634 static void
1635 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1637 static void
1638 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1639 {
1645 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1648 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1649 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1653 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1656 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1663 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1665 }
1668 /* Check that the object is a vector too */
1673 }
1680 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1683 }
1684 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1687 }
1688 }
1690 static void
1691 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1692 {
1694 }
1696 static void
1698 {
1717 #if SIZEOF_REGISTER == 8
1721 #endif
1722 }
1723 }
1729 else
1733 /* This could be optimized further if neccesary */
1738 }
1740 }
1742 #if !NO_UNALIGNED_ACCESS
1748 }
1753 }
1754 }
1755 #endif
1761 }
1766 }
1771 }
1772 }
1774 void
1775 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1776 {
1782 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1786 /* This could be optimized further if neccesary */
1794 }
1795 }
1797 #if !NO_UNALIGNED_ACCESS
1806 }
1807 }
1808 #endif
1817 }
1825 }
1833 }
1834 }
1836 static int
1837 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1838 {
1842 handle_enum:
1886 }
1888 }
1890 /*
1891 * target_type_is_incompatible:
1892 * @cfg: MonoCompile context
1893 *
1894 * Check that the item @arg on the evaluation stack can be stored
1895 * in the target type (can be a local, or field, etc).
1896 * The cfg arg can be used to check if we need verification or just
1897 * validity checks.
1898 *
1899 * Returns: non-0 value if arg can't be stored on a target.
1900 */
1901 static int
1903 {
1908 /* FIXME: check that the pointed to types match */
1914 }
1932 /* STACK_MP is needed when setting pinned locals */
1939 /*
1940 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
1941 * in native int. (#688008).
1942 */
1953 /* FIXME: check type compatibility */
1990 /* FIXME: check type compatibility */
1992 }
1995 /* FIXME: all the arguments must be references for now,
1996 * later look inside cfg and see if the arg num is
1997 * really a reference
1998 */
2005 }
2007 }
2009 /*
2010 * Prepare arguments for passing to a function call.
2011 * Return a non-zero value if the arguments can't be passed to the given
2012 * signature.
2013 * The type checks are not yet complete and some conversions may need
2014 * casts on 32 or 64 bit architectures.
2015 *
2016 * FIXME: implement this using target_type_is_incompatible ()
2017 */
2018 static int
2020 {
2027 args++;
2028 }
2034 }
2037 handle_enum:
2057 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2082 }
2097 }
2098 }
2100 }
2102 static int
2104 {
2118 }
2121 }
2123 static int
2125 {
2139 }
2142 }
2144 #ifdef MONO_ARCH_HAVE_IMT
2145 static void
2147 {
2163 }
2165 #ifdef ENABLE_LLVM
2167 #endif
2168 #ifdef MONO_ARCH_IMT_REG
2170 #else
2171 /* Need this to keep the IMT arg alive */
2173 #endif
2175 }
2177 #ifdef MONO_ARCH_IMT_REG
2190 }
2193 #else
2195 #endif
2196 }
2197 #endif
2201 {
2209 }
2214 {
2216 #ifdef MONO_ARCH_SOFT_FLOAT
2218 #endif
2222 else
2223 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2234 //g_assert_not_reached ();
2235 }
2242 /*
2243 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2244 * address of return value to increase optimization opportunities.
2245 * Before vtype decomposition, the dreg of the call ins itself represents the
2246 * fact the call modifies the return value. After decomposition, the call will
2247 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2248 * will be transformed into an LDADDR.
2249 */
2253 /* We reference the call too since call->dreg could change during optimization */
2263 #ifdef MONO_ARCH_SOFT_FLOAT
2265 /*
2266 * If the call has a float argument, we would need to do an r8->r4 conversion using
2267 * an icall, but that cannot be done during the call sequence since it would clobber
2268 * the call registers + the stack. So we do it before emitting the call.
2269 */
2276 else
2287 /* The result will be in an int vreg */
2289 }
2290 }
2291 }
2292 #endif
2294 #ifdef ENABLE_LLVM
2297 else
2299 #else
2301 #endif
2307 }
2309 static void
2311 {
2312 #ifdef MONO_ARCH_RGCTX_REG
2316 #ifdef ENABLE_LLVM
2318 #endif
2319 #else
2320 NOT_IMPLEMENTED;
2321 #endif
2322 }
2325 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2326 {
2333 }
2345 }
2348 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2355 {
2356 gboolean might_be_remote;
2366 }
2369 /* Create the real signature */
2370 /* FIXME: Cache these */
2375 }
2388 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2391 }
2397 else
2407 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2408 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2413 /* Make a call to delegate->invoke_impl */
2419 /* We must emit a dummy use here because the delegate trampoline will
2420 replace the 'this' argument with the delegate target making this activation
2421 no longer a root for the delegate.
2422 This is an issue for delegates that target collectible code such as dynamic
2423 methods of GC'able assemblies.
2425 For a test case look into #667921.
2427 FIXME: a dummy use is not the best way to do it as the local register allocator
2428 will put it on a caller save register and spil it around the call.
2429 Ideally, we would either put it on a callee save register or only do the store part.
2430 */
2434 }
2435 #endif
2442 /*
2443 * the method is not virtual, we just need to ensure this is not null
2444 * and then we can call the method directly.
2445 */
2447 /*
2448 * The check above ensures method is not gshared, this is needed since
2449 * gshared methods can't have wrappers.
2450 */
2452 }
2459 /*
2460 * the method is virtual, but we can statically dispatch since either
2461 * it's class or the method itself are sealed.
2462 * But first we need to ensure it's not a null reference.
2463 */
2471 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2474 #ifdef MONO_ARCH_HAVE_IMT
2480 }
2481 #endif
2486 }
2491 #ifdef MONO_ARCH_HAVE_IMT
2495 }
2496 #endif
2497 }
2501 }
2502 }
2510 }
2512 MonoInst*
2514 {
2515 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL, NULL);
2516 }
2518 MonoInst*
2521 {
2532 }
2534 MonoInst*
2536 {
2542 }
2544 /*
2545 * mono_emit_abs_call:
2546 *
2547 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2548 */
2552 {
2556 /*
2557 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2558 * handle it.
2559 */
2566 }
2570 {
2575 /*
2576 * Native code might return non register sized integers
2577 * without initializing the upper bits.
2578 */
2594 }
2603 }
2604 }
2605 }
2608 }
2612 {
2618 }
2620 }
2622 static void
2623 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
2624 {
2641 }
2642 }
2643 }
2645 static void
2647 {
2649 gpointer card_table_mask;
2663 #ifdef MONO_ARCH_HAVE_CARD_TABLE_WBARRIER
2665 #endif
2674 else
2686 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
2687 * IMM's larger than 32bits.
2688 */
2696 }
2703 }
2711 }
2712 }
2714 static gboolean
2715 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
2716 {
2723 /*types with references can't have alignment smaller than sizeof(void*) */
2727 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
2733 /* We don't unroll more than 5 stores to avoid code bloat. */
2735 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
2743 }
2752 /*tmp = dreg*/
2766 /*tmp += sizeof (void*)*/
2770 }
2771 }
2773 /* Those cannot be references since size < sizeof (void*) */
2779 }
2786 }
2793 }
2796 }
2798 /*
2799 * Emit code to copy a valuetype of type @klass whose address is stored in
2800 * @src->dreg to memory whose address is stored at @dest->dreg.
2801 */
2802 void
2803 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2804 {
2811 /*
2812 * This check breaks with spilled vars... need to handle it during verification anyway.
2813 * g_assert (klass && klass == src->klass && klass == dest->klass);
2814 */
2818 else
2821 /* if native is true there should be no references in the struct */
2823 /* Avoid barriers when storing to the stack */
2834 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
2835 if ((cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
2845 }
2846 }
2850 }
2851 }
2854 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2863 }
2864 }
2868 {
2874 }
2876 }
2878 void
2880 {
2883 guint32 align;
2886 /* FIXME: Optimize this for the case when dest is an LDADDR */
2893 }
2900 }
2901 }
2905 {
2938 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2940 }
2948 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2950 }
2951 }
2954 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2955 {
2965 }
2969 {
2970 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2971 }
2976 {
2977 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);
2981 }
2983 /*
2984 * emit_get_rgctx_method:
2985 *
2986 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2987 * normal constants, else emit a load from the rgctx.
2988 */
2992 {
3005 }
3007 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);
3011 }
3012 }
3017 {
3018 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);
3022 }
3024 /*
3025 * On return the caller must check @klass for load errors.
3026 */
3027 static void
3029 {
3046 }
3049 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
3050 else
3051 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
3052 #ifdef MONO_ARCH_VTABLE_REG
3055 #else
3056 NOT_IMPLEMENTED;
3057 #endif
3058 }
3060 static void
3062 {
3072 }
3078 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3080 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3081 }
3082 }
3084 static void
3086 {
3087 /* Reset the variables holding the cast details */
3092 /* It is enough to reset the from field */
3093 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3094 }
3095 }
3097 /*
3098 * On return the caller must check @array_class for load errors
3099 */
3100 static void
3102 {
3111 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3122 }
3143 }
3144 }
3149 }
3151 /**
3152 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3153 * generic code is generated.
3154 */
3157 {
3163 /* FIXME: What if the class is shared? We might not
3164 have to get the address of the method from the
3165 RGCTX. */
3167 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3174 }
3175 }
3179 {
3188 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3189 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3191 /* FIXME: generics */
3194 // Check rank == 0
3199 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3204 /* This assertion is from the unboxcast insn */
3216 }
3218 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
3224 }
3226 /*
3227 * Returns NULL and set the cfg exception on error.
3228 */
3231 {
3240 /*
3241 FIXME: we cannot get managed_alloc here because we can't get
3242 the class's vtable (because it's not a closed class)
3244 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3245 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3246 */
3250 else
3261 }
3264 }
3271 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3272 /* This happens often in argument checking code, eg. throw new FooException... */
3273 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3279 gboolean pass_lw;
3285 }
3287 #ifndef MONO_CROSS_COMPILE
3289 #endif
3294 }
3301 }
3304 }
3305 }
3308 }
3310 /*
3311 * Returns NULL and set the cfg exception on error.
3312 */
3315 {
3322 /* FIXME: What if the class is shared? We might not
3323 have to get the method address from the RGCTX. */
3325 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3331 }
3332 }
3338 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3341 }
3344 static gboolean
3345 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
3346 {
3359 }
3363 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
3368 }
3370 }
3372 // FIXME: This doesn't work yet (class libs tests fail?)
3373 #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)
3375 /*
3376 * Returns NULL and set the cfg exception on error.
3377 */
3380 {
3395 /* obj */
3398 /* klass - it's the second element of the cache entry*/
3399 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3401 /* cache */
3405 }
3410 /* Complex case, handle by an icall */
3412 /* obj */
3415 /* klass */
3420 /* Simple case, handled by the code below */
3421 }
3422 }
3439 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3440 /* the remoting code is broken, access the class for now */
3441 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3447 }
3452 }
3457 }
3458 }
3465 }
3467 /*
3468 * Returns NULL and set the cfg exception on error.
3469 */
3472 {
3489 /* obj */
3492 /* klass - it's the second element of the cache entry*/
3493 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3495 /* cache */
3499 }
3504 /* Complex case, handle by an icall */
3506 /* obj */
3509 /* klass */
3514 /* Simple case, the code below can handle it */
3515 }
3516 }
3522 /* Do the assignment at the beginning, so the other assignment can be if converted */
3534 /* the is_null_bb target simply copies the input register to the output */
3544 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3548 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3552 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3556 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3566 /* Check that the object is a vector too */
3571 }
3573 /* the is_null_bb target simply copies the input register to the output */
3575 }
3579 /* the is_null_bb target simply copies the input register to the output */
3582 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3584 /* the remoting code is broken, access the class for now */
3585 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3591 }
3596 }
3601 /* the is_null_bb target simply copies the input register to the output */
3603 }
3604 }
3605 }
3617 }
3621 {
3622 /* This opcode takes as input an object reference and a class, and returns:
3623 0) if the object is an instance of the class,
3624 1) if the object is not instance of the class,
3625 2) if the object is a proxy whose type cannot be determined */
3652 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3655 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3663 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3665 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3666 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3669 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3679 }
3697 /* FIXME: */
3703 }
3707 {
3708 /* This opcode takes as input an object reference and a class, and returns:
3709 0) if the object is an instance of the class,
3710 1) if the object is a proxy whose type cannot be determined
3711 an InvalidCastException exception is thrown otherwhise*/
3739 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3751 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3754 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3755 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3758 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3774 }
3782 /* FIXME: */
3788 }
3790 /*
3791 * Returns NULL and set the cfg exception on error.
3792 */
3794 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3795 {
3807 /* Inline the contents of mono_delegate_ctor */
3809 /* Set target field */
3810 /* Optimize away setting of NULL target */
3812 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3815 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target));
3817 }
3818 }
3820 /* Set method field */
3822 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3825 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method));
3827 }
3828 /*
3829 * To avoid looking up the compiled code belonging to the target method
3830 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3831 * store it, and we fill it after the method has been compiled.
3832 */
3837 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3847 }
3851 }
3852 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3853 }
3855 /* Set invoke_impl field */
3861 }
3862 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3864 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3867 }
3871 {
3874 /* Need to register the icall so it gets an icall wrapper */
3879 /* mono_array_new_va () needs a vararg calling convention */
3882 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3884 }
3886 static void
3888 {
3897 /* Add it to the start of the first bblock */
3901 }
3902 else
3907 /*
3908 * Add a dummy use to keep the got_var alive, since real uses might
3909 * only be generated by the back ends.
3910 * Add it to end_bblock, so the variable's lifetime covers the whole
3911 * method.
3912 * It would be better to make the usage of the got var explicit in all
3913 * cases when the backend needs it (i.e. calls, throw etc.), so this
3914 * wouldn't be needed.
3915 */
3918 }
3923 static gboolean
3925 {
3926 MonoMethodHeaderSummary header;
3928 #ifdef MONO_ARCH_SOFT_FLOAT
3931 #endif
3939 #ifdef MONO_ARCH_HAVE_LMF_OPS
3944 #endif
3950 /*runtime, icall and pinvoke are checked by summary call*/
3957 /* also consider num_locals? */
3958 /* Do the size check early to avoid creating vtables */
3962 else
3965 }
3969 /*
3970 * if we can initialize the class of the method right away, we do,
3971 * otherwise we don't allow inlining if the class needs initialization,
3972 * since it would mean inserting a call to mono_runtime_class_init()
3973 * inside the inlined code
3974 */
3978 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3980 /* No vtable created yet */
3985 /* This makes so that inline cannot trigger */
3986 /* .cctors: too many apps depend on them */
3987 /* running with a specific order... */
3991 }
3994 /* No vtable created yet */
4001 }
4003 /*
4004 * If we're compiling for shared code
4005 * the cctor will need to be run at aot method load time, for example,
4006 * or at the end of the compilation of the inlining method.
4007 */
4008 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
4010 }
4012 /*
4013 * CAS - do not inline methods with declarative security
4014 * Note: this has to be before any possible return TRUE;
4015 */
4019 #ifdef MONO_ARCH_SOFT_FLOAT
4020 /* FIXME: */
4026 #endif
4029 }
4031 static gboolean
4033 {
4044 /* The initialization is already done before the method is called */
4048 }
4051 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4052 {
4054 guint32 size;
4064 #if SIZEOF_REGISTER == 8
4065 /* The array reg is 64 bits but the index reg is only 32 */
4067 /* Not needed */
4072 }
4073 #else
4079 }
4080 #endif
4085 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4089 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
4094 }
4095 #endif
4107 }
4109 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4111 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4112 {
4126 guint32 size;
4134 /* range checking */
4165 }
4166 #endif
4169 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
4170 {
4181 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4182 /* emit_ldelema_2 depends on OP_LMUL */
4185 }
4186 #endif
4193 }
4195 static MonoBreakPolicy
4197 {
4199 }
4203 /**
4204 * mono_set_break_policy:
4205 * policy_callback: the new callback function
4206 *
4207 * Allow embedders to decide wherther to actually obey breakpoint instructions
4208 * (both break IL instructions and Debugger.Break () method calls), for example
4209 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4210 * untrusted or semi-trusted code.
4211 *
4212 * @policy_callback will be called every time a break point instruction needs to
4213 * be inserted with the method argument being the method that calls Debugger.Break()
4214 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4215 * if it wants the breakpoint to not be effective in the given method.
4216 * #MONO_BREAK_POLICY_ALWAYS is the default.
4217 */
4218 void
4220 {
4223 else
4225 }
4227 static gboolean
4239 }
4240 }
4242 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
4244 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4245 {
4249 /* the bounds check is already done by the callers */
4257 }
4259 }
4262 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4263 {
4265 #ifdef MONO_ARCH_SIMD_INTRINSICS
4270 }
4271 #endif
4274 }
4278 {
4285 }
4288 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4289 {
4304 #if SIZEOF_REGISTER == 8
4305 /* The array reg is 64 bits but the index reg is only 32 */
4307 #else
4309 #endif
4312 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4313 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
4315 /* Avoid a warning */
4319 #else
4324 #endif
4329 /* Decompose later to allow more optimizations */
4341 /* The corlib functions check for oob already. */
4344 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4353 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4354 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4358 #if !defined(MONO_ARCH_EMULATE_MUL_DIV)
4368 #endif
4379 #ifndef MONO_BIG_ARRAYS
4380 /*
4381 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
4382 * Array methods.
4383 */
4384 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
4397 /* Non-szarray case */
4401 else
4406 /* Szarray case */
4410 else
4418 }
4419 #endif
4458 }
4461 /* FIXME this should be integrated to the check below once we support the trampoline version */
4462 #if defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4466 /* Avoid infinite recursion */
4467 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN && !strcmp (cfg->method->name, "FastMonitorEnterV4"))
4475 }
4476 #endif
4478 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4483 /*
4484 * Pass the argument normally, the LLVM backend will handle the
4485 * calling convention problems.
4486 */
4487 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4493 }
4500 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4506 }
4509 }
4510 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4511 {
4514 /* Avoid infinite recursion */
4527 }
4528 #endif
4534 #if SIZEOF_REGISTER == 8
4536 /* 64 bit reads are already atomic */
4542 }
4543 #endif
4545 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4552 #if SIZEOF_REGISTER == 8
4555 #endif
4569 }
4576 #if SIZEOF_REGISTER == 8
4579 #endif
4593 }
4599 #if SIZEOF_REGISTER == 8
4602 #endif
4612 }
4613 }
4616 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4618 guint32 opcode;
4623 #if SIZEOF_REGISTER == 8
4627 #else
4630 #endif
4631 else
4654 }
4658 }
4661 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4688 /* g_assert_not_reached (); */
4689 }
4692 }
4705 }
4707 }
4710 #ifdef TARGET_WIN32
4712 #else
4714 #endif
4716 }
4718 /*
4719 * There is general branches code for Min/Max, but it does not work for
4720 * all inputs:
4721 * http://everything2.com/?node_id=1051618
4722 */
4723 }
4725 #ifdef MONO_ARCH_SIMD_INTRINSICS
4730 }
4731 #endif
4734 }
4736 /*
4737 * This entry point could be used later for arbitrary method
4738 * redirection.
4739 */
4743 {
4745 /* managed string allocation support */
4746 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
4752 #ifndef MONO_CROSS_COMPILE
4754 #endif
4760 }
4761 }
4763 }
4765 static void
4767 {
4772 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4774 /*
4775 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4776 * would be different than the MonoInst's used to represent arguments, and
4777 * the ldelema implementation can't deal with that.
4778 * Solution: When ldelema is used on an inline argument, create a var for
4779 * it, emit ldelema on that var, and emit the saving code below in
4780 * inline_method () if needed.
4781 */
4784 /* This uses cfg->args [i] which is set by the preceeding line */
4787 sp++;
4788 }
4789 }
4791 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4792 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4794 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4795 static gboolean
4797 {
4806 else
4808 }
4816 //return (strncmp_result <= 0);
4820 }
4821 }
4822 #endif
4824 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4825 static gboolean
4827 {
4837 }
4838 }
4846 //return (strncmp_result <= 0);
4850 }
4851 }
4852 #endif
4854 static int
4855 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4857 {
4865 guint prev_real_offset;
4870 guint32 prev_cil_offset_to_bb_len;
4877 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4880 #endif
4881 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4884 #endif
4887 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4892 }
4894 /* allocate local variables */
4907 }
4909 /*Must verify before creating locals as it can cause the JIT to assert.*/
4913 }
4915 /* allocate space to store the return value */
4918 }
4925 /* allocate start and end blocks */
4926 /* This is needed so if the inline is aborted, we can clean up */
4953 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
4973 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4977 /* always add some code to avoid block split failures */
4984 /*
4985 * Get rid of the begin and end bblocks if possible to aid local
4986 * optimizations.
4987 */
4990 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4997 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
5000 }
5003 }
5006 /*
5007 * If the inlined method contains only a throw, then the ret var is not
5008 * set, so set it to a dummy value.
5009 */
5037 }
5038 }
5042 }
5051 /* This gets rid of the newly added bblocks */
5053 }
5056 }
5058 /*
5059 * Some of these comments may well be out-of-date.
5060 * Design decisions: we do a single pass over the IL code (and we do bblock
5061 * splitting/merging in the few cases when it's required: a back jump to an IL
5062 * address that was not already seen as bblock starting point).
5063 * Code is validated as we go (full verification is still better left to metadata/verify.c).
5064 * Complex operations are decomposed in simpler ones right away. We need to let the
5065 * arch-specific code peek and poke inside this process somehow (except when the
5066 * optimizations can take advantage of the full semantic info of coarse opcodes).
5067 * All the opcodes of the form opcode.s are 'normalized' to opcode.
5068 * MonoInst->opcode initially is the IL opcode or some simplification of that
5069 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
5070 * opcode with value bigger than OP_LAST.
5071 * At this point the IR can be handed over to an interpreter, a dumb code generator
5072 * or to the optimizing code generator that will translate it to SSA form.
5073 *
5074 * Profiling directed optimizations.
5075 * We may compile by default with few or no optimizations and instrument the code
5076 * or the user may indicate what methods to optimize the most either in a config file
5077 * or through repeated runs where the compiler applies offline the optimizations to
5078 * each method and then decides if it was worth it.
5079 */
5081 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
5082 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
5083 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
5084 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
5085 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
5086 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
5087 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
5088 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; LOAD_ERROR;}
5090 /* offset from br.s -> br like opcodes */
5091 #define BIG_BRANCH_OFFSET 13
5093 static gboolean
5095 {
5099 }
5101 static int
5102 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
5103 {
5107 guint cli_addr;
5115 UNVERIFIED;
5119 ip++;
5154 guint32 j;
5164 }
5166 }
5173 }
5178 /* Find the start of the bblock containing the throw */
5182 bb_start --;
5183 }
5186 }
5187 }
5189 unverified:
5192 }
5195 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5196 {
5205 }
5208 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5209 {
5212 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
5216 }
5220 {
5225 else
5230 }
5232 /*
5233 * Returns TRUE if the JIT should abort inlining because "callee"
5234 * is influenced by security attributes.
5235 */
5236 static
5238 {
5239 guint32 result;
5243 }
5250 /* Generate code to throw a SecurityException before the actual call/link */
5258 /* don't hide previous results */
5262 }
5265 }
5269 {
5275 }
5278 }
5280 static void
5282 {
5288 }
5290 /*
5291 * Return the original method is a wrapper is specified. We can only access
5292 * the custom attributes from the original method.
5293 */
5296 {
5300 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
5304 /* in other cases we need to find the original method */
5306 }
5308 static void
5309 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
5311 {
5312 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5313 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
5316 }
5318 static void
5319 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
5321 {
5322 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5323 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
5326 }
5328 /*
5329 * Check that the IL instructions at ip are the array initialization
5330 * sequence and return the pointer to the data and the size.
5331 */
5333 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
5334 {
5335 /*
5336 * newarr[System.Int32]
5337 * dup
5338 * ldtoken field valuetype ...
5339 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5340 */
5345 guint32 rva;
5350 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
5361 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
5368 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5369 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5379 #ifdef ARM_FPU_FPA
5381 #endif
5385 #endif
5388 }
5393 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5398 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5399 /* for aot code we do the lookup on load */
5403 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5406 }
5408 }
5410 }
5412 static void
5414 {
5421 else
5424 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5428 }
5430 static void
5432 {
5436 }
5438 static gboolean
5440 {
5442 }
5444 static void
5446 {
5451 /* Optimize reg-reg moves away */
5452 /*
5453 * Can't optimize other opcodes, since sp[0] might point to
5454 * the last ins of a decomposed opcode.
5455 */
5459 }
5460 }
5462 /*
5463 * ldloca inhibits many optimizations so try to get rid of it in common
5464 * cases.
5465 */
5468 {
5478 }
5480 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5483 /* From the INITOBJ case */
5493 }
5497 }
5498 load_error:
5500 }
5502 static gboolean
5504 {
5509 }
5511 }
5513 /*
5514 * is_jit_optimizer_disabled:
5515 *
5516 * Determine whenever M's assembly has a DebuggableAttribute with the
5517 * IsJITOptimizerDisabled flag set.
5518 */
5519 static gboolean
5521 {
5533 klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
5535 /* Linked away */
5540 }
5552 /* Decode the attribute. See reflection.c */
5558 // FIXME: Support named parameters
5560 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
5562 /* Two boolean arguments */
5563 p ++;
5565 }
5567 }
5574 }
5576 static gboolean
5577 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig)
5578 {
5579 gboolean supported_tail_call;
5582 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
5583 supported_tail_call = MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
5584 #else
5585 supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
5586 #endif
5589 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
5590 /* These can point to the current method's stack */
5592 }
5594 /* this might point to the current method's stack */
5603 /* Debugging support */
5604 #if 0
5607 count ++;
5613 }
5614 }
5615 #endif
5618 }
5620 /* the JIT intercepts ldflda instructions to the tlsdata field in ThreadLocal<T> and redirects
5621 * it to the thread local value based on the tls_offset field. Every other kind of access to
5622 * the field causes an assert.
5623 */
5624 static gboolean
5626 {
5632 }
5634 /* emits the code needed to access a managed tls var (like ThreadStatic)
5635 * with the value of the tls offset in offset_reg. thread_ins represents the MonoInternalThread
5636 * pointer for the current thread.
5637 * Returns the MonoInst* representing the address of the tls var.
5638 */
5641 {
5645 // inlined access to the tls data
5646 // idx = (offset >> 24) - 1;
5647 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
5649 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
5662 }
5664 /*
5665 * redirect access to the tlsdata field to the tls var given by the tls_offset field.
5666 * this address is cached per-method in cached_tls_addr.
5667 */
5669 create_magic_tls_access (MonoCompile *cfg, MonoClassField *tls_field, MonoInst **cached_tls_addr, MonoInst *thread_local)
5670 {
5677 }
5681 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, offset_field->type, thread_local->dreg, offset_field->offset);
5686 thread_method = mono_class_get_method_from_name (mono_get_thread_class(), "CurrentInternalThread_internal", 0);
5688 }
5692 *cached_tls_addr = temp = mono_compile_create_var (cfg, type_from_stack_type (addr), OP_LOCAL);
5697 }
5699 /*
5700 * mono_method_to_ir:
5701 *
5702 * Translate the .net IL into linear IR.
5703 */
5704 int
5705 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5708 {
5709 MonoError error;
5729 guint num_args;
5732 MonoDeclSecurityActions actions;
5737 gboolean disable_inline;
5742 /* serialization and xdomain stuff may need access to private fields and methods */
5752 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5767 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
5768 }
5770 }
5782 /*
5783 * Methods without init_locals set could cause asserts in various passes
5784 * (#497220).
5785 */
5792 }
5794 /* SkipVerification is not allowed if core-clr is enabled */
5798 }
5815 }
5823 }
5825 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5846 /* ENTRY BLOCK */
5851 #if defined(__native_client_codegen__)
5855 #endif
5857 /* EXIT BLOCK */
5870 }
5871 /* handle exception clauses */
5895 /* finally clauses already have a seq point */
5898 }
5900 /* todo: is a fault block unsafe to optimize? */
5903 }
5906 /*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);
5907 while (p < end) {
5908 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5909 }*/
5910 /* catch and filter blocks get the exception object on the stack */
5915 /* mostly like handle_stack_args (), but just sets the input args */
5916 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5921 /*
5922 * Add a dummy use for the exvar so its liveness info will be
5923 * correct.
5924 */
5934 /* The filter block shares the exvar with the handler block */
5938 }
5939 }
5945 /*
5946 * In shared generic code with catch
5947 * clauses containing type variables
5948 * the exception handling code has to
5949 * be able to get to the rgctx.
5950 * Therefore we have to make sure that
5951 * the vtable/mrgctx argument (for
5952 * static or generic methods) or the
5953 * "this" argument (for non-static
5954 * methods) are live.
5955 */
5964 }
5965 }
5966 }
5972 }
5974 /* FIRST CODE BLOCK */
5987 }
5988 }
5994 /* at this point having security doesn't mean we have any code to generate */
5996 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5997 * And we do not want to enter the next section (with allocation) if we
5998 * have nothing to generate */
6000 }
6002 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
6009 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
6012 }
6020 }
6023 }
6025 /* not a P/Invoke after all */
6027 }
6028 }
6030 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
6031 /* we use a separate basic block for the initialization code */
6044 }
6046 /* at this point we know, if security is TRUE, that some code needs to be generated */
6053 /* Add code for SecurityAction.Demand */
6056 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6058 }
6060 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
6061 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
6064 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6066 }
6068 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
6071 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
6073 }
6074 }
6076 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
6079 }
6082 /* check if this is native code, e.g. an icall or a p/invoke */
6089 /* if this ia a native call then it can only be JITted from platform code */
6095 }
6096 }
6097 }
6098 }
6099 }
6102 UNVERIFIED;
6106 UNVERIFIED;
6107 }
6114 UNVERIFIED;
6115 }
6118 /* We force the vtable variable here for all shared methods
6119 for the possibility that they might show up in a stack
6120 trace where their exact instantiation is needed. */
6127 /* FIXME: Is there a better way to do this?
6128 We need the variable live for the duration
6129 of the whole method. */
6131 }
6132 }
6134 /* add a check for this != NULL to inlined methods */
6141 }
6148 UNVERIFIED;
6149 }
6151 }
6153 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
6154 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
6162 else
6174 }
6184 }
6195 }
6204 }
6207 }
6208 }
6226 }
6230 }
6231 }
6232 /*
6233 * Sequence points are points where the debugger can place a breakpoint.
6234 * Currently, we generate these automatically at points where the IL
6235 * stack is empty.
6236 */
6240 }
6248 /* TODO: Use an increment here */
6249 #if defined(TARGET_X86)
6254 #else
6257 #endif
6258 }
6261 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
6267 else
6269 ip++;
6277 }
6278 ip++;
6289 ip++;
6300 ip++;
6312 UNVERIFIED;
6317 }
6344 UNVERIFIED;
6367 }
6373 }
6380 UNVERIFIED;
6443 #ifdef TARGET_POWERPC
6444 /* FIXME: Clean this up */
6447 #endif
6449 /* FIXME: we should really allocate this only late in the compilation process */
6469 }
6475 }
6480 #ifdef TARGET_POWERPC
6481 /* FIXME: Clean this up */
6484 #endif
6486 /* FIXME: we should really allocate this only late in the compilation process */
6506 }
6512 }
6517 sp--;
6532 }
6535 ip++;
6538 #ifdef TARGET_X86
6540 /* we need to pop the value from the x86 FP stack */
6542 #endif
6547 INLINE_FAILURE;
6551 UNVERIFIED;
6553 /* FIXME: check the signature matches */
6557 LOAD_ERROR;
6563 CHECK_CFG_EXCEPTION;
6565 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6566 {
6570 /* Handle tail calls similarly to calls */
6584 }
6585 #else
6587 /* Prevent arguments from being optimized away */
6594 #endif
6599 }
6626 else
6634 /*
6635 * This is a call through a function pointer using a pinvoke
6636 * signature. Have to create a wrapper and call that instead.
6637 * FIXME: This is very slow, need to create a wrapper at JIT time
6638 * instead based on the signature.
6639 */
6644 }
6656 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_call, generic_context);
6657 }
6662 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6663 /*
6664 * This is needed since get_method_constrained can't find
6665 * the method in klass representing a type var.
6666 * The type var is guaranteed to be a reference type in this
6667 * case.
6668 */
6673 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6674 }
6678 }
6681 LOAD_ERROR;
6685 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6686 }
6689 METHOD_ACCESS_FAILURE;
6690 }
6696 /* MS.NET seems to silently convert this to a callvirt */
6699 {
6700 /*
6701 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
6702 * converts to a callvirt.
6703 *
6704 * tests/bug-515884.il is an example of this behavior
6705 */
6706 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
6708 if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
6710 }
6714 LOAD_ERROR;
6724 LOAD_ERROR;
6734 }
6735 }
6743 INLINE_FAILURE;
6744 CHECK_CFG_EXCEPTION;
6745 }
6749 }
6752 UNVERIFIED;
6759 //g_assert (!virtual || fsig->hasthis);
6764 /*
6765 * We have the `constrained.' prefix opcode.
6766 */
6768 /*
6769 * The type parameter is instantiated as a valuetype,
6770 * but that type doesn't override the method we're
6771 * calling, so we need to box `this'.
6772 */
6775 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
6776 CHECK_CFG_EXCEPTION;
6780 /*
6781 * The type parameter is instantiated as a reference
6782 * type. We have a managed pointer on the stack, so
6783 * we need to dereference it here.
6784 */
6791 }
6794 UNVERIFIED;
6796 /*
6797 * If the callee is a shared method, then its static cctor
6798 * might not get called after the call was patched.
6799 */
6800 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)) {
6803 }
6811 /*
6812 * Pass vtable iff target method might
6813 * be shared, which means that sharing
6814 * is enabled for its class and its
6815 * context is sharable (and it's not a
6816 * generic method).
6817 */
6821 }
6833 }
6841 /* Generic method interface
6842 calls are resolved via a
6843 helper function and don't
6844 need an imt. */
6847 }
6849 /*
6850 * If a shared method calls another
6851 * shared method then the caller must
6852 * have a generic sharing context
6853 * because the magic trampoline
6854 * requires it. FIXME: We shouldn't
6855 * have to force the vtable/mrgctx
6856 * variable here. Instead there
6857 * should be a flag in the cfg to
6858 * request a generic sharing context.
6859 */
6863 }
6873 }
6874 }
6880 /*
6881 * emit_get_rgctx_method () calls mono_class_vtable () so check
6882 * for type load errors before.
6883 */
6886 }
6890 /* !marshalbyref is needed to properly handle generic methods + remoting */
6897 }
6898 }
6906 }
6911 /* Calling virtual generic methods */
6922 /* Prevent inlining of methods that contain indirect calls */
6923 INLINE_FAILURE;
6925 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
6934 #endif
6935 {
6940 /* FIXME: This should be a managed pointer */
6953 }
6958 CHECK_CFG_EXCEPTION;
6963 }
6965 /*
6966 * Implement a workaround for the inherent races involved in locking:
6967 * Monitor.Enter ()
6968 * try {
6969 * } finally {
6970 * Monitor.Exit ()
6971 * }
6972 * If a thread abort happens between the call to Monitor.Enter () and the start of the
6973 * try block, the Exit () won't be executed, see:
6974 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
6975 * To work around this, we extend such try blocks to include the last x bytes
6976 * of the Monitor.Enter () call.
6977 */
6978 if (cmethod && cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
6982 /*
6983 * Only extend try blocks with a finally, to avoid catching exceptions thrown
6984 * from Monitor.Enter like ArgumentNullException.
6985 */
6987 /* Mark this bblock as needing to be extended */
6989 }
6990 }
6992 /* Conversion to a JIT intrinsic */
6993 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6998 sp++;
6999 }
7001 CHECK_CFG_EXCEPTION;
7006 }
7008 /* Inlining */
7010 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
7018 /* Prevent inlining of methods that call wrappers */
7019 INLINE_FAILURE;
7022 }
7024 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, always))) {
7030 /* *sp is already set by inline_method */
7031 sp++;
7036 }
7037 }
7041 /* Tail recursion elimination */
7042 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
7046 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7047 INLINE_FAILURE;
7049 /* keep it simple */
7053 }
7065 /* skip the CEE_RET, too */
7068 else
7073 }
7074 }
7076 /* Generic sharing */
7077 /* FIXME: only do this for generic methods if
7078 they are not shared! */
7084 INLINE_FAILURE;
7089 /*
7090 * We are compiling a call to a
7091 * generic method from shared code,
7092 * which means that we have to look up
7093 * the method in the rgctx and do an
7094 * indirect call.
7095 */
7096 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
7097 }
7099 /* Indirect calls */
7107 else
7108 /* FIXME: what the hell is this??? */
7112 /* Prevent inlining of methods with indirect calls */
7113 INLINE_FAILURE;
7119 /*
7120 * Instead of emitting an indirect call, emit a direct call
7121 * with the contents of the aotconst as the patch info.
7122 */
7123 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
7125 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
7126 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
7130 }
7131 }
7135 CHECK_CFG_EXCEPTION;
7140 }
7142 /* Array methods */
7156 }
7159 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
7160 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
7178 }
7180 CHECK_CFG_EXCEPTION;
7185 }
7192 CHECK_CFG_EXCEPTION;
7197 }
7199 /* Tail prefix / tail call optimization */
7201 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
7202 /* FIXME: runtime generic context pointer for jumps? */
7203 /* FIXME: handle this for generic sharing eventually */
7207 && !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig);
7212 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7213 INLINE_FAILURE;
7215 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7217 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
7218 /* Handle tail calls similarly to calls */
7219 call = mono_emit_call_args (cfg, mono_method_signature (cmethod), sp, FALSE, FALSE, TRUE, FALSE);
7220 #else
7226 /*
7227 * We implement tail calls by storing the actual arguments into the
7228 * argument variables, then emitting a CEE_JMP.
7229 */
7231 /* Prevent argument from being register allocated */
7234 }
7235 #endif
7244 CHECK_CFG_EXCEPTION;
7249 // FIXME: Eliminate unreachable epilogs
7251 /*
7252 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
7253 * only reachable from this call.
7254 */
7259 }
7261 /* Common call */
7262 INLINE_FAILURE;
7269 CHECK_CFG_EXCEPTION;
7274 }
7277 /* return from inlined method */
7278 /*
7279 * If in_count == 0, that means the ret is unreachable due to
7280 * being preceeded by a throw. In that case, inline_method () will
7281 * handle setting the return value
7282 * (test case: test_0_inline_throw ()).
7283 */
7288 //g_assert (returnvar != -1);
7291 }
7297 /*
7298 * Place a seq point here too even through the IL stack is not
7299 * empty, so a step over on
7300 * call <FOO>
7301 * ret
7302 * will work correctly.
7303 */
7306 }
7312 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7313 UNVERIFIED;
7327 }
7329 #ifdef MONO_ARCH_SOFT_FLOAT
7339 }
7340 #else
7342 #endif
7343 }
7344 }
7345 }
7347 UNVERIFIED;
7349 ip++;
7358 ip++;
7368 }
7386 ip++;
7388 ip++;
7398 ip++;
7409 }
7428 UNVERIFIED;
7429 ip ++;
7433 sp--;
7443 }
7450 #if SIZEOF_REGISTER == 4
7452 /* Convert it to OP_LCOMPARE */
7460 }
7461 #endif
7477 }
7491 ip++;
7509 gboolean use_op_switch;
7517 UNVERIFIED;
7532 }
7535 /*
7536 * Link the current bb with the targets as well, so handle_stack_args
7537 * will set their in_stack correctly.
7538 */
7546 }
7560 #ifdef TARGET_ARM
7561 /* ARM implements SWITCH statements differently */
7562 /* FIXME: Make it use the generic implementation */
7565 #endif
7582 else
7585 #if SIZEOF_REGISTER == 8
7586 /* The upper word might not be zero, and we add it to a 64 bit address later */
7588 #endif
7598 }
7600 /* FIXME: Use load_memindex */
7604 }
7608 }
7636 }
7645 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
7646 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
7648 }
7667 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
7668 /* FIXME it's questionable if acquire semantics require full barrier or just LoadLoad*/
7670 }
7674 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)))
7692 /* Use the immediate opcodes if possible */
7701 }
7702 }
7707 ip++;
7732 /* FIXME: Pass opcode to is_inst_imm */
7734 /* Use the immediate opcodes if possible */
7735 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)) {
7742 #if SIZEOF_REGISTER == 8
7744 #else
7747 #endif
7748 }
7749 else
7753 /* Might be followed by an instruction added by ADD_WIDEN_OP */
7756 }
7757 }
7761 ip++;
7778 /* Special case this earlier so we have long constants in the IR */
7783 #if SIZEOF_REGISTER == 8
7786 else
7788 #else
7792 else
7794 #endif
7796 }
7799 }
7800 ip++;
7814 }
7815 ip++;
7827 }
7828 ip++;
7846 CHECK_CFG_EXCEPTION;
7847 ip++;
7857 ip++;
7882 }
7897 /* Optimize the common ldobj+stloc combination */
7912 }
7922 }
7924 /* Optimize the ldobj+stobj combination */
7925 /* The reference case ends up being a load+store anyway */
7926 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7929 sp --;
7936 }
7945 }
7955 }
7967 }
7978 /*
7979 * Avoid relocations in AOT and save some space by using a
7980 * version of helper_ldstr specialized to mscorlib.
7981 */
7985 /* Avoid creating the string object */
7989 }
7990 }
7991 else
7996 }
8002 OUT_OF_MEMORY_FAILURE;
8006 }
8007 }
8008 }
8010 sp++;
8016 MonoInst this_ins;
8024 LOAD_ERROR;
8027 LOAD_ERROR;
8032 LOAD_ERROR;
8039 INLINE_FAILURE;
8040 CHECK_CFG_EXCEPTION;
8043 }
8045 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)) {
8048 }
8067 }
8068 }
8069 }
8074 /*
8075 * Generate smaller code for the common newobj <exception> instruction in
8076 * argument checking code.
8077 */
8104 }
8109 }
8111 /* move the args to allow room for 'this' in the first position */
8115 }
8117 /* check_call_signature () requires sp[0] to be set */
8121 UNVERIFIED;
8131 /* Avoid varargs in the common case */
8138 else
8143 /* we simply pass a null pointer */
8145 /* now call the string ctor */
8157 /*
8158 * The code generated by mini_emit_virtual_call () expects
8159 * iargs [0] to be a boxed instance, but luckily the vcall
8160 * will be transformed into a normal call there.
8161 */
8170 /*
8171 * TypeInitializationExceptions thrown from the mono_runtime_class_init
8172 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
8173 * As a workaround, we call class cctors before allocating objects.
8174 */
8175 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8176 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8178 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
8180 }
8184 }
8190 /* Now call the actual ctor */
8191 /* Avoid virtual calls to ctors if possible */
8196 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8200 sp++;
8201 }
8203 CHECK_CFG_EXCEPTION;
8210 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
8216 INLINE_FAILURE;
8218 }
8229 INLINE_FAILURE;
8232 }
8233 }
8236 /* Valuetype */
8240 }
8241 else
8247 }
8256 UNVERIFIED;
8261 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8265 /* obj */
8268 /* klass */
8271 /* inline cache*/
8274 else
8277 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8281 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8291 CHECK_CFG_EXCEPTION;
8301 }
8304 CHECK_CFG_EXCEPTION;
8308 }
8318 UNVERIFIED;
8323 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8327 /* obj */
8330 /* klass */
8333 /* inline cache*/
8336 else
8342 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8352 CHECK_CFG_EXCEPTION;
8362 }
8365 CHECK_CFG_EXCEPTION;
8369 }
8371 }
8386 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
8387 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8391 /* obj */
8394 /* klass */
8397 /* inline cache*/
8398 /*FIXME AOT support*/
8401 else
8404 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8408 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8418 CHECK_CFG_EXCEPTION;
8429 CHECK_CFG_EXCEPTION;
8433 }
8435 }
8442 }
8444 /* UNBOX */
8450 /* LDOBJ */
8456 }
8477 }
8480 UNVERIFIED;
8482 UNVERIFIED;
8483 /* frequent check in generic code: box (struct), brtrue */
8485 // FIXME: LLVM can't handle the inconsistent bb linking
8499 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8501 }
8507 ip++;
8509 ip++;
8514 ip++;
8520 }
8522 /*
8523 * We need to link both bblocks, since it is needed for handling stack
8524 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
8525 * Branching to only one of them would lead to inconsistencies, so
8526 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
8527 */
8538 }
8547 /* The JIT can't eliminate the iconst+compare */
8551 }
8555 }
8559 CHECK_CFG_EXCEPTION;
8563 }
8587 }
8591 }
8597 guint foffset;
8605 }
8607 UNVERIFIED;
8609 UNVERIFIED;
8615 }
8618 }
8620 LOAD_ERROR;
8622 FIELD_ACCESS_FAILURE;
8626 UNVERIFIED;
8627 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
8628 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
8629 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8630 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8631 */
8636 UNVERIFIED;
8637 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8651 CHECK_CFG_EXCEPTION;
8660 }
8670 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)) {
8671 /* insert call to write barrier */
8678 }
8681 }
8685 }
8687 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8688 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
8694 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
8698 CHECK_CFG_EXCEPTION;
8710 }
8715 /* Have to compute the address of the variable */
8720 else
8725 }
8735 }
8743 }
8754 }
8755 }
8759 }
8765 gboolean is_special_static;
8774 }
8775 else
8778 LOAD_ERROR;
8781 FIELD_ACCESS_FAILURE;
8783 /* if the class is Critical then transparent code cannot access it's fields */
8787 /*
8788 * We can only support shared generic static
8789 * field access on architectures where the
8790 * trampoline code has been extended to handle
8791 * the generic class init.
8792 */
8793 #ifndef MONO_ARCH_VTABLE_REG
8795 #endif
8804 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8805 * to be called here.
8806 */
8810 }
8818 /* Generate IR to compute the field address */
8819 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
8820 /*
8821 * Fast access to TLS data
8822 * Inline version of get_thread_static_data () in
8823 * threads.c.
8824 */
8825 guint32 offset;
8829 // offset &= 0x7fffffff;
8830 // idx = (offset >> 24) - 1;
8831 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
8836 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
8841 /* For TLS variables, this will return the TLS offset */
8864 }
8877 }
8882 /*
8883 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8884 method->klass->name_space, method->klass->name, method->name,
8885 depth, field->offset);
8886 */
8891 /*
8892 * The pointer we're computing here is
8893 *
8894 * super_info.static_data + field->offset
8895 */
8904 }
8919 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8921 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8923 }
8927 /* This makes so that inline cannot trigger */
8928 /* .cctors: too many apps depend on them */
8929 /* running with a specific order... */
8931 INLINE_FAILURE;
8936 }
8937 }
8938 }
8943 else
8949 }
8950 }
8952 /* Generate IR to do the actual load/store operation */
8961 sp--;
8972 }
8979 }
8980 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8986 sp++;
8990 sp++;
8995 sp++;
8999 sp++;
9004 sp++;
9008 sp++;
9016 sp++;
9026 sp++;
9029 }
9034 sp++;
9042 }
9043 }
9054 }
9055 }
9059 }
9067 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
9071 /* insert call to write barrier */
9073 }
9079 /*
9080 * Array opcodes
9081 */
9086 guint32 field_token;
9107 }
9112 /* FIXME: we cannot get a managed
9113 allocator because we can't get the
9114 open generic class's vtable. We
9115 have the same problem in
9116 handle_alloc(). This
9117 needs to be solved so that we can
9118 have managed allocs of shared
9119 generic classes. */
9120 /*
9121 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
9122 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
9123 */
9126 /* FIXME: Decompose later to help abcrem */
9128 /* vtable */
9131 /* array len */
9136 else
9140 /* Decompose now to avoid problems with references to the domainvar */
9149 /* Decompose later since it is needed by abcrem */
9164 /* Needed so mono_emit_load_get_addr () gets called */
9166 }
9167 }
9174 /*
9175 * we inline/optimize the initialization sequence if possible.
9176 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
9177 * for small sizes open code the memcpy
9178 * ensure the rva field is big enough
9179 */
9180 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))) {
9185 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
9187 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
9190 }
9194 }
9197 }
9202 UNVERIFIED;
9208 /* This flag will be inherited by the decomposition */
9213 ip ++;
9221 UNVERIFIED;
9227 /* we need to make sure that this array is exactly the type it needs
9228 * to be for correctness. the wrappers are lax with their usage
9229 * so we need to ignore them here
9230 */
9235 }
9265 }
9266 else
9270 UNVERIFIED;
9277 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
9284 }
9288 else
9291 }
9314 }
9315 else
9319 UNVERIFIED;
9321 /* storing a NULL doesn't need any of the complex checks in stelemref */
9333 UNVERIFIED;
9335 UNVERIFIED;
9346 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
9353 }
9354 }
9358 else
9362 }
9377 }
9395 // FIXME:
9398 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9408 // FIXME:
9413 }
9414 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
9419 }
9434 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
9442 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
9443 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
9444 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
9450 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
9451 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
9452 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
9454 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
9455 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
9456 }
9457 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
9465 }
9467 gpointer handle;
9481 }
9484 }
9486 LOAD_ERROR;
9491 /* This case handles ldtoken
9492 of an open type, like for
9493 typeof(Gen<>). */
9496 /* If we get a MONO_TYPE_CLASS
9497 then we need to provide the
9498 open type, not an
9499 instantiation of it. */
9502 else
9508 else
9510 }
9520 else
9534 }
9555 /* Special case for static synchronized wrappers */
9556 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
9558 /* FIXME: n is not a normal token */
9561 }
9564 }
9567 }
9580 MONO_RGCTX_INFO_TYPE);
9589 }
9594 }
9598 }
9599 }
9604 }
9610 ip++;
9623 ip++;
9626 /*
9627 * Control will leave the method so empty the stack, otherwise
9628 * the next basic block will start with a nonempty stack.
9629 */
9631 sp--;
9632 }
9644 }
9646 /* empty the stack */
9648 sp--;
9649 }
9651 /*
9652 * If this leave statement is in a catch block, check for a
9653 * pending exception, and rethrow it if necessary.
9654 * We avoid doing this in runtime invoke wrappers, since those are called
9655 * by native code which excepts the wrapper to catch all exceptions.
9656 */
9660 /*
9661 * Use <= in the final comparison to handle clauses with multiple
9662 * leave statements, like in bug #78024.
9663 * The ordering of the exception clauses guarantees that we find the
9664 * innermost clause.
9665 */
9666 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) {
9670 /*
9671 MonoInst *load;
9673 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
9674 */
9680 /*
9681 * Currently, we always rethrow the abort exception, despite the
9682 * fact that this is not correct. See thread6.cs for an example.
9683 * But propagating the abort exception is more important than
9684 * getting the sematics right.
9685 */
9692 }
9693 }
9712 /*
9713 * Link the finally bblock with the target, since it will
9714 * conceptually branch there.
9715 * FIXME: Have to link the bblock containing the endfinally.
9716 */
9719 }
9720 }
9722 }
9733 else
9737 }
9739 /*
9740 * Mono specific opcodes
9741 */
9749 gpointer func;
9768 }
9770 gpointer ptr;
9777 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9787 /* Will be transformed into an AOTCONST later */
9792 }
9793 }
9794 /* FIXME: Generalize this */
9800 }
9805 /* Can't embed random pointers into AOT code */
9808 }
9811 gpointer ptr;
9825 }
9829 }
9836 // FIXME:
9842 }
9859 }
9872 /*
9873 * Similar to LDOBJ, but instead load the unmanaged
9874 * representation of the vtype to the stack.
9875 */
9884 {
9899 }
9902 /*
9903 * Same as RET, but return the native representation of a vtype
9904 * to the caller.
9905 */
9921 }
9925 UNVERIFIED;
9934 }
9945 else
9951 }
9954 #ifdef MONO_ARCH_HAVE_LMF_OPS
9958 #endif
9988 /* It would be easier to call a trampoline, but that would put an
9989 * extra frame on the stack, confusing exception handling. So
9990 * implement it inline using an opcode for now.
9991 */
9994 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9995 /* prevent it from being register allocated */
9997 }
9999 /* Has to use a call inst since it local regalloc expects it */
10007 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
10009 #endif
10015 }
10021 }
10025 }
10027 }
10033 /* somewhat similar to LDTOKEN */
10036 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
10047 }
10055 /*
10056 * The following transforms:
10057 * CEE_CEQ into OP_CEQ
10058 * CEE_CGT into OP_CGT
10059 * CEE_CGT_UN into OP_CGT_UN
10060 * CEE_CLT into OP_CLT
10061 * CEE_CLT_UN into OP_CLT_UN
10062 */
10071 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))))
10075 else
10083 /*
10084 * The backends expect the fceq opcodes to do the
10085 * comparison too.
10086 */
10090 }
10095 }
10105 LOAD_ERROR;
10114 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
10115 METHOD_ACCESS_FAILURE;
10119 INLINE_FAILURE;
10120 CHECK_CFG_EXCEPTION;
10123 }
10125 /*
10126 * Optimize the common case of ldftn+delegate creation
10127 */
10128 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
10129 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
10137 LOAD_ERROR;
10148 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
10149 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
10152 }
10153 }
10155 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
10156 /* FIXME: SGEN support */
10160 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
10161 sp --;
10163 CHECK_CFG_EXCEPTION;
10165 sp ++;
10167 }
10168 #endif
10169 }
10170 }
10179 }
10188 LOAD_ERROR;
10196 INLINE_FAILURE;
10197 CHECK_CFG_EXCEPTION;
10200 }
10210 else
10216 }
10243 UNVERIFIED;
10267 }
10273 }
10281 UNVERIFIED;
10290 UNVERIFIED;
10292 /*
10293 * Inlining this into a loop in a parent could lead to
10294 * stack overflows which is different behavior than the
10295 * non-inlined case, thus disable inlining in this case.
10296 */
10319 UNVERIFIED;
10331 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
10335 }
10336 }
10339 UNVERIFIED;
10342 }
10345 /* FIXME: record alignment? we can assume 1 for now */
10356 /* Can't inline tail calls at this time */
10369 else
10379 else
10390 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
10392 } 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)) {
10393 /* emit_memset only works when val == 0 */
10405 }
10406 }
10410 }
10417 /* we ignore the no-nullcheck for now since we
10418 * really do it explicitly only when doing callvirt->call
10419 */
10428 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
10431 }
10432 }
10451 }
10453 guint32 align;
10459 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic && !generic_context) {
10467 }
10472 }
10479 // FIXME:
10482 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
10484 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
10488 }
10499 UNVERIFIED;
10503 UNVERIFIED;
10504 }
10506 }
10509 UNVERIFIED;
10513 UNVERIFIED;
10514 }
10515 }
10517 UNVERIFIED;
10521 /* This could already be set because of inlining, #693905 */
10529 }
10539 }
10543 }
10546 }
10548 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
10550 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
10552 #endif
10587 }
10588 }
10589 }
10592 /* Emit initialization for ref vars */
10593 // FIXME: Avoid duplication initialization for IL locals.
10599 }
10600 }
10602 /* Add a sequence point for method entry/exit events */
10608 }
10620 }
10621 }
10629 /* Method is too large */
10637 }
10646 exception_exit:
10650 inline_failure:
10653 load_error:
10657 unverified:
10661 cleanup:
10667 }
10669 static int
10671 {
10685 }
10688 }
10692 int
10694 {
10756 #if defined(TARGET_X86) || defined (TARGET_AMD64)
10761 #endif
10762 #if defined(TARGET_AMD64)
10765 #endif
10776 }
10779 }
10781 static int
10783 {
10809 }
10812 }
10814 static int
10816 {
10835 }
10838 }
10840 int
10842 {
10843 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10844 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10856 #if SIZEOF_REGISTER == 8
10859 #endif
10860 }
10861 #endif
10864 }
10868 {
10869 #if defined(TARGET_X86)
10901 }
10902 #endif
10904 #if defined(TARGET_AMD64)
10905 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10956 }
10957 #endif
10960 }
10964 {
10965 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10973 }
10974 #endif
10977 }
10981 {
10982 #ifdef TARGET_X86
10983 /* FIXME: This has sign extension issues */
10984 /*
10985 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10986 return OP_X86_COMPARE_MEMBASE8_IMM;
10987 */
10989 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11001 }
11002 #endif
11004 #ifdef TARGET_AMD64
11005 /* FIXME: This has sign extension issues */
11006 /*
11007 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
11008 return OP_X86_COMPARE_MEMBASE8_IMM;
11009 */
11013 #ifdef __mono_ilp32__
11015 #else
11017 #endif
11020 /* FIXME: This only works for 32 bit immediates
11021 case OP_COMPARE_IMM:
11022 case OP_LCOMPARE_IMM:
11023 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
11024 return OP_AMD64_COMPARE_MEMBASE_IMM;
11025 */
11032 #ifdef __mono_ilp32__
11036 #else
11038 #endif
11045 }
11046 #endif
11049 }
11053 {
11054 #ifdef TARGET_X86
11055 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11072 }
11073 #endif
11075 #ifdef TARGET_AMD64
11076 #ifdef __mono_ilp32__
11077 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE) ) {
11078 #else
11080 #endif
11094 }
11095 #ifdef __mono_ilp32__
11097 #else
11099 #endif
11114 }
11115 }
11116 #endif
11119 }
11121 int
11123 {
11125 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
11130 #endif
11131 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
11137 #endif
11140 }
11141 }
11143 #ifndef DISABLE_JIT
11145 /**
11146 * mono_handle_global_vregs:
11147 *
11148 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
11149 * for them.
11150 */
11151 void
11153 {
11160 #ifdef MONO_ARCH_SIMD_INTRINSICS
11163 #endif
11165 /* Find local vregs used in more than one bb */
11177 gint32 prev_bb;
11207 }
11209 #if SIZEOF_REGISTER == 4
11210 /* In the LLVM case, the long opcodes are not decomposed */
11212 /*
11213 * Since some instructions reference the original long vreg,
11214 * and some reference the two component vregs, it is quite hard
11215 * to determine when it needs to be global. So be conservative.
11216 */
11218 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11222 }
11224 /*
11225 * Make the component vregs volatile since the optimizations can
11226 * get confused otherwise.
11227 */
11230 }
11231 #endif
11237 /* 0 is a valid block num */
11240 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
11250 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
11251 else
11255 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11258 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
11265 }
11266 }
11268 /* Flag as having been used in more than one bb */
11270 }
11271 }
11272 }
11273 }
11275 /* If a variable is used in only one bblock, convert it into a local vreg */
11286 #if SIZEOF_REGISTER == 8
11288 #endif
11289 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
11290 /* Enabling this screws up the fp stack on x86 */
11292 #endif
11293 /* Arguments are implicitly global */
11294 /* Putting R4 vars into registers doesn't work currently */
11295 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) {
11296 /*
11297 * Make that the variable's liveness interval doesn't contain a call, since
11298 * that would cause the lvreg to be spilled, making the whole optimization
11299 * useless.
11300 */
11301 /* This is too slow for JIT compilation */
11302 #if 0
11322 }
11323 }
11328 ins_index ++;
11329 }
11333 }
11334 #endif
11340 }
11342 }
11343 }
11345 /*
11346 * Compress the varinfo and vars tables so the liveness computation is faster and
11347 * takes up less space.
11348 */
11360 #if SIZEOF_REGISTER == 4
11362 /* Modify the two component vars too */
11369 }
11370 #endif
11371 }
11372 pos ++;
11373 }
11374 }
11378 }
11380 /**
11381 * mono_spill_global_vars:
11382 *
11383 * Generate spill code for variables which are not allocated to registers,
11384 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
11385 * code is generated which could be optimized by the local optimization passes.
11386 */
11387 void
11389 {
11405 /* FIXME: Move this function to mini.c */
11409 #ifdef MONO_ARCH_SIMD_INTRINSICS
11411 #endif
11413 #if SIZEOF_REGISTER == 4
11414 /* Create MonoInsts for longs */
11441 }
11444 }
11445 }
11446 }
11447 #endif
11450 /* registers need liveness info even for !non refs */
11456 }
11457 }
11459 /* FIXME: widening and truncation */
11461 /*
11462 * As an optimization, when a variable allocated to the stack is first loaded into
11463 * an lvreg, we will remember the lvreg and use it the next time instead of loading
11464 * the variable again.
11465 */
11471 /*
11472 * These arrays contain the first and last instructions accessing a given
11473 * variable.
11474 * Since we emit bblocks in the same order we process them here, and we
11475 * don't split live ranges, these will precisely describe the live range of
11476 * the variable, i.e. the instruction range where a valid value can be found
11477 * in the variables location.
11478 * The live range is computed using the liveness info computed by the liveness pass.
11479 * We can't use vmv->range, since that is an abstract live range, and we need
11480 * one which is instruction precise.
11481 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
11482 */
11483 /* FIXME: Only do this if debugging info is requested */
11489 /* Add spill loads/stores */
11496 /* Clear vreg_to_lvreg array */
11514 /*
11515 * We handle LDADDR here as well, since it can only be decomposed
11516 * when variable addresses are known.
11517 */
11522 /* Happens on SPARC/S390 where vtypes are passed by reference */
11527 }
11533 NOT_IMPLEMENTED;
11540 }
11544 }
11549 }
11551 /*
11552 * Store opcodes have destbasereg in the dreg, but in reality, it is an
11553 * src register.
11554 * FIXME:
11555 */
11569 else
11579 }
11581 /***************/
11582 /* DREG */
11583 /***************/
11585 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
11599 } 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)) {
11600 /*
11601 * Instead of emitting a load+store, use a _membase opcode.
11602 */
11612 }
11615 guint32 lvreg;
11621 /* Invalidate any previous lvreg for this vreg */
11629 }
11634 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
11636 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
11639 }
11643 /* Try to fuse the store into the instruction itself */
11644 /* FIXME: Add more instructions */
11645 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
11651 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
11669 // FIXME: The backends expect the base reg to be in inst_basereg
11676 /* printf ("INS: "); mono_print_ins (ins); */
11677 /* Create a store instruction */
11678 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
11680 /* Insert it after the instruction */
11685 /*
11686 * We can't assign ins->dreg to var->dreg here, since the
11687 * sregs could use it. So set a flag, and do it after
11688 * the sregs.
11689 */
11690 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)))
11692 }
11693 }
11694 }
11699 }
11707 }
11708 }
11710 /************/
11711 /* SREGS */
11712 /************/
11723 guint32 load_opcode;
11727 //mono_inst_set_src_registers (ins, sregs);
11731 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
11735 /* var->dreg is a hreg */
11738 }
11741 }
11752 /* The variable is already loaded to an lvreg */
11756 //mono_inst_set_src_registers (ins, sregs);
11758 }
11760 /* Try to fuse the load into the instruction */
11764 //mono_inst_set_src_registers (ins, sregs);
11769 //mono_inst_set_src_registers (ins, sregs);
11776 //printf ("%d ", srcindex); mono_print_ins (ins);
11780 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) {
11782 /*
11783 * sreg refers to the value loaded by the load
11784 * emitted below, but we need to use ins->dreg
11785 * since it refers to the store emitted earlier.
11786 */
11788 }
11793 }
11794 }
11797 //mono_inst_set_src_registers (ins, sregs);
11800 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
11802 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
11805 }
11807 #if SIZEOF_REGISTER == 4
11809 #endif
11813 }
11814 }
11819 }
11821 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
11827 }
11828 }
11829 }
11838 }
11844 }
11847 /* Clear vreg_to_lvreg array */
11854 }
11858 }
11860 /* Extend the live range based on the liveness info */
11866 /* The liveness info is incomplete */
11870 /* Live from at least the first ins of this bb */
11873 }
11876 /* Live at least until the last ins of this bb */
11879 }
11880 }
11881 }
11882 }
11884 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11885 /*
11886 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11887 * by storing the current native offset into MonoMethodVar->live_range_start/end.
11888 */
11899 }
11906 else
11908 }
11909 }
11910 }
11911 #endif
11917 }
11919 /**
11920 * FIXME:
11921 * - use 'iadd' instead of 'int_add'
11922 * - handling ovf opcodes: decompose in method_to_ir.
11923 * - unify iregs/fregs
11924 * -> partly done, the missing parts are:
11925 * - a more complete unification would involve unifying the hregs as well, so
11926 * code wouldn't need if (fp) all over the place. but that would mean the hregs
11927 * would no longer map to the machine hregs, so the code generators would need to
11928 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11929 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11930 * fp/non-fp branches speeds it up by about 15%.
11931 * - use sext/zext opcodes instead of shifts
11932 * - add OP_ICALL
11933 * - get rid of TEMPLOADs if possible and use vregs instead
11934 * - clean up usage of OP_P/OP_ opcodes
11935 * - cleanup usage of DUMMY_USE
11936 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11937 * stack
11938 * - set the stack type and allocate a dreg in the EMIT_NEW macros
11939 * - get rid of all the <foo>2 stuff when the new JIT is ready.
11940 * - make sure handle_stack_args () is called before the branch is emitted
11941 * - when the new IR is done, get rid of all unused stuff
11942 * - COMPARE/BEQ as separate instructions or unify them ?
11943 * - keeping them separate allows specialized compare instructions like
11944 * compare_imm, compare_membase
11945 * - most back ends unify fp compare+branch, fp compare+ceq
11946 * - integrate mono_save_args into inline_method
11947 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11948 * - handle long shift opts on 32 bit platforms somehow: they require
11949 * 3 sregs (2 for arg1 and 1 for arg2)
11950 * - make byref a 'normal' type.
11951 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11952 * variable if needed.
11953 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11954 * like inline_method.
11955 * - remove inlining restrictions
11956 * - fix LNEG and enable cfold of INEG
11957 * - generalize x86 optimizations like ldelema as a peephole optimization
11958 * - add store_mem_imm for amd64
11959 * - optimize the loading of the interruption flag in the managed->native wrappers
11960 * - avoid special handling of OP_NOP in passes
11961 * - move code inserting instructions into one function/macro.
11962 * - try a coalescing phase after liveness analysis
11963 * - add float -> vreg conversion + local optimizations on !x86
11964 * - figure out how to handle decomposed branches during optimizations, ie.
11965 * compare+branch, op_jump_table+op_br etc.
11966 * - promote RuntimeXHandles to vregs
11967 * - vtype cleanups:
11968 * - add a NEW_VARLOADA_VREG macro
11969 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11970 * accessing vtype fields.
11971 * - get rid of I8CONST on 64 bit platforms
11972 * - dealing with the increase in code size due to branches created during opcode
11973 * decomposition:
11974 * - use extended basic blocks
11975 * - all parts of the JIT
11976 * - handle_global_vregs () && local regalloc
11977 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11978 * - sources of increase in code size:
11979 * - vtypes
11980 * - long compares
11981 * - isinst and castclass
11982 * - lvregs not allocated to global registers even if used multiple times
11983 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11984 * meaningful.
11985 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11986 * - add all micro optimizations from the old JIT
11987 * - put tree optimizations into the deadce pass
11988 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11989 * specific function.
11990 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11991 * fcompare + branchCC.
11992 * - create a helper function for allocating a stack slot, taking into account
11993 * MONO_CFG_HAS_SPILLUP.
11994 * - merge r68207.
11995 * - merge the ia64 switch changes.
11996 * - optimize mono_regstate2_alloc_int/float.
11997 * - fix the pessimistic handling of variables accessed in exception handler blocks.
11998 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11999 * parts of the tree could be separated by other instructions, killing the tree
12000 * arguments, or stores killing loads etc. Also, should we fold loads into other
12001 * instructions if the result of the load is used multiple times ?
12002 * - make the REM_IMM optimization in mini-x86.c arch-independent.
12003 * - LAST MERGE: 108395.
12004 * - when returning vtypes in registers, generate IR and append it to the end of the
12005 * last bb instead of doing it in the epilog.
12006 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
12007 */
12009 /*
12011 NOTES
12012 -----
12014 - When to decompose opcodes:
12015 - earlier: this makes some optimizations hard to implement, since the low level IR
12016 no longer contains the neccessary information. But it is easier to do.
12017 - later: harder to implement, enables more optimizations.
12018 - Branches inside bblocks:
12019 - created when decomposing complex opcodes.
12020 - branches to another bblock: harmless, but not tracked by the branch
12021 optimizations, so need to branch to a label at the start of the bblock.
12022 - branches to inside the same bblock: very problematic, trips up the local
12023 reg allocator. Can be fixed by spitting the current bblock, but that is a
12024 complex operation, since some local vregs can become global vregs etc.
12025 - Local/global vregs:
12026 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
12027 local register allocator.
12028 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
12029 structure, created by mono_create_var (). Assigned to hregs or the stack by
12030 the global register allocator.
12031 - When to do optimizations like alu->alu_imm:
12032 - earlier -> saves work later on since the IR will be smaller/simpler
12033 - later -> can work on more instructions
12034 - Handling of valuetypes:
12035 - When a vtype is pushed on the stack, a new temporary is created, an
12036 instruction computing its address (LDADDR) is emitted and pushed on
12037 the stack. Need to optimize cases when the vtype is used immediately as in
12038 argument passing, stloc etc.
12039 - Instead of the to_end stuff in the old JIT, simply call the function handling
12040 the values on the stack before emitting the last instruction of the bb.
12041 */