| blob | dcfbb246eb4d2fd637e0ae883a513ebf3cab038c |
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/metadata/mono-basic-block.h>
65 #define BRANCH_COST 10
66 #define INLINE_LENGTH_LIMIT 20
67 #define INLINE_FAILURE do {\
68 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
69 goto inline_failure;\
70 } while (0)
71 #define CHECK_CFG_EXCEPTION do {\
72 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
73 goto exception_exit;\
74 } while (0)
75 #define METHOD_ACCESS_FAILURE do { \
76 char *method_fname = mono_method_full_name (method, TRUE); \
77 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
78 mono_cfg_set_exception (cfg, MONO_EXCEPTION_METHOD_ACCESS); \
79 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
80 g_free (method_fname); \
81 g_free (cil_method_fname); \
82 goto exception_exit; \
83 } while (0)
84 #define FIELD_ACCESS_FAILURE do { \
85 char *method_fname = mono_method_full_name (method, TRUE); \
86 char *field_fname = mono_field_full_name (field); \
87 mono_cfg_set_exception (cfg, MONO_EXCEPTION_FIELD_ACCESS); \
88 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
89 g_free (method_fname); \
90 g_free (field_fname); \
91 goto exception_exit; \
92 } while (0)
93 #define GENERIC_SHARING_FAILURE(opcode) do { \
94 if (cfg->generic_sharing_context) { \
95 if (cfg->verbose_level > 2) \
96 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__); \
97 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
98 goto exception_exit; \
99 } \
100 } while (0)
101 #define OUT_OF_MEMORY_FAILURE do { \
102 mono_cfg_set_exception (cfg, MONO_EXCEPTION_OUT_OF_MEMORY); \
103 goto exception_exit; \
104 } while (0)
105 /* Determine whenever 'ins' represents a load of the 'this' argument */
106 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
114 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
115 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
118 /* helper methods signatures */
127 /*
128 * Instruction metadata
129 */
130 #ifdef MINI_OP
131 #undef MINI_OP
132 #endif
133 #ifdef MINI_OP3
134 #undef MINI_OP3
135 #endif
137 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
143 #if SIZEOF_REGISTER == 8
144 #define LREG IREG
145 #else
147 #endif
148 /* keep in sync with the enum in mini.h */
149 const char
150 ins_info[] = {
152 };
153 #undef MINI_OP
154 #undef MINI_OP3
156 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
157 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
158 /*
159 * This should contain the index of the last sreg + 1. This is not the same
160 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
161 */
164 };
165 #undef MINI_OP
166 #undef MINI_OP3
168 #define MONO_INIT_VARINFO(vi,id) do { \
169 (vi)->range.first_use.pos.bid = 0xffff; \
170 (vi)->reg = -1; \
171 (vi)->idx = (id); \
172 } while (0)
174 void
176 {
180 }
182 guint32
184 {
186 }
188 guint32
190 {
192 }
194 guint32
196 {
198 }
200 guint32
202 {
204 }
206 /*
207 * mono_alloc_ireg_ref:
208 *
209 * Allocate an IREG, and mark it as holding a GC ref.
210 */
211 guint32
213 {
215 }
217 /*
218 * mono_alloc_ireg_mp:
219 *
220 * Allocate an IREG, and mark it as holding a managed pointer.
221 */
222 guint32
224 {
226 }
228 /*
229 * mono_alloc_ireg_copy:
230 *
231 * Allocate an IREG with the same GC type as VREG.
232 */
233 guint32
235 {
240 else
242 }
244 guint
246 {
250 handle_enum:
276 #if SIZEOF_REGISTER == 8
278 #else
280 #endif
289 }
304 }
306 }
308 void
310 {
323 }
325 void
327 {
335 }
337 /*
338 * Can't put this at the beginning, since other files reference stuff from this
339 * file.
340 */
341 #ifndef DISABLE_JIT
343 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
345 #define LOAD_ERROR do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto load_error; } while (0)
347 #define GET_BBLOCK(cfg,tblock,ip) do { \
348 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
349 if (!(tblock)) { \
350 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
351 NEW_BBLOCK (cfg, (tblock)); \
352 (tblock)->cil_code = (ip); \
353 ADD_BBLOCK (cfg, (tblock)); \
354 } \
355 } while (0)
357 #if defined(TARGET_X86) || defined(TARGET_AMD64)
358 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
359 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
360 (dest)->dreg = alloc_ireg_mp ((cfg)); \
361 (dest)->sreg1 = (sr1); \
362 (dest)->sreg2 = (sr2); \
363 (dest)->inst_imm = (imm); \
364 (dest)->backend.shift_amount = (shift); \
365 MONO_ADD_INS ((cfg)->cbb, (dest)); \
366 } while (0)
367 #endif
369 #if SIZEOF_REGISTER == 8
370 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
372 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
373 MonoInst *widen; \
374 int dr = alloc_preg (cfg); \
375 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
376 (ins)->sreg2 = widen->dreg; \
377 } \
378 } while (0)
379 #else
380 #define ADD_WIDEN_OP(ins, arg1, arg2)
381 #endif
383 #define ADD_BINOP(op) do { \
384 MONO_INST_NEW (cfg, ins, (op)); \
385 sp -= 2; \
386 ins->sreg1 = sp [0]->dreg; \
387 ins->sreg2 = sp [1]->dreg; \
388 type_from_op (ins, sp [0], sp [1]); \
389 CHECK_TYPE (ins); \
391 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
392 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
393 MONO_ADD_INS ((cfg)->cbb, (ins)); \
394 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
395 } while (0)
397 #define ADD_UNOP(op) do { \
398 MONO_INST_NEW (cfg, ins, (op)); \
399 sp--; \
400 ins->sreg1 = sp [0]->dreg; \
401 type_from_op (ins, sp [0], NULL); \
402 CHECK_TYPE (ins); \
403 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
404 MONO_ADD_INS ((cfg)->cbb, (ins)); \
405 *sp++ = mono_decompose_opcode (cfg, ins); \
406 } while (0)
408 #define ADD_BINCOND(next_block) do { \
409 MonoInst *cmp; \
410 sp -= 2; \
411 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
412 cmp->sreg1 = sp [0]->dreg; \
413 cmp->sreg2 = sp [1]->dreg; \
414 type_from_op (cmp, sp [0], sp [1]); \
415 CHECK_TYPE (cmp); \
416 type_from_op (ins, sp [0], sp [1]); \
417 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
418 GET_BBLOCK (cfg, tblock, target); \
419 link_bblock (cfg, bblock, tblock); \
420 ins->inst_true_bb = tblock; \
421 if ((next_block)) { \
422 link_bblock (cfg, bblock, (next_block)); \
423 ins->inst_false_bb = (next_block); \
424 start_new_bblock = 1; \
425 } else { \
426 GET_BBLOCK (cfg, tblock, ip); \
427 link_bblock (cfg, bblock, tblock); \
428 ins->inst_false_bb = tblock; \
429 start_new_bblock = 2; \
430 } \
431 if (sp != stack_start) { \
432 handle_stack_args (cfg, stack_start, sp - stack_start); \
433 CHECK_UNVERIFIABLE (cfg); \
434 } \
435 MONO_ADD_INS (bblock, cmp); \
436 MONO_ADD_INS (bblock, ins); \
437 } while (0)
439 /* *
440 * link_bblock: Links two basic blocks
441 *
442 * links two basic blocks in the control flow graph, the 'from'
443 * argument is the starting block and the 'to' argument is the block
444 * the control flow ends to after 'from'.
445 */
446 static void
448 {
452 #if 0
455 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
456 else
461 else
463 }
464 #endif
471 }
472 }
477 }
481 }
488 }
489 }
494 }
498 }
499 }
501 void
503 {
505 }
507 /**
508 * mono_find_block_region:
509 *
510 * We mark each basic block with a region ID. We use that to avoid BB
511 * optimizations when blocks are in different regions.
512 *
513 * Returns:
514 * A region token that encodes where this region is, and information
515 * about the clause owner for this block.
516 *
517 * The region encodes the try/catch/filter clause that owns this block
518 * as well as the type. -1 is a special value that represents a block
519 * that is in none of try/catch/filter.
520 */
521 static int
523 {
530 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
539 else
541 }
545 }
548 }
552 {
564 }
565 }
567 }
569 static void
571 {
579 /* prevent it from being register allocated */
583 }
585 MonoInst *
587 {
589 }
593 {
601 /* prevent it from being register allocated */
607 }
609 /*
610 * Returns the type used in the eval stack when @type is loaded.
611 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
612 */
613 void
615 {
622 }
624 handle_enum:
668 }
678 /* FIXME: all the arguments must be references for now,
679 * later look inside cfg and see if the arg num is
680 * really a reference
681 */
687 }
688 }
690 /*
691 * The following tables are used to quickly validate the IL code in type_from_op ().
692 */
693 static const char
703 };
705 static const char
706 neg_table [] = {
708 };
710 /* reduce the size of this table */
711 static const char
721 };
723 static const char
725 /* Inv i L p F & O vt */
734 };
736 /* reduce the size of this table */
737 static const char
747 };
749 /*
750 * Tables to map from the non-specific opcode to the matching
751 * type-specific opcode.
752 */
753 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
754 static const guint16
757 };
759 /* handles from CEE_NEG to CEE_CONV_U8 */
760 static const guint16
763 };
765 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
766 static const guint16
768 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
769 };
771 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
772 static const guint16
774 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
775 };
777 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
778 static const guint16
780 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
781 };
783 /* handles from CEE_BEQ to CEE_BLT_UN */
784 static const guint16
786 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
787 };
789 /* handles from CEE_CEQ to CEE_CLT_UN */
790 static const guint16
792 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
793 };
795 /*
796 * Sets ins->type (the type on the eval stack) according to the
797 * type of the opcode and the arguments to it.
798 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
799 *
800 * FIXME: this function sets ins->type unconditionally in some cases, but
801 * it should set it to invalid for some types (a conv.x on an object)
802 */
803 static void
807 /* binops */
813 /* FIXME: check unverifiable args for STACK_MP */
835 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
839 else
844 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
870 /* unops */
878 else
899 }
932 #if SIZEOF_VOID_P == 8
934 #else
936 #endif
944 }
1012 }
1016 }
1018 static const char
1019 ldind_type [] = {
1020 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1021 };
1023 #if 0
1025 static const char
1028 };
1030 static int
1042 }
1043 args++;
1044 }
1065 }
1078 }
1079 /*if (!param_table [args [i].type] [sig->params [i]->type])
1080 return 0;*/
1081 }
1083 }
1084 #endif
1086 /*
1087 * When we need a pointer to the current domain many times in a method, we
1088 * call mono_domain_get() once and we store the result in a local variable.
1089 * This function returns the variable that represents the MonoDomain*.
1090 */
1093 {
1097 }
1099 /*
1100 * The got_var contains the address of the Global Offset Table when AOT
1101 * compiling.
1102 */
1103 MonoInst *
1105 {
1106 #ifdef MONO_ARCH_NEED_GOT_VAR
1111 }
1113 #else
1115 #endif
1116 }
1120 {
1125 /* force the var to be stack allocated */
1127 }
1130 }
1145 }
1147 }
1151 {
1186 else
1191 }
1194 }
1198 {
1232 }
1234 }
1236 /*
1237 * We try to share variables when possible
1238 */
1241 {
1245 /* inlining can result in deeper stacks */
1265 }
1267 }
1269 static void
1271 {
1272 /*
1273 * Don't use this if a generic_context is set, since that means AOT can't
1274 * look up the method using just the image+token.
1275 * table == 0 means this is a reference made from a wrapper.
1276 */
1278 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1282 }
1283 }
1285 /*
1286 * This function is called to handle items that are left on the evaluation stack
1287 * at basic block boundaries. What happens is that we save the values to local variables
1288 * and we reload them later when first entering the target basic block (with the
1289 * handle_loaded_temps () function).
1290 * A single joint point will use the same variables (stored in the array bb->out_stack or
1291 * bb->in_stack, if the basic block is before or after the joint point).
1292 *
1293 * This function needs to be called _before_ emitting the last instruction of
1294 * the bb (i.e. before emitting a branch).
1295 * If the stack merge fails at a join point, cfg->unverifiable is set.
1296 */
1297 static void
1299 {
1304 gboolean found;
1312 //printf ("bblock %d has out:", bb->block_num);
1316 /* exception handlers are linked, but they should not be considered for stack args */
1319 //printf (" %d", outb->block_num);
1324 }
1325 }
1326 //printf ("\n");
1330 /*
1331 * try to reuse temps already allocated for this purpouse, if they occupy the same
1332 * stack slot and if they are of the same type.
1333 * This won't cause conflicts since if 'local' is used to
1334 * store one of the values in the in_stack of a bblock, then
1335 * the same variable will be used for the same outgoing stack
1336 * slot as well.
1337 * This doesn't work when inlining methods, since the bblocks
1338 * in the inlined methods do not inherit their in_stack from
1339 * the bblock they are inlined to. See bug #58863 for an
1340 * example.
1341 */
1344 else
1346 }
1347 }
1348 }
1352 /* exception handlers are linked, but they should not be considered for stack args */
1359 }
1361 }
1364 }
1374 }
1376 /*
1377 * It is possible that the out bblocks already have in_stack assigned, and
1378 * the in_stacks differ. In this case, we will store to all the different
1379 * in_stacks.
1380 */
1385 /* Find a bblock which has a different in_stack */
1389 /* exception handlers are linked, but they should not be considered for stack args */
1391 bindex++;
1393 }
1401 }
1405 }
1406 bindex ++;
1407 }
1408 }
1409 }
1411 /* Emit code which loads interface_offsets [klass->interface_id]
1412 * The array is stored in memory before vtable.
1413 */
1414 static void
1415 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1416 {
1424 }
1426 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1427 }
1428 }
1430 static void
1431 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1432 {
1434 #ifdef COMPRESSED_INTERFACE_BITMAP
1442 else
1446 #else
1461 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1467 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1468 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1469 }
1470 #endif
1471 }
1473 /*
1474 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1475 * stored in "klass_reg" implements the interface "klass".
1476 */
1477 static void
1478 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1479 {
1480 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1481 }
1483 /*
1484 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1485 * stored in "vtable_reg" implements the interface "klass".
1486 */
1487 static void
1488 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1489 {
1490 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1491 }
1493 /*
1494 * Emit code which checks whenever the interface id of @klass is smaller than
1495 * than the value given by max_iid_reg.
1496 */
1497 static void
1500 {
1505 }
1506 else
1510 else
1512 }
1514 /* Same as above, but obtains max_iid from a vtable */
1515 static void
1518 {
1521 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1523 }
1525 /* Same as above, but obtains max_iid from a klass */
1526 static void
1529 {
1532 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1534 }
1536 static void
1537 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1538 {
1544 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1547 }
1548 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1558 }
1560 }
1562 static void
1563 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1564 {
1566 }
1568 static void
1569 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1570 {
1578 else
1580 }
1582 /*
1583 * Variant of the above that takes a register to the class, not the vtable.
1584 */
1585 static void
1586 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1587 {
1595 else
1597 }
1600 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1601 {
1610 }
1612 }
1616 {
1618 }
1621 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1622 {
1629 }
1631 }
1633 static void
1634 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1636 static void
1637 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1638 {
1644 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1647 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1648 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1652 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1655 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1662 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1664 }
1667 /* Check that the object is a vector too */
1672 }
1679 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1682 }
1683 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1686 }
1687 }
1689 static void
1690 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1691 {
1693 }
1695 static void
1697 {
1716 #if SIZEOF_REGISTER == 8
1720 #endif
1721 }
1722 }
1728 else
1732 /* This could be optimized further if neccesary */
1737 }
1739 }
1741 #if !NO_UNALIGNED_ACCESS
1747 }
1752 }
1753 }
1754 #endif
1760 }
1765 }
1770 }
1771 }
1773 void
1774 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1775 {
1781 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1785 /* This could be optimized further if neccesary */
1793 }
1794 }
1796 #if !NO_UNALIGNED_ACCESS
1805 }
1806 }
1807 #endif
1816 }
1824 }
1832 }
1833 }
1835 static int
1836 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1837 {
1841 handle_enum:
1885 }
1887 }
1889 /*
1890 * target_type_is_incompatible:
1891 * @cfg: MonoCompile context
1892 *
1893 * Check that the item @arg on the evaluation stack can be stored
1894 * in the target type (can be a local, or field, etc).
1895 * The cfg arg can be used to check if we need verification or just
1896 * validity checks.
1897 *
1898 * Returns: non-0 value if arg can't be stored on a target.
1899 */
1900 static int
1902 {
1907 /* FIXME: check that the pointed to types match */
1913 }
1931 /* STACK_MP is needed when setting pinned locals */
1938 /*
1939 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
1940 * in native int. (#688008).
1941 */
1952 /* FIXME: check type compatibility */
1989 /* FIXME: check type compatibility */
1991 }
1994 /* FIXME: all the arguments must be references for now,
1995 * later look inside cfg and see if the arg num is
1996 * really a reference
1997 */
2004 }
2006 }
2008 /*
2009 * Prepare arguments for passing to a function call.
2010 * Return a non-zero value if the arguments can't be passed to the given
2011 * signature.
2012 * The type checks are not yet complete and some conversions may need
2013 * casts on 32 or 64 bit architectures.
2014 *
2015 * FIXME: implement this using target_type_is_incompatible ()
2016 */
2017 static int
2019 {
2026 args++;
2027 }
2033 }
2036 handle_enum:
2056 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2081 }
2096 }
2097 }
2099 }
2101 static int
2103 {
2117 }
2120 }
2122 static int
2124 {
2138 }
2141 }
2143 #ifdef MONO_ARCH_HAVE_IMT
2144 static void
2146 {
2162 }
2164 #ifdef ENABLE_LLVM
2166 #endif
2167 #ifdef MONO_ARCH_IMT_REG
2169 #else
2170 /* Need this to keep the IMT arg alive */
2172 #endif
2174 }
2176 #ifdef MONO_ARCH_IMT_REG
2189 }
2192 #else
2194 #endif
2195 }
2196 #endif
2200 {
2208 }
2213 {
2215 #ifdef MONO_ARCH_SOFT_FLOAT
2217 #endif
2221 else
2222 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2233 //g_assert_not_reached ();
2234 }
2241 /*
2242 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2243 * address of return value to increase optimization opportunities.
2244 * Before vtype decomposition, the dreg of the call ins itself represents the
2245 * fact the call modifies the return value. After decomposition, the call will
2246 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2247 * will be transformed into an LDADDR.
2248 */
2252 /* We reference the call too since call->dreg could change during optimization */
2262 #ifdef MONO_ARCH_SOFT_FLOAT
2264 /*
2265 * If the call has a float argument, we would need to do an r8->r4 conversion using
2266 * an icall, but that cannot be done during the call sequence since it would clobber
2267 * the call registers + the stack. So we do it before emitting the call.
2268 */
2275 else
2286 /* The result will be in an int vreg */
2288 }
2289 }
2290 }
2291 #endif
2293 #ifdef ENABLE_LLVM
2296 else
2298 #else
2300 #endif
2306 }
2308 static void
2310 {
2311 #ifdef MONO_ARCH_RGCTX_REG
2315 #ifdef ENABLE_LLVM
2317 #endif
2318 #else
2319 NOT_IMPLEMENTED;
2320 #endif
2321 }
2324 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2325 {
2332 }
2344 }
2347 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2354 {
2355 gboolean might_be_remote;
2365 }
2368 /* Create the real signature */
2369 /* FIXME: Cache these */
2374 }
2387 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2390 }
2396 else
2406 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2407 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2412 /* Make a call to delegate->invoke_impl */
2418 /* We must emit a dummy use here because the delegate trampoline will
2419 replace the 'this' argument with the delegate target making this activation
2420 no longer a root for the delegate.
2421 This is an issue for delegates that target collectible code such as dynamic
2422 methods of GC'able assemblies.
2424 For a test case look into #667921.
2426 FIXME: a dummy use is not the best way to do it as the local register allocator
2427 will put it on a caller save register and spil it around the call.
2428 Ideally, we would either put it on a callee save register or only do the store part.
2429 */
2433 }
2434 #endif
2441 /*
2442 * the method is not virtual, we just need to ensure this is not null
2443 * and then we can call the method directly.
2444 */
2446 /*
2447 * The check above ensures method is not gshared, this is needed since
2448 * gshared methods can't have wrappers.
2449 */
2451 }
2458 /*
2459 * the method is virtual, but we can statically dispatch since either
2460 * it's class or the method itself are sealed.
2461 * But first we need to ensure it's not a null reference.
2462 */
2470 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2473 #ifdef MONO_ARCH_HAVE_IMT
2479 }
2480 #endif
2485 }
2490 #ifdef MONO_ARCH_HAVE_IMT
2494 }
2495 #endif
2496 }
2500 }
2501 }
2509 }
2511 MonoInst*
2513 {
2514 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL, NULL);
2515 }
2517 MonoInst*
2520 {
2531 }
2533 MonoInst*
2535 {
2541 }
2543 /*
2544 * mono_emit_abs_call:
2545 *
2546 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2547 */
2551 {
2555 /*
2556 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2557 * handle it.
2558 */
2565 }
2569 {
2574 /*
2575 * Native code might return non register sized integers
2576 * without initializing the upper bits.
2577 */
2593 }
2602 }
2603 }
2604 }
2607 }
2611 {
2617 }
2619 }
2621 static void
2622 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
2623 {
2640 }
2641 }
2642 }
2644 static void
2646 {
2648 gpointer card_table_mask;
2662 #ifdef MONO_ARCH_HAVE_CARD_TABLE_WBARRIER
2664 #endif
2673 else
2685 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
2686 * IMM's larger than 32bits.
2687 */
2695 }
2702 }
2710 }
2711 }
2713 static gboolean
2714 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
2715 {
2722 /*types with references can't have alignment smaller than sizeof(void*) */
2726 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
2732 /* We don't unroll more than 5 stores to avoid code bloat. */
2734 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
2742 }
2751 /*tmp = dreg*/
2765 /*tmp += sizeof (void*)*/
2769 }
2770 }
2772 /* Those cannot be references since size < sizeof (void*) */
2778 }
2785 }
2792 }
2795 }
2797 /*
2798 * Emit code to copy a valuetype of type @klass whose address is stored in
2799 * @src->dreg to memory whose address is stored at @dest->dreg.
2800 */
2801 void
2802 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2803 {
2810 /*
2811 * This check breaks with spilled vars... need to handle it during verification anyway.
2812 * g_assert (klass && klass == src->klass && klass == dest->klass);
2813 */
2817 else
2820 /* if native is true there should be no references in the struct */
2822 /* Avoid barriers when storing to the stack */
2833 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
2834 if ((cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
2844 }
2845 }
2849 }
2850 }
2853 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2862 }
2863 }
2867 {
2873 }
2875 }
2877 void
2879 {
2882 guint32 align;
2885 /* FIXME: Optimize this for the case when dest is an LDADDR */
2892 }
2899 }
2900 }
2904 {
2937 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2939 }
2947 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2949 }
2950 }
2953 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2954 {
2964 }
2968 {
2969 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2970 }
2975 {
2976 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);
2980 }
2982 /*
2983 * emit_get_rgctx_method:
2984 *
2985 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2986 * normal constants, else emit a load from the rgctx.
2987 */
2991 {
3004 }
3006 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);
3010 }
3011 }
3016 {
3017 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);
3021 }
3023 /*
3024 * On return the caller must check @klass for load errors.
3025 */
3026 static void
3028 {
3045 }
3048 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
3049 else
3050 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
3051 #ifdef MONO_ARCH_VTABLE_REG
3054 #else
3055 NOT_IMPLEMENTED;
3056 #endif
3057 }
3059 static void
3061 {
3071 }
3077 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3079 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3080 }
3081 }
3083 static void
3085 {
3086 /* Reset the variables holding the cast details */
3091 /* It is enough to reset the from field */
3092 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3093 }
3094 }
3096 /*
3097 * On return the caller must check @array_class for load errors
3098 */
3099 static void
3101 {
3110 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3121 }
3142 }
3143 }
3148 }
3150 /**
3151 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3152 * generic code is generated.
3153 */
3156 {
3162 /* FIXME: What if the class is shared? We might not
3163 have to get the address of the method from the
3164 RGCTX. */
3166 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3173 }
3174 }
3178 {
3187 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3188 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3190 /* FIXME: generics */
3193 // Check rank == 0
3198 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3203 /* This assertion is from the unboxcast insn */
3215 }
3217 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
3223 }
3225 /*
3226 * Returns NULL and set the cfg exception on error.
3227 */
3230 {
3239 /*
3240 FIXME: we cannot get managed_alloc here because we can't get
3241 the class's vtable (because it's not a closed class)
3243 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3244 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3245 */
3249 else
3260 }
3263 }
3270 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3271 /* This happens often in argument checking code, eg. throw new FooException... */
3272 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3278 gboolean pass_lw;
3284 }
3286 #ifndef MONO_CROSS_COMPILE
3288 #endif
3293 }
3300 }
3303 }
3304 }
3307 }
3309 /*
3310 * Returns NULL and set the cfg exception on error.
3311 */
3314 {
3321 /* FIXME: What if the class is shared? We might not
3322 have to get the method address from the RGCTX. */
3324 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3330 }
3331 }
3337 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3340 }
3343 static gboolean
3344 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
3345 {
3358 }
3362 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
3367 }
3369 }
3371 // FIXME: This doesn't work yet (class libs tests fail?)
3372 #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)
3374 /*
3375 * Returns NULL and set the cfg exception on error.
3376 */
3379 {
3394 /* obj */
3397 /* klass - it's the second element of the cache entry*/
3398 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3400 /* cache */
3404 }
3409 /* Complex case, handle by an icall */
3411 /* obj */
3414 /* klass */
3419 /* Simple case, handled by the code below */
3420 }
3421 }
3438 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3439 /* the remoting code is broken, access the class for now */
3440 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3446 }
3451 }
3456 }
3457 }
3464 }
3466 /*
3467 * Returns NULL and set the cfg exception on error.
3468 */
3471 {
3488 /* obj */
3491 /* klass - it's the second element of the cache entry*/
3492 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
3494 /* cache */
3498 }
3503 /* Complex case, handle by an icall */
3505 /* obj */
3508 /* klass */
3513 /* Simple case, the code below can handle it */
3514 }
3515 }
3521 /* Do the assignment at the beginning, so the other assignment can be if converted */
3533 /* the is_null_bb target simply copies the input register to the output */
3543 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3547 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3551 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3555 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3565 /* Check that the object is a vector too */
3570 }
3572 /* the is_null_bb target simply copies the input register to the output */
3574 }
3578 /* the is_null_bb target simply copies the input register to the output */
3581 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3583 /* the remoting code is broken, access the class for now */
3584 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3590 }
3595 }
3600 /* the is_null_bb target simply copies the input register to the output */
3602 }
3603 }
3604 }
3616 }
3620 {
3621 /* This opcode takes as input an object reference and a class, and returns:
3622 0) if the object is an instance of the class,
3623 1) if the object is not instance of the class,
3624 2) if the object is a proxy whose type cannot be determined */
3651 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3654 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3662 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3664 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3665 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3668 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3678 }
3696 /* FIXME: */
3702 }
3706 {
3707 /* This opcode takes as input an object reference and a class, and returns:
3708 0) if the object is an instance of the class,
3709 1) if the object is a proxy whose type cannot be determined
3710 an InvalidCastException exception is thrown otherwhise*/
3738 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3750 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3753 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3754 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3757 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3773 }
3781 /* FIXME: */
3787 }
3789 /*
3790 * Returns NULL and set the cfg exception on error.
3791 */
3793 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3794 {
3806 /* Inline the contents of mono_delegate_ctor */
3808 /* Set target field */
3809 /* Optimize away setting of NULL target */
3811 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3814 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target));
3816 }
3817 }
3819 /* Set method field */
3821 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3824 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method));
3826 }
3827 /*
3828 * To avoid looking up the compiled code belonging to the target method
3829 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3830 * store it, and we fill it after the method has been compiled.
3831 */
3836 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3846 }
3850 }
3851 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3852 }
3854 /* Set invoke_impl field */
3860 }
3861 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3863 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3866 }
3870 {
3873 /* Need to register the icall so it gets an icall wrapper */
3878 /* mono_array_new_va () needs a vararg calling convention */
3881 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3883 }
3885 static void
3887 {
3896 /* Add it to the start of the first bblock */
3900 }
3901 else
3906 /*
3907 * Add a dummy use to keep the got_var alive, since real uses might
3908 * only be generated by the back ends.
3909 * Add it to end_bblock, so the variable's lifetime covers the whole
3910 * method.
3911 * It would be better to make the usage of the got var explicit in all
3912 * cases when the backend needs it (i.e. calls, throw etc.), so this
3913 * wouldn't be needed.
3914 */
3917 }
3922 static gboolean
3924 {
3925 MonoMethodHeaderSummary header;
3927 #ifdef MONO_ARCH_SOFT_FLOAT
3930 #endif
3938 #ifdef MONO_ARCH_HAVE_LMF_OPS
3943 #endif
3949 /*runtime, icall and pinvoke are checked by summary call*/
3956 /* also consider num_locals? */
3957 /* Do the size check early to avoid creating vtables */
3961 else
3964 }
3968 /*
3969 * if we can initialize the class of the method right away, we do,
3970 * otherwise we don't allow inlining if the class needs initialization,
3971 * since it would mean inserting a call to mono_runtime_class_init()
3972 * inside the inlined code
3973 */
3977 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3979 /* No vtable created yet */
3984 /* This makes so that inline cannot trigger */
3985 /* .cctors: too many apps depend on them */
3986 /* running with a specific order... */
3990 }
3993 /* No vtable created yet */
4000 }
4002 /*
4003 * If we're compiling for shared code
4004 * the cctor will need to be run at aot method load time, for example,
4005 * or at the end of the compilation of the inlining method.
4006 */
4007 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
4009 }
4011 /*
4012 * CAS - do not inline methods with declarative security
4013 * Note: this has to be before any possible return TRUE;
4014 */
4018 #ifdef MONO_ARCH_SOFT_FLOAT
4019 /* FIXME: */
4025 #endif
4028 }
4030 static gboolean
4032 {
4043 /* The initialization is already done before the method is called */
4047 }
4050 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4051 {
4053 guint32 size;
4063 #if SIZEOF_REGISTER == 8
4064 /* The array reg is 64 bits but the index reg is only 32 */
4066 /* Not needed */
4071 }
4072 #else
4078 }
4079 #endif
4084 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4088 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
4093 }
4094 #endif
4106 }
4108 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4110 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4111 {
4125 guint32 size;
4133 /* range checking */
4164 }
4165 #endif
4168 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
4169 {
4180 #ifndef MONO_ARCH_EMULATE_MUL_DIV
4181 /* emit_ldelema_2 depends on OP_LMUL */
4184 }
4185 #endif
4192 }
4194 static MonoBreakPolicy
4196 {
4198 }
4202 /**
4203 * mono_set_break_policy:
4204 * policy_callback: the new callback function
4205 *
4206 * Allow embedders to decide wherther to actually obey breakpoint instructions
4207 * (both break IL instructions and Debugger.Break () method calls), for example
4208 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4209 * untrusted or semi-trusted code.
4210 *
4211 * @policy_callback will be called every time a break point instruction needs to
4212 * be inserted with the method argument being the method that calls Debugger.Break()
4213 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4214 * if it wants the breakpoint to not be effective in the given method.
4215 * #MONO_BREAK_POLICY_ALWAYS is the default.
4216 */
4217 void
4219 {
4222 else
4224 }
4226 static gboolean
4238 }
4239 }
4241 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
4243 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4244 {
4248 /* the bounds check is already done by the callers */
4256 }
4258 }
4261 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4262 {
4264 #ifdef MONO_ARCH_SIMD_INTRINSICS
4269 }
4270 #endif
4273 }
4276 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4277 {
4292 #if SIZEOF_REGISTER == 8
4293 /* The array reg is 64 bits but the index reg is only 32 */
4295 #else
4297 #endif
4300 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4301 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
4303 /* Avoid a warning */
4307 #else
4312 #endif
4317 /* Decompose later to allow more optimizations */
4329 /* The corlib functions check for oob already. */
4332 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4341 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4342 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4346 #if !defined(MONO_ARCH_EMULATE_MUL_DIV)
4356 #endif
4367 #ifndef MONO_BIG_ARRAYS
4368 /*
4369 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
4370 * Array methods.
4371 */
4372 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
4385 /* Non-szarray case */
4389 else
4394 /* Szarray case */
4398 else
4406 }
4407 #endif
4448 }
4451 /* FIXME this should be integrated to the check below once we support the trampoline version */
4452 #if defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4456 /*FIXME fix LLVM and AOT support*/
4460 /* Avoid infinite recursion */
4461 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN && !strcmp (cfg->method->name, "FastMonitorEnterV4"))
4469 }
4470 #endif
4472 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4477 /*
4478 * Pass the argument normally, the LLVM backend will handle the
4479 * calling convention problems.
4480 */
4481 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4487 }
4494 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4500 }
4503 }
4504 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4507 /* Avoid infinite recursion */
4520 #endif
4526 #if SIZEOF_REGISTER == 8
4528 /* 64 bit reads are already atomic */
4534 }
4535 #endif
4537 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4544 #if SIZEOF_REGISTER == 8
4547 #endif
4561 }
4568 #if SIZEOF_REGISTER == 8
4571 #endif
4585 }
4591 #if SIZEOF_REGISTER == 8
4594 #endif
4604 }
4605 }
4608 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4610 guint32 opcode;
4615 #if SIZEOF_REGISTER == 8
4619 #else
4622 #endif
4623 else
4646 }
4650 }
4653 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4680 /* g_assert_not_reached (); */
4681 }
4684 }
4694 else
4698 }
4701 #ifdef TARGET_WIN32
4703 #else
4705 #endif
4707 }
4709 /*
4710 * There is general branches code for Min/Max, but it does not work for
4711 * all inputs:
4712 * http://everything2.com/?node_id=1051618
4713 */
4714 }
4716 #ifdef MONO_ARCH_SIMD_INTRINSICS
4721 }
4722 #endif
4725 }
4727 /*
4728 * This entry point could be used later for arbitrary method
4729 * redirection.
4730 */
4734 {
4736 /* managed string allocation support */
4737 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
4743 #ifndef MONO_CROSS_COMPILE
4745 #endif
4751 }
4752 }
4754 }
4756 static void
4758 {
4763 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4765 /*
4766 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4767 * would be different than the MonoInst's used to represent arguments, and
4768 * the ldelema implementation can't deal with that.
4769 * Solution: When ldelema is used on an inline argument, create a var for
4770 * it, emit ldelema on that var, and emit the saving code below in
4771 * inline_method () if needed.
4772 */
4775 /* This uses cfg->args [i] which is set by the preceeding line */
4778 sp++;
4779 }
4780 }
4782 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4783 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4785 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4786 static gboolean
4788 {
4797 else
4799 }
4807 //return (strncmp_result <= 0);
4811 }
4812 }
4813 #endif
4815 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4816 static gboolean
4818 {
4828 }
4829 }
4837 //return (strncmp_result <= 0);
4841 }
4842 }
4843 #endif
4845 static int
4846 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4848 {
4856 guint prev_real_offset;
4861 guint32 prev_cil_offset_to_bb_len;
4868 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4871 #endif
4872 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4875 #endif
4878 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4883 }
4885 /* allocate local variables */
4898 }
4900 /*Must verify before creating locals as it can cause the JIT to assert.*/
4904 }
4906 /* allocate space to store the return value */
4909 }
4916 /* allocate start and end blocks */
4917 /* This is needed so if the inline is aborted, we can clean up */
4944 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
4964 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4968 /* always add some code to avoid block split failures */
4975 /*
4976 * Get rid of the begin and end bblocks if possible to aid local
4977 * optimizations.
4978 */
4981 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4988 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4991 }
4994 }
4997 /*
4998 * If the inlined method contains only a throw, then the ret var is not
4999 * set, so set it to a dummy value.
5000 */
5028 }
5029 }
5033 }
5042 /* This gets rid of the newly added bblocks */
5044 }
5047 }
5049 /*
5050 * Some of these comments may well be out-of-date.
5051 * Design decisions: we do a single pass over the IL code (and we do bblock
5052 * splitting/merging in the few cases when it's required: a back jump to an IL
5053 * address that was not already seen as bblock starting point).
5054 * Code is validated as we go (full verification is still better left to metadata/verify.c).
5055 * Complex operations are decomposed in simpler ones right away. We need to let the
5056 * arch-specific code peek and poke inside this process somehow (except when the
5057 * optimizations can take advantage of the full semantic info of coarse opcodes).
5058 * All the opcodes of the form opcode.s are 'normalized' to opcode.
5059 * MonoInst->opcode initially is the IL opcode or some simplification of that
5060 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
5061 * opcode with value bigger than OP_LAST.
5062 * At this point the IR can be handed over to an interpreter, a dumb code generator
5063 * or to the optimizing code generator that will translate it to SSA form.
5064 *
5065 * Profiling directed optimizations.
5066 * We may compile by default with few or no optimizations and instrument the code
5067 * or the user may indicate what methods to optimize the most either in a config file
5068 * or through repeated runs where the compiler applies offline the optimizations to
5069 * each method and then decides if it was worth it.
5070 */
5072 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
5073 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
5074 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
5075 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
5076 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
5077 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
5078 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
5079 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; LOAD_ERROR;}
5081 /* offset from br.s -> br like opcodes */
5082 #define BIG_BRANCH_OFFSET 13
5084 static gboolean
5086 {
5090 }
5092 static int
5093 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
5094 {
5098 guint cli_addr;
5106 UNVERIFIED;
5110 ip++;
5145 guint32 j;
5155 }
5157 }
5164 }
5169 /* Find the start of the bblock containing the throw */
5173 bb_start --;
5174 }
5177 }
5178 }
5180 unverified:
5183 }
5186 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5187 {
5196 }
5199 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
5200 {
5203 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
5207 }
5211 {
5216 else
5221 }
5223 /*
5224 * Returns TRUE if the JIT should abort inlining because "callee"
5225 * is influenced by security attributes.
5226 */
5227 static
5229 {
5230 guint32 result;
5234 }
5241 /* Generate code to throw a SecurityException before the actual call/link */
5249 /* don't hide previous results */
5253 }
5256 }
5260 {
5266 }
5269 }
5271 static void
5273 {
5279 }
5281 /*
5282 * Return the original method is a wrapper is specified. We can only access
5283 * the custom attributes from the original method.
5284 */
5287 {
5291 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
5295 /* in other cases we need to find the original method */
5297 }
5299 static void
5300 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
5302 {
5303 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5304 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
5307 }
5309 static void
5310 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
5312 {
5313 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5314 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
5317 }
5319 /*
5320 * Check that the IL instructions at ip are the array initialization
5321 * sequence and return the pointer to the data and the size.
5322 */
5324 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
5325 {
5326 /*
5327 * newarr[System.Int32]
5328 * dup
5329 * ldtoken field valuetype ...
5330 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5331 */
5336 guint32 rva;
5341 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
5352 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
5359 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5360 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5370 #ifdef ARM_FPU_FPA
5372 #endif
5376 #endif
5379 }
5384 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5389 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5390 /* for aot code we do the lookup on load */
5394 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5397 }
5399 }
5401 }
5403 static void
5405 {
5412 else
5415 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5419 }
5421 static void
5423 {
5427 }
5429 static gboolean
5431 {
5433 }
5435 static void
5437 {
5442 /* Optimize reg-reg moves away */
5443 /*
5444 * Can't optimize other opcodes, since sp[0] might point to
5445 * the last ins of a decomposed opcode.
5446 */
5450 }
5451 }
5453 /*
5454 * ldloca inhibits many optimizations so try to get rid of it in common
5455 * cases.
5456 */
5459 {
5469 }
5471 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5474 /* From the INITOBJ case */
5484 }
5488 }
5489 load_error:
5491 }
5493 static gboolean
5495 {
5500 }
5502 }
5504 /*
5505 * is_jit_optimizer_disabled:
5506 *
5507 * Determine whenever M's assembly has a DebuggableAttribute with the
5508 * IsJITOptimizerDisabled flag set.
5509 */
5510 static gboolean
5512 {
5524 klass = mono_class_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggableAttribute");
5526 /* Linked away */
5531 }
5543 /* Decode the attribute. See reflection.c */
5549 // FIXME: Support named parameters
5551 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
5553 /* Two boolean arguments */
5554 p ++;
5556 }
5558 }
5565 }
5567 static gboolean
5568 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig)
5569 {
5570 gboolean supported_tail_call;
5573 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
5574 supported_tail_call = MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
5575 #else
5576 supported_tail_call = mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
5577 #endif
5580 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
5581 /* These can point to the current method's stack */
5583 }
5585 /* this might point to the current method's stack */
5594 /* Debugging support */
5595 #if 0
5598 count ++;
5604 }
5605 }
5606 #endif
5609 }
5611 /* the JIT intercepts ldflda instructions to the tlsdata field in ThreadLocal<T> and redirects
5612 * it to the thread local value based on the tls_offset field. Every other kind of access to
5613 * the field causes an assert.
5614 */
5615 static gboolean
5617 {
5623 }
5625 /* emits the code needed to access a managed tls var (like ThreadStatic)
5626 * with the value of the tls offset in offset_reg. thread_ins represents the MonoInternalThread
5627 * pointer for the current thread.
5628 * Returns the MonoInst* representing the address of the tls var.
5629 */
5632 {
5636 // inlined access to the tls data
5637 // idx = (offset >> 24) - 1;
5638 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
5640 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
5653 }
5655 /*
5656 * redirect access to the tlsdata field to the tls var given by the tls_offset field.
5657 * this address is cached per-method in cached_tls_addr.
5658 */
5660 create_magic_tls_access (MonoCompile *cfg, MonoClassField *tls_field, MonoInst **cached_tls_addr, MonoInst *thread_local)
5661 {
5668 }
5672 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, offset_field->type, thread_local->dreg, offset_field->offset);
5677 thread_method = mono_class_get_method_from_name (mono_get_thread_class(), "CurrentInternalThread_internal", 0);
5679 }
5683 *cached_tls_addr = temp = mono_compile_create_var (cfg, type_from_stack_type (addr), OP_LOCAL);
5688 }
5690 /*
5691 * mono_method_to_ir:
5692 *
5693 * Translate the .net IL into linear IR.
5694 */
5695 int
5696 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5699 {
5700 MonoError error;
5720 guint num_args;
5723 MonoDeclSecurityActions actions;
5728 gboolean disable_inline;
5733 /* serialization and xdomain stuff may need access to private fields and methods */
5743 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5758 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
5759 }
5761 }
5773 /*
5774 * Methods without init_locals set could cause asserts in various passes
5775 * (#497220).
5776 */
5783 }
5785 /* SkipVerification is not allowed if core-clr is enabled */
5789 }
5806 }
5814 }
5816 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5837 /* ENTRY BLOCK */
5842 #if defined(__native_client_codegen__)
5846 #endif
5848 /* EXIT BLOCK */
5861 }
5862 /* handle exception clauses */
5886 /* finally clauses already have a seq point */
5889 }
5891 /* todo: is a fault block unsafe to optimize? */
5894 }
5897 /*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);
5898 while (p < end) {
5899 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5900 }*/
5901 /* catch and filter blocks get the exception object on the stack */
5906 /* mostly like handle_stack_args (), but just sets the input args */
5907 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5912 /*
5913 * Add a dummy use for the exvar so its liveness info will be
5914 * correct.
5915 */
5925 /* The filter block shares the exvar with the handler block */
5929 }
5930 }
5936 /*
5937 * In shared generic code with catch
5938 * clauses containing type variables
5939 * the exception handling code has to
5940 * be able to get to the rgctx.
5941 * Therefore we have to make sure that
5942 * the vtable/mrgctx argument (for
5943 * static or generic methods) or the
5944 * "this" argument (for non-static
5945 * methods) are live.
5946 */
5955 }
5956 }
5957 }
5963 }
5965 /* FIRST CODE BLOCK */
5978 }
5979 }
5985 /* at this point having security doesn't mean we have any code to generate */
5987 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5988 * And we do not want to enter the next section (with allocation) if we
5989 * have nothing to generate */
5991 }
5993 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
6000 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
6003 }
6011 }
6014 }
6016 /* not a P/Invoke after all */
6018 }
6019 }
6021 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
6022 /* we use a separate basic block for the initialization code */
6035 }
6037 /* at this point we know, if security is TRUE, that some code needs to be generated */
6044 /* Add code for SecurityAction.Demand */
6047 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6049 }
6051 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
6052 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
6055 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
6057 }
6059 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
6062 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
6064 }
6065 }
6067 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
6070 }
6073 /* check if this is native code, e.g. an icall or a p/invoke */
6080 /* if this ia a native call then it can only be JITted from platform code */
6086 }
6087 }
6088 }
6089 }
6090 }
6093 UNVERIFIED;
6097 UNVERIFIED;
6098 }
6105 UNVERIFIED;
6106 }
6109 /* We force the vtable variable here for all shared methods
6110 for the possibility that they might show up in a stack
6111 trace where their exact instantiation is needed. */
6118 /* FIXME: Is there a better way to do this?
6119 We need the variable live for the duration
6120 of the whole method. */
6122 }
6123 }
6125 /* add a check for this != NULL to inlined methods */
6132 }
6139 UNVERIFIED;
6140 }
6142 }
6144 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
6145 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
6153 else
6165 }
6175 }
6186 }
6195 }
6198 }
6199 }
6217 }
6221 }
6222 }
6223 /*
6224 * Sequence points are points where the debugger can place a breakpoint.
6225 * Currently, we generate these automatically at points where the IL
6226 * stack is empty.
6227 */
6231 }
6239 /* TODO: Use an increment here */
6240 #if defined(TARGET_X86)
6245 #else
6248 #endif
6249 }
6252 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
6258 else
6260 ip++;
6266 else
6268 ip++;
6279 ip++;
6290 ip++;
6302 UNVERIFIED;
6307 }
6334 UNVERIFIED;
6357 }
6363 }
6370 UNVERIFIED;
6433 #ifdef TARGET_POWERPC
6434 /* FIXME: Clean this up */
6437 #endif
6439 /* FIXME: we should really allocate this only late in the compilation process */
6459 }
6465 }
6470 #ifdef TARGET_POWERPC
6471 /* FIXME: Clean this up */
6474 #endif
6476 /* FIXME: we should really allocate this only late in the compilation process */
6496 }
6502 }
6507 sp--;
6522 }
6525 ip++;
6528 #ifdef TARGET_X86
6530 /* we need to pop the value from the x86 FP stack */
6532 #endif
6537 INLINE_FAILURE;
6541 UNVERIFIED;
6543 /* FIXME: check the signature matches */
6547 LOAD_ERROR;
6553 CHECK_CFG_EXCEPTION;
6555 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6556 {
6560 /* Handle tail calls similarly to calls */
6574 }
6575 #else
6577 /* Prevent arguments from being optimized away */
6584 #endif
6589 }
6616 else
6624 /*
6625 * This is a call through a function pointer using a pinvoke
6626 * signature. Have to create a wrapper and call that instead.
6627 * FIXME: This is very slow, need to create a wrapper at JIT time
6628 * instead based on the signature.
6629 */
6634 }
6646 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_call, generic_context);
6647 }
6652 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6653 /*
6654 * This is needed since get_method_constrained can't find
6655 * the method in klass representing a type var.
6656 * The type var is guaranteed to be a reference type in this
6657 * case.
6658 */
6663 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6664 }
6668 }
6671 LOAD_ERROR;
6675 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6676 }
6679 METHOD_ACCESS_FAILURE;
6680 }
6686 /* MS.NET seems to silently convert this to a callvirt */
6689 {
6690 /*
6691 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
6692 * converts to a callvirt.
6693 *
6694 * tests/bug-515884.il is an example of this behavior
6695 */
6696 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
6698 if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
6700 }
6704 LOAD_ERROR;
6714 LOAD_ERROR;
6724 }
6725 }
6733 INLINE_FAILURE;
6734 CHECK_CFG_EXCEPTION;
6735 }
6739 }
6742 UNVERIFIED;
6749 //g_assert (!virtual || fsig->hasthis);
6754 /*
6755 * We have the `constrained.' prefix opcode.
6756 */
6758 /*
6759 * The type parameter is instantiated as a valuetype,
6760 * but that type doesn't override the method we're
6761 * calling, so we need to box `this'.
6762 */
6765 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
6766 CHECK_CFG_EXCEPTION;
6770 /*
6771 * The type parameter is instantiated as a reference
6772 * type. We have a managed pointer on the stack, so
6773 * we need to dereference it here.
6774 */
6781 }
6784 UNVERIFIED;
6786 /*
6787 * If the callee is a shared method, then its static cctor
6788 * might not get called after the call was patched.
6789 */
6790 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)) {
6793 }
6801 /*
6802 * Pass vtable iff target method might
6803 * be shared, which means that sharing
6804 * is enabled for its class and its
6805 * context is sharable (and it's not a
6806 * generic method).
6807 */
6811 }
6823 }
6831 /* Generic method interface
6832 calls are resolved via a
6833 helper function and don't
6834 need an imt. */
6837 }
6839 /*
6840 * If a shared method calls another
6841 * shared method then the caller must
6842 * have a generic sharing context
6843 * because the magic trampoline
6844 * requires it. FIXME: We shouldn't
6845 * have to force the vtable/mrgctx
6846 * variable here. Instead there
6847 * should be a flag in the cfg to
6848 * request a generic sharing context.
6849 */
6853 }
6863 }
6864 }
6870 /*
6871 * emit_get_rgctx_method () calls mono_class_vtable () so check
6872 * for type load errors before.
6873 */
6876 }
6880 /* !marshalbyref is needed to properly handle generic methods + remoting */
6887 }
6888 }
6896 }
6901 /* Calling virtual generic methods */
6912 /* Prevent inlining of methods that contain indirect calls */
6913 INLINE_FAILURE;
6915 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
6924 #endif
6925 {
6930 /* FIXME: This should be a managed pointer */
6943 }
6948 CHECK_CFG_EXCEPTION;
6953 }
6955 /*
6956 * Implement a workaround for the inherent races involved in locking:
6957 * Monitor.Enter ()
6958 * try {
6959 * } finally {
6960 * Monitor.Exit ()
6961 * }
6962 * If a thread abort happens between the call to Monitor.Enter () and the start of the
6963 * try block, the Exit () won't be executed, see:
6964 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
6965 * To work around this, we extend such try blocks to include the last x bytes
6966 * of the Monitor.Enter () call.
6967 */
6968 if (cmethod && cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
6972 /*
6973 * Only extend try blocks with a finally, to avoid catching exceptions thrown
6974 * from Monitor.Enter like ArgumentNullException.
6975 */
6977 /* Mark this bblock as needing to be extended */
6979 }
6980 }
6982 /* Conversion to a JIT intrinsic */
6983 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6988 sp++;
6989 }
6991 CHECK_CFG_EXCEPTION;
6996 }
6998 /* Inlining */
7000 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
7008 /* Prevent inlining of methods that call wrappers */
7009 INLINE_FAILURE;
7012 }
7014 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, always))) {
7020 /* *sp is already set by inline_method */
7021 sp++;
7026 }
7027 }
7031 /* Tail recursion elimination */
7032 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
7036 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7037 INLINE_FAILURE;
7039 /* keep it simple */
7043 }
7055 /* skip the CEE_RET, too */
7058 else
7063 }
7064 }
7066 /* Generic sharing */
7067 /* FIXME: only do this for generic methods if
7068 they are not shared! */
7074 INLINE_FAILURE;
7079 /*
7080 * We are compiling a call to a
7081 * generic method from shared code,
7082 * which means that we have to look up
7083 * the method in the rgctx and do an
7084 * indirect call.
7085 */
7086 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
7087 }
7089 /* Indirect calls */
7097 else
7098 /* FIXME: what the hell is this??? */
7102 /* Prevent inlining of methods with indirect calls */
7103 INLINE_FAILURE;
7109 /*
7110 * Instead of emitting an indirect call, emit a direct call
7111 * with the contents of the aotconst as the patch info.
7112 */
7113 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
7115 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
7116 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
7120 }
7121 }
7125 CHECK_CFG_EXCEPTION;
7130 }
7132 /* Array methods */
7146 }
7149 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
7150 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
7168 }
7170 CHECK_CFG_EXCEPTION;
7175 }
7182 CHECK_CFG_EXCEPTION;
7187 }
7189 /* Tail prefix / tail call optimization */
7191 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
7192 /* FIXME: runtime generic context pointer for jumps? */
7193 /* FIXME: handle this for generic sharing eventually */
7197 && !vtable_arg && !cfg->generic_sharing_context && is_supported_tail_call (cfg, method, cmethod, fsig);
7202 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
7203 INLINE_FAILURE;
7205 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7207 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
7208 /* Handle tail calls similarly to calls */
7209 call = mono_emit_call_args (cfg, mono_method_signature (cmethod), sp, FALSE, FALSE, TRUE, FALSE);
7210 #else
7216 /*
7217 * We implement tail calls by storing the actual arguments into the
7218 * argument variables, then emitting a CEE_JMP.
7219 */
7221 /* Prevent argument from being register allocated */
7224 }
7225 #endif
7234 CHECK_CFG_EXCEPTION;
7239 // FIXME: Eliminate unreachable epilogs
7241 /*
7242 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
7243 * only reachable from this call.
7244 */
7249 }
7251 /* Common call */
7252 INLINE_FAILURE;
7259 CHECK_CFG_EXCEPTION;
7264 }
7267 /* return from inlined method */
7268 /*
7269 * If in_count == 0, that means the ret is unreachable due to
7270 * being preceeded by a throw. In that case, inline_method () will
7271 * handle setting the return value
7272 * (test case: test_0_inline_throw ()).
7273 */
7278 //g_assert (returnvar != -1);
7281 }
7287 /*
7288 * Place a seq point here too even through the IL stack is not
7289 * empty, so a step over on
7290 * call <FOO>
7291 * ret
7292 * will work correctly.
7293 */
7296 }
7302 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7303 UNVERIFIED;
7317 }
7319 #ifdef MONO_ARCH_SOFT_FLOAT
7329 }
7330 #else
7332 #endif
7333 }
7334 }
7335 }
7337 UNVERIFIED;
7339 ip++;
7348 ip++;
7358 }
7376 ip++;
7378 ip++;
7388 ip++;
7399 }
7418 UNVERIFIED;
7419 ip ++;
7423 sp--;
7433 }
7440 #if SIZEOF_REGISTER == 4
7442 /* Convert it to OP_LCOMPARE */
7450 }
7451 #endif
7467 }
7481 ip++;
7499 gboolean use_op_switch;
7507 UNVERIFIED;
7522 }
7525 /*
7526 * Link the current bb with the targets as well, so handle_stack_args
7527 * will set their in_stack correctly.
7528 */
7536 }
7550 #ifdef TARGET_ARM
7551 /* ARM implements SWITCH statements differently */
7552 /* FIXME: Make it use the generic implementation */
7555 #endif
7572 else
7575 #if SIZEOF_REGISTER == 8
7576 /* The upper word might not be zero, and we add it to a 64 bit address later */
7578 #endif
7588 }
7590 /* FIXME: Use load_memindex */
7594 }
7598 }
7626 }
7652 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)))
7670 /* Use the immediate opcodes if possible */
7679 }
7680 }
7685 ip++;
7710 /* FIXME: Pass opcode to is_inst_imm */
7712 /* Use the immediate opcodes if possible */
7713 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)) {
7720 #if SIZEOF_REGISTER == 8
7722 #else
7725 #endif
7726 }
7727 else
7731 /* Might be followed by an instruction added by ADD_WIDEN_OP */
7734 }
7735 }
7739 ip++;
7756 /* Special case this earlier so we have long constants in the IR */
7761 #if SIZEOF_REGISTER == 8
7764 else
7766 #else
7770 else
7772 #endif
7774 }
7777 }
7778 ip++;
7792 }
7793 ip++;
7805 }
7806 ip++;
7824 CHECK_CFG_EXCEPTION;
7825 ip++;
7835 ip++;
7860 }
7875 /* Optimize the common ldobj+stloc combination */
7890 }
7900 }
7902 /* Optimize the ldobj+stobj combination */
7903 /* The reference case ends up being a load+store anyway */
7904 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7907 sp --;
7914 }
7923 }
7933 }
7945 }
7956 /*
7957 * Avoid relocations in AOT and save some space by using a
7958 * version of helper_ldstr specialized to mscorlib.
7959 */
7963 /* Avoid creating the string object */
7967 }
7968 }
7969 else
7974 }
7980 OUT_OF_MEMORY_FAILURE;
7984 }
7985 }
7986 }
7988 sp++;
7994 MonoInst this_ins;
8002 LOAD_ERROR;
8005 LOAD_ERROR;
8010 LOAD_ERROR;
8017 INLINE_FAILURE;
8018 CHECK_CFG_EXCEPTION;
8021 }
8023 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)) {
8026 }
8045 }
8046 }
8047 }
8052 /*
8053 * Generate smaller code for the common newobj <exception> instruction in
8054 * argument checking code.
8055 */
8082 }
8087 }
8089 /* move the args to allow room for 'this' in the first position */
8093 }
8095 /* check_call_signature () requires sp[0] to be set */
8099 UNVERIFIED;
8109 /* Avoid varargs in the common case */
8116 else
8121 /* we simply pass a null pointer */
8123 /* now call the string ctor */
8135 /*
8136 * The code generated by mini_emit_virtual_call () expects
8137 * iargs [0] to be a boxed instance, but luckily the vcall
8138 * will be transformed into a normal call there.
8139 */
8148 /*
8149 * TypeInitializationExceptions thrown from the mono_runtime_class_init
8150 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
8151 * As a workaround, we call class cctors before allocating objects.
8152 */
8153 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8154 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8156 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
8158 }
8162 }
8168 /* Now call the actual ctor */
8169 /* Avoid virtual calls to ctors if possible */
8174 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8178 sp++;
8179 }
8181 CHECK_CFG_EXCEPTION;
8188 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
8194 INLINE_FAILURE;
8196 }
8207 INLINE_FAILURE;
8210 }
8211 }
8214 /* Valuetype */
8218 }
8219 else
8225 }
8234 UNVERIFIED;
8239 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8243 /* obj */
8246 /* klass */
8249 /* inline cache*/
8252 else
8255 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8259 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8269 CHECK_CFG_EXCEPTION;
8279 }
8282 CHECK_CFG_EXCEPTION;
8286 }
8296 UNVERIFIED;
8301 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8305 /* obj */
8308 /* klass */
8311 /* inline cache*/
8314 else
8320 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8330 CHECK_CFG_EXCEPTION;
8340 }
8343 CHECK_CFG_EXCEPTION;
8347 }
8349 }
8364 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
8365 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
8369 /* obj */
8372 /* klass */
8375 /* inline cache*/
8376 /*FIXME AOT support*/
8379 else
8382 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
8386 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
8396 CHECK_CFG_EXCEPTION;
8407 CHECK_CFG_EXCEPTION;
8411 }
8413 }
8420 }
8422 /* UNBOX */
8428 /* LDOBJ */
8434 }
8455 }
8458 UNVERIFIED;
8460 UNVERIFIED;
8461 /* frequent check in generic code: box (struct), brtrue */
8463 // FIXME: LLVM can't handle the inconsistent bb linking
8477 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8479 }
8485 ip++;
8487 ip++;
8492 ip++;
8498 }
8500 /*
8501 * We need to link both bblocks, since it is needed for handling stack
8502 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
8503 * Branching to only one of them would lead to inconsistencies, so
8504 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
8505 */
8516 }
8525 /* The JIT can't eliminate the iconst+compare */
8529 }
8533 }
8537 CHECK_CFG_EXCEPTION;
8541 }
8565 }
8569 }
8575 guint foffset;
8583 }
8585 UNVERIFIED;
8587 UNVERIFIED;
8593 }
8596 }
8598 LOAD_ERROR;
8600 FIELD_ACCESS_FAILURE;
8604 UNVERIFIED;
8605 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
8606 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
8607 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8608 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8609 */
8614 UNVERIFIED;
8615 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8629 CHECK_CFG_EXCEPTION;
8638 }
8648 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)) {
8649 /* insert call to write barrier */
8656 }
8659 }
8663 }
8665 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8666 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
8672 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
8676 CHECK_CFG_EXCEPTION;
8688 }
8693 /* Have to compute the address of the variable */
8698 else
8703 }
8713 }
8721 }
8732 }
8733 }
8737 }
8743 gboolean is_special_static;
8752 }
8753 else
8756 LOAD_ERROR;
8759 FIELD_ACCESS_FAILURE;
8761 /* if the class is Critical then transparent code cannot access it's fields */
8765 /*
8766 * We can only support shared generic static
8767 * field access on architectures where the
8768 * trampoline code has been extended to handle
8769 * the generic class init.
8770 */
8771 #ifndef MONO_ARCH_VTABLE_REG
8773 #endif
8782 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8783 * to be called here.
8784 */
8788 }
8796 /* Generate IR to compute the field address */
8797 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
8798 /*
8799 * Fast access to TLS data
8800 * Inline version of get_thread_static_data () in
8801 * threads.c.
8802 */
8803 guint32 offset;
8807 // offset &= 0x7fffffff;
8808 // idx = (offset >> 24) - 1;
8809 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
8814 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
8819 /* For TLS variables, this will return the TLS offset */
8842 }
8855 }
8860 /*
8861 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8862 method->klass->name_space, method->klass->name, method->name,
8863 depth, field->offset);
8864 */
8869 /*
8870 * The pointer we're computing here is
8871 *
8872 * super_info.static_data + field->offset
8873 */
8882 }
8897 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8899 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8901 }
8905 /* This makes so that inline cannot trigger */
8906 /* .cctors: too many apps depend on them */
8907 /* running with a specific order... */
8909 INLINE_FAILURE;
8914 }
8915 }
8916 }
8921 else
8927 }
8928 }
8930 /* Generate IR to do the actual load/store operation */
8939 sp--;
8950 }
8957 }
8958 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8964 sp++;
8968 sp++;
8973 sp++;
8977 sp++;
8982 sp++;
8986 sp++;
8994 sp++;
9004 sp++;
9007 }
9012 sp++;
9020 }
9021 }
9032 }
9033 }
9037 }
9045 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
9049 /* insert call to write barrier */
9051 }
9057 /*
9058 * Array opcodes
9059 */
9064 guint32 field_token;
9085 }
9090 /* FIXME: we cannot get a managed
9091 allocator because we can't get the
9092 open generic class's vtable. We
9093 have the same problem in
9094 handle_alloc(). This
9095 needs to be solved so that we can
9096 have managed allocs of shared
9097 generic classes. */
9098 /*
9099 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
9100 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
9101 */
9104 /* FIXME: Decompose later to help abcrem */
9106 /* vtable */
9109 /* array len */
9114 else
9118 /* Decompose now to avoid problems with references to the domainvar */
9127 /* Decompose later since it is needed by abcrem */
9142 /* Needed so mono_emit_load_get_addr () gets called */
9144 }
9145 }
9152 /*
9153 * we inline/optimize the initialization sequence if possible.
9154 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
9155 * for small sizes open code the memcpy
9156 * ensure the rva field is big enough
9157 */
9158 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))) {
9163 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
9165 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
9168 }
9172 }
9175 }
9180 UNVERIFIED;
9186 /* This flag will be inherited by the decomposition */
9191 ip ++;
9199 UNVERIFIED;
9205 /* we need to make sure that this array is exactly the type it needs
9206 * to be for correctness. the wrappers are lax with their usage
9207 * so we need to ignore them here
9208 */
9213 }
9243 }
9244 else
9248 UNVERIFIED;
9255 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
9262 }
9266 else
9269 }
9292 }
9293 else
9297 UNVERIFIED;
9299 /* storing a NULL doesn't need any of the complex checks in stelemref */
9311 UNVERIFIED;
9313 UNVERIFIED;
9324 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
9331 }
9332 }
9336 else
9340 }
9355 }
9373 // FIXME:
9376 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9386 // FIXME:
9391 }
9392 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
9397 }
9412 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
9420 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
9421 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
9422 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
9428 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
9429 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
9430 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
9432 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
9433 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
9434 }
9435 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
9443 }
9445 gpointer handle;
9459 }
9462 }
9464 LOAD_ERROR;
9469 /* This case handles ldtoken
9470 of an open type, like for
9471 typeof(Gen<>). */
9474 /* If we get a MONO_TYPE_CLASS
9475 then we need to provide the
9476 open type, not an
9477 instantiation of it. */
9480 else
9486 else
9488 }
9498 else
9512 }
9533 /* Special case for static synchronized wrappers */
9534 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
9536 /* FIXME: n is not a normal token */
9539 }
9542 }
9545 }
9558 MONO_RGCTX_INFO_TYPE);
9567 }
9572 }
9576 }
9577 }
9582 }
9588 ip++;
9601 ip++;
9604 /*
9605 * Control will leave the method so empty the stack, otherwise
9606 * the next basic block will start with a nonempty stack.
9607 */
9609 sp--;
9610 }
9622 }
9624 /* empty the stack */
9626 sp--;
9627 }
9629 /*
9630 * If this leave statement is in a catch block, check for a
9631 * pending exception, and rethrow it if necessary.
9632 * We avoid doing this in runtime invoke wrappers, since those are called
9633 * by native code which excepts the wrapper to catch all exceptions.
9634 */
9638 /*
9639 * Use <= in the final comparison to handle clauses with multiple
9640 * leave statements, like in bug #78024.
9641 * The ordering of the exception clauses guarantees that we find the
9642 * innermost clause.
9643 */
9644 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) {
9648 /*
9649 MonoInst *load;
9651 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
9652 */
9658 /*
9659 * Currently, we always rethrow the abort exception, despite the
9660 * fact that this is not correct. See thread6.cs for an example.
9661 * But propagating the abort exception is more important than
9662 * getting the sematics right.
9663 */
9670 }
9671 }
9690 /*
9691 * Link the finally bblock with the target, since it will
9692 * conceptually branch there.
9693 * FIXME: Have to link the bblock containing the endfinally.
9694 */
9697 }
9698 }
9700 }
9711 else
9715 }
9717 /*
9718 * Mono specific opcodes
9719 */
9727 gpointer func;
9746 }
9748 gpointer ptr;
9755 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9765 /* Will be transformed into an AOTCONST later */
9770 }
9771 }
9772 /* FIXME: Generalize this */
9778 }
9783 /* Can't embed random pointers into AOT code */
9786 }
9789 gpointer ptr;
9803 }
9807 }
9814 // FIXME:
9820 }
9837 }
9850 /*
9851 * Similar to LDOBJ, but instead load the unmanaged
9852 * representation of the vtype to the stack.
9853 */
9862 {
9877 }
9880 /*
9881 * Same as RET, but return the native representation of a vtype
9882 * to the caller.
9883 */
9899 }
9903 UNVERIFIED;
9912 }
9923 else
9929 }
9932 #ifdef MONO_ARCH_HAVE_LMF_OPS
9936 #endif
9966 /* It would be easier to call a trampoline, but that would put an
9967 * extra frame on the stack, confusing exception handling. So
9968 * implement it inline using an opcode for now.
9969 */
9972 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9973 /* prevent it from being register allocated */
9975 }
9977 /* Has to use a call inst since it local regalloc expects it */
9985 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
9987 #endif
9993 }
9997 }
9999 }
10005 /* somewhat similar to LDTOKEN */
10008 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
10019 }
10027 /*
10028 * The following transforms:
10029 * CEE_CEQ into OP_CEQ
10030 * CEE_CGT into OP_CGT
10031 * CEE_CGT_UN into OP_CGT_UN
10032 * CEE_CLT into OP_CLT
10033 * CEE_CLT_UN into OP_CLT_UN
10034 */
10043 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))))
10047 else
10055 /*
10056 * The backends expect the fceq opcodes to do the
10057 * comparison too.
10058 */
10062 }
10067 }
10077 LOAD_ERROR;
10086 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
10087 METHOD_ACCESS_FAILURE;
10091 INLINE_FAILURE;
10092 CHECK_CFG_EXCEPTION;
10095 }
10097 /*
10098 * Optimize the common case of ldftn+delegate creation
10099 */
10100 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
10101 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
10109 LOAD_ERROR;
10120 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
10121 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
10124 }
10125 }
10127 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
10128 /* FIXME: SGEN support */
10132 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
10133 sp --;
10135 CHECK_CFG_EXCEPTION;
10137 sp ++;
10139 }
10140 #endif
10141 }
10142 }
10151 }
10160 LOAD_ERROR;
10168 INLINE_FAILURE;
10169 CHECK_CFG_EXCEPTION;
10172 }
10182 else
10188 }
10215 UNVERIFIED;
10239 }
10245 }
10253 UNVERIFIED;
10262 UNVERIFIED;
10264 /*
10265 * Inlining this into a loop in a parent could lead to
10266 * stack overflows which is different behavior than the
10267 * non-inlined case, thus disable inlining in this case.
10268 */
10291 UNVERIFIED;
10303 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
10307 }
10308 }
10311 UNVERIFIED;
10314 }
10317 /* FIXME: record alignment? we can assume 1 for now */
10328 /* Can't inline tail calls at this time */
10341 else
10351 else
10362 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
10364 } 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)) {
10365 /* emit_memset only works when val == 0 */
10377 }
10378 }
10382 }
10389 /* we ignore the no-nullcheck for now since we
10390 * really do it explicitly only when doing callvirt->call
10391 */
10400 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
10403 }
10404 }
10423 }
10425 guint32 align;
10431 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic && !generic_context) {
10439 }
10444 }
10451 // FIXME:
10454 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
10456 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
10460 }
10471 UNVERIFIED;
10475 UNVERIFIED;
10476 }
10478 }
10481 UNVERIFIED;
10485 UNVERIFIED;
10486 }
10487 }
10489 UNVERIFIED;
10502 }
10506 }
10509 }
10511 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
10513 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
10515 #endif
10550 }
10551 }
10552 }
10555 /* Emit initialization for ref vars */
10556 // FIXME: Avoid duplication initialization for IL locals.
10562 }
10563 }
10565 /* Add a sequence point for method entry/exit events */
10571 }
10583 }
10584 }
10592 /* Method is too large */
10600 }
10609 exception_exit:
10613 inline_failure:
10616 load_error:
10620 unverified:
10624 cleanup:
10630 }
10632 static int
10634 {
10648 }
10651 }
10655 int
10657 {
10719 #if defined(TARGET_X86) || defined (TARGET_AMD64)
10724 #endif
10725 #if defined(TARGET_AMD64)
10728 #endif
10739 }
10742 }
10744 static int
10746 {
10772 }
10775 }
10777 static int
10779 {
10798 }
10801 }
10803 int
10805 {
10806 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10807 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10819 #if SIZEOF_REGISTER == 8
10822 #endif
10823 }
10824 #endif
10827 }
10831 {
10832 #if defined(TARGET_X86)
10864 }
10865 #endif
10867 #if defined(TARGET_AMD64)
10868 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10919 }
10920 #endif
10923 }
10927 {
10928 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10936 }
10937 #endif
10940 }
10944 {
10945 #ifdef TARGET_X86
10946 /* FIXME: This has sign extension issues */
10947 /*
10948 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10949 return OP_X86_COMPARE_MEMBASE8_IMM;
10950 */
10952 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10964 }
10965 #endif
10967 #ifdef TARGET_AMD64
10968 /* FIXME: This has sign extension issues */
10969 /*
10970 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10971 return OP_X86_COMPARE_MEMBASE8_IMM;
10972 */
10976 #ifdef __mono_ilp32__
10978 #else
10980 #endif
10983 /* FIXME: This only works for 32 bit immediates
10984 case OP_COMPARE_IMM:
10985 case OP_LCOMPARE_IMM:
10986 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10987 return OP_AMD64_COMPARE_MEMBASE_IMM;
10988 */
10995 #ifdef __mono_ilp32__
10999 #else
11001 #endif
11008 }
11009 #endif
11012 }
11016 {
11017 #ifdef TARGET_X86
11018 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11035 }
11036 #endif
11038 #ifdef TARGET_AMD64
11039 #ifdef __mono_ilp32__
11040 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE) ) {
11041 #else
11043 #endif
11057 }
11058 #ifdef __mono_ilp32__
11060 #else
11062 #endif
11077 }
11078 }
11079 #endif
11082 }
11084 int
11086 {
11088 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
11093 #endif
11094 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
11100 #endif
11103 }
11104 }
11106 #ifndef DISABLE_JIT
11108 /**
11109 * mono_handle_global_vregs:
11110 *
11111 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
11112 * for them.
11113 */
11114 void
11116 {
11123 #ifdef MONO_ARCH_SIMD_INTRINSICS
11126 #endif
11128 /* Find local vregs used in more than one bb */
11140 gint32 prev_bb;
11170 }
11172 #if SIZEOF_REGISTER == 4
11173 /* In the LLVM case, the long opcodes are not decomposed */
11175 /*
11176 * Since some instructions reference the original long vreg,
11177 * and some reference the two component vregs, it is quite hard
11178 * to determine when it needs to be global. So be conservative.
11179 */
11181 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11185 }
11187 /*
11188 * Make the component vregs volatile since the optimizations can
11189 * get confused otherwise.
11190 */
11193 }
11194 #endif
11200 /* 0 is a valid block num */
11203 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
11213 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
11214 else
11218 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
11221 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
11228 }
11229 }
11231 /* Flag as having been used in more than one bb */
11233 }
11234 }
11235 }
11236 }
11238 /* If a variable is used in only one bblock, convert it into a local vreg */
11249 #if SIZEOF_REGISTER == 8
11251 #endif
11252 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
11253 /* Enabling this screws up the fp stack on x86 */
11255 #endif
11256 /* Arguments are implicitly global */
11257 /* Putting R4 vars into registers doesn't work currently */
11258 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) {
11259 /*
11260 * Make that the variable's liveness interval doesn't contain a call, since
11261 * that would cause the lvreg to be spilled, making the whole optimization
11262 * useless.
11263 */
11264 /* This is too slow for JIT compilation */
11265 #if 0
11285 }
11286 }
11291 ins_index ++;
11292 }
11296 }
11297 #endif
11303 }
11305 }
11306 }
11308 /*
11309 * Compress the varinfo and vars tables so the liveness computation is faster and
11310 * takes up less space.
11311 */
11323 #if SIZEOF_REGISTER == 4
11325 /* Modify the two component vars too */
11332 }
11333 #endif
11334 }
11335 pos ++;
11336 }
11337 }
11341 }
11343 /**
11344 * mono_spill_global_vars:
11345 *
11346 * Generate spill code for variables which are not allocated to registers,
11347 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
11348 * code is generated which could be optimized by the local optimization passes.
11349 */
11350 void
11352 {
11368 /* FIXME: Move this function to mini.c */
11372 #ifdef MONO_ARCH_SIMD_INTRINSICS
11374 #endif
11376 #if SIZEOF_REGISTER == 4
11377 /* Create MonoInsts for longs */
11404 }
11407 }
11408 }
11409 }
11410 #endif
11413 /* registers need liveness info even for !non refs */
11419 }
11420 }
11422 /* FIXME: widening and truncation */
11424 /*
11425 * As an optimization, when a variable allocated to the stack is first loaded into
11426 * an lvreg, we will remember the lvreg and use it the next time instead of loading
11427 * the variable again.
11428 */
11434 /*
11435 * These arrays contain the first and last instructions accessing a given
11436 * variable.
11437 * Since we emit bblocks in the same order we process them here, and we
11438 * don't split live ranges, these will precisely describe the live range of
11439 * the variable, i.e. the instruction range where a valid value can be found
11440 * in the variables location.
11441 * The live range is computed using the liveness info computed by the liveness pass.
11442 * We can't use vmv->range, since that is an abstract live range, and we need
11443 * one which is instruction precise.
11444 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
11445 */
11446 /* FIXME: Only do this if debugging info is requested */
11452 /* Add spill loads/stores */
11459 /* Clear vreg_to_lvreg array */
11477 /*
11478 * We handle LDADDR here as well, since it can only be decomposed
11479 * when variable addresses are known.
11480 */
11485 /* Happens on SPARC/S390 where vtypes are passed by reference */
11490 }
11496 NOT_IMPLEMENTED;
11503 }
11507 }
11512 }
11514 /*
11515 * Store opcodes have destbasereg in the dreg, but in reality, it is an
11516 * src register.
11517 * FIXME:
11518 */
11532 else
11542 }
11544 /***************/
11545 /* DREG */
11546 /***************/
11548 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
11562 } 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)) {
11563 /*
11564 * Instead of emitting a load+store, use a _membase opcode.
11565 */
11575 }
11578 guint32 lvreg;
11584 /* Invalidate any previous lvreg for this vreg */
11592 }
11597 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
11599 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
11602 }
11606 /* Try to fuse the store into the instruction itself */
11607 /* FIXME: Add more instructions */
11608 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
11614 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
11632 // FIXME: The backends expect the base reg to be in inst_basereg
11639 /* printf ("INS: "); mono_print_ins (ins); */
11640 /* Create a store instruction */
11641 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
11643 /* Insert it after the instruction */
11648 /*
11649 * We can't assign ins->dreg to var->dreg here, since the
11650 * sregs could use it. So set a flag, and do it after
11651 * the sregs.
11652 */
11653 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)))
11655 }
11656 }
11657 }
11662 }
11670 }
11671 }
11673 /************/
11674 /* SREGS */
11675 /************/
11686 guint32 load_opcode;
11690 //mono_inst_set_src_registers (ins, sregs);
11694 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
11698 /* var->dreg is a hreg */
11701 }
11704 }
11715 /* The variable is already loaded to an lvreg */
11719 //mono_inst_set_src_registers (ins, sregs);
11721 }
11723 /* Try to fuse the load into the instruction */
11727 //mono_inst_set_src_registers (ins, sregs);
11732 //mono_inst_set_src_registers (ins, sregs);
11739 //printf ("%d ", srcindex); mono_print_ins (ins);
11743 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) {
11745 /*
11746 * sreg refers to the value loaded by the load
11747 * emitted below, but we need to use ins->dreg
11748 * since it refers to the store emitted earlier.
11749 */
11751 }
11756 }
11757 }
11760 //mono_inst_set_src_registers (ins, sregs);
11763 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
11765 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
11768 }
11770 #if SIZEOF_REGISTER == 4
11772 #endif
11776 }
11777 }
11782 }
11784 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
11790 }
11791 }
11792 }
11801 }
11807 }
11810 /* Clear vreg_to_lvreg array */
11817 }
11821 }
11823 /* Extend the live range based on the liveness info */
11829 /* The liveness info is incomplete */
11833 /* Live from at least the first ins of this bb */
11836 }
11839 /* Live at least until the last ins of this bb */
11842 }
11843 }
11844 }
11845 }
11847 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11848 /*
11849 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11850 * by storing the current native offset into MonoMethodVar->live_range_start/end.
11851 */
11862 }
11869 else
11871 }
11872 }
11873 }
11874 #endif
11880 }
11882 /**
11883 * FIXME:
11884 * - use 'iadd' instead of 'int_add'
11885 * - handling ovf opcodes: decompose in method_to_ir.
11886 * - unify iregs/fregs
11887 * -> partly done, the missing parts are:
11888 * - a more complete unification would involve unifying the hregs as well, so
11889 * code wouldn't need if (fp) all over the place. but that would mean the hregs
11890 * would no longer map to the machine hregs, so the code generators would need to
11891 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11892 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11893 * fp/non-fp branches speeds it up by about 15%.
11894 * - use sext/zext opcodes instead of shifts
11895 * - add OP_ICALL
11896 * - get rid of TEMPLOADs if possible and use vregs instead
11897 * - clean up usage of OP_P/OP_ opcodes
11898 * - cleanup usage of DUMMY_USE
11899 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11900 * stack
11901 * - set the stack type and allocate a dreg in the EMIT_NEW macros
11902 * - get rid of all the <foo>2 stuff when the new JIT is ready.
11903 * - make sure handle_stack_args () is called before the branch is emitted
11904 * - when the new IR is done, get rid of all unused stuff
11905 * - COMPARE/BEQ as separate instructions or unify them ?
11906 * - keeping them separate allows specialized compare instructions like
11907 * compare_imm, compare_membase
11908 * - most back ends unify fp compare+branch, fp compare+ceq
11909 * - integrate mono_save_args into inline_method
11910 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11911 * - handle long shift opts on 32 bit platforms somehow: they require
11912 * 3 sregs (2 for arg1 and 1 for arg2)
11913 * - make byref a 'normal' type.
11914 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11915 * variable if needed.
11916 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11917 * like inline_method.
11918 * - remove inlining restrictions
11919 * - fix LNEG and enable cfold of INEG
11920 * - generalize x86 optimizations like ldelema as a peephole optimization
11921 * - add store_mem_imm for amd64
11922 * - optimize the loading of the interruption flag in the managed->native wrappers
11923 * - avoid special handling of OP_NOP in passes
11924 * - move code inserting instructions into one function/macro.
11925 * - try a coalescing phase after liveness analysis
11926 * - add float -> vreg conversion + local optimizations on !x86
11927 * - figure out how to handle decomposed branches during optimizations, ie.
11928 * compare+branch, op_jump_table+op_br etc.
11929 * - promote RuntimeXHandles to vregs
11930 * - vtype cleanups:
11931 * - add a NEW_VARLOADA_VREG macro
11932 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11933 * accessing vtype fields.
11934 * - get rid of I8CONST on 64 bit platforms
11935 * - dealing with the increase in code size due to branches created during opcode
11936 * decomposition:
11937 * - use extended basic blocks
11938 * - all parts of the JIT
11939 * - handle_global_vregs () && local regalloc
11940 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11941 * - sources of increase in code size:
11942 * - vtypes
11943 * - long compares
11944 * - isinst and castclass
11945 * - lvregs not allocated to global registers even if used multiple times
11946 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11947 * meaningful.
11948 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11949 * - add all micro optimizations from the old JIT
11950 * - put tree optimizations into the deadce pass
11951 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11952 * specific function.
11953 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11954 * fcompare + branchCC.
11955 * - create a helper function for allocating a stack slot, taking into account
11956 * MONO_CFG_HAS_SPILLUP.
11957 * - merge r68207.
11958 * - merge the ia64 switch changes.
11959 * - optimize mono_regstate2_alloc_int/float.
11960 * - fix the pessimistic handling of variables accessed in exception handler blocks.
11961 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11962 * parts of the tree could be separated by other instructions, killing the tree
11963 * arguments, or stores killing loads etc. Also, should we fold loads into other
11964 * instructions if the result of the load is used multiple times ?
11965 * - make the REM_IMM optimization in mini-x86.c arch-independent.
11966 * - LAST MERGE: 108395.
11967 * - when returning vtypes in registers, generate IR and append it to the end of the
11968 * last bb instead of doing it in the epilog.
11969 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
11970 */
11972 /*
11974 NOTES
11975 -----
11977 - When to decompose opcodes:
11978 - earlier: this makes some optimizations hard to implement, since the low level IR
11979 no longer contains the neccessary information. But it is easier to do.
11980 - later: harder to implement, enables more optimizations.
11981 - Branches inside bblocks:
11982 - created when decomposing complex opcodes.
11983 - branches to another bblock: harmless, but not tracked by the branch
11984 optimizations, so need to branch to a label at the start of the bblock.
11985 - branches to inside the same bblock: very problematic, trips up the local
11986 reg allocator. Can be fixed by spitting the current bblock, but that is a
11987 complex operation, since some local vregs can become global vregs etc.
11988 - Local/global vregs:
11989 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
11990 local register allocator.
11991 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
11992 structure, created by mono_create_var (). Assigned to hregs or the stack by
11993 the global register allocator.
11994 - When to do optimizations like alu->alu_imm:
11995 - earlier -> saves work later on since the IR will be smaller/simpler
11996 - later -> can work on more instructions
11997 - Handling of valuetypes:
11998 - When a vtype is pushed on the stack, a new temporary is created, an
11999 instruction computing its address (LDADDR) is emitted and pushed on
12000 the stack. Need to optimize cases when the vtype is used immediately as in
12001 argument passing, stloc etc.
12002 - Instead of the to_end stuff in the old JIT, simply call the function handling
12003 the values on the stack before emitting the last instruction of the bb.
12004 */