| blob | 7db0f9b086a413cea38c5c7a8a4410574f4a8c67 |
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/loader.h>
34 #include <mono/metadata/tabledefs.h>
35 #include <mono/metadata/class.h>
36 #include <mono/metadata/object.h>
37 #include <mono/metadata/exception.h>
38 #include <mono/metadata/opcodes.h>
39 #include <mono/metadata/mono-endian.h>
40 #include <mono/metadata/tokentype.h>
41 #include <mono/metadata/tabledefs.h>
42 #include <mono/metadata/marshal.h>
43 #include <mono/metadata/debug-helpers.h>
44 #include <mono/metadata/mono-debug.h>
45 #include <mono/metadata/gc-internal.h>
46 #include <mono/metadata/security-manager.h>
47 #include <mono/metadata/threads-types.h>
48 #include <mono/metadata/security-core-clr.h>
49 #include <mono/metadata/monitor.h>
50 #include <mono/metadata/profiler-private.h>
51 #include <mono/metadata/profiler.h>
52 #include <mono/utils/mono-compiler.h>
53 #include <mono/metadata/mono-basic-block.h>
64 #define BRANCH_COST 100
65 #define INLINE_LENGTH_LIMIT 20
66 #define INLINE_FAILURE do {\
67 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
68 goto inline_failure;\
69 } while (0)
70 #define CHECK_CFG_EXCEPTION do {\
71 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
72 goto exception_exit;\
73 } while (0)
74 #define METHOD_ACCESS_FAILURE do { \
75 char *method_fname = mono_method_full_name (method, TRUE); \
76 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
77 cfg->exception_type = MONO_EXCEPTION_METHOD_ACCESS; \
78 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
79 g_free (method_fname); \
80 g_free (cil_method_fname); \
81 goto exception_exit; \
82 } while (0)
83 #define FIELD_ACCESS_FAILURE do { \
84 char *method_fname = mono_method_full_name (method, TRUE); \
85 char *field_fname = mono_field_full_name (field); \
86 cfg->exception_type = MONO_EXCEPTION_FIELD_ACCESS; \
87 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
88 g_free (method_fname); \
89 g_free (field_fname); \
90 goto exception_exit; \
91 } while (0)
92 #define GENERIC_SHARING_FAILURE(opcode) do { \
93 if (cfg->generic_sharing_context) { \
94 if (cfg->verbose_level > 2) \
95 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__); \
96 cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED; \
97 goto exception_exit; \
98 } \
99 } while (0)
101 /* Determine whenever 'ins' represents a load of the 'this' argument */
102 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
110 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
111 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
114 /* helper methods signature */
123 /*
124 * Instruction metadata
125 */
126 #ifdef MINI_OP
127 #undef MINI_OP
128 #endif
129 #ifdef MINI_OP3
130 #undef MINI_OP3
131 #endif
133 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
139 #if SIZEOF_REGISTER == 8
140 #define LREG IREG
141 #else
143 #endif
144 /* keep in sync with the enum in mini.h */
145 const char
146 ins_info[] = {
148 };
149 #undef MINI_OP
150 #undef MINI_OP3
152 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
153 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
154 /*
155 * This should contain the index of the last sreg + 1. This is not the same
156 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
157 */
160 };
161 #undef MINI_OP
162 #undef MINI_OP3
164 #define MONO_INIT_VARINFO(vi,id) do { \
165 (vi)->range.first_use.pos.bid = 0xffff; \
166 (vi)->reg = -1; \
167 (vi)->idx = (id); \
168 } while (0)
170 void
172 {
176 }
178 guint32
180 {
182 }
184 guint32
186 {
188 }
190 guint32
192 {
194 }
196 guint32
198 {
200 }
202 guint
204 {
208 handle_enum:
234 #if SIZEOF_REGISTER == 8
236 #else
238 #endif
247 }
262 }
264 }
266 void
268 {
281 }
283 /*
284 * Can't put this at the beginning, since other files reference stuff from this
285 * file.
286 */
287 #ifndef DISABLE_JIT
289 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
291 #define GET_BBLOCK(cfg,tblock,ip) do { \
292 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
293 if (!(tblock)) { \
294 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
295 NEW_BBLOCK (cfg, (tblock)); \
296 (tblock)->cil_code = (ip); \
297 ADD_BBLOCK (cfg, (tblock)); \
298 } \
299 } while (0)
301 #if defined(TARGET_X86) || defined(TARGET_AMD64)
302 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
303 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
304 (dest)->dreg = alloc_preg ((cfg)); \
305 (dest)->sreg1 = (sr1); \
306 (dest)->sreg2 = (sr2); \
307 (dest)->inst_imm = (imm); \
308 (dest)->backend.shift_amount = (shift); \
309 MONO_ADD_INS ((cfg)->cbb, (dest)); \
310 } while (0)
311 #endif
313 #if SIZEOF_REGISTER == 8
314 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
316 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
317 MonoInst *widen; \
318 int dr = alloc_preg (cfg); \
319 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
320 (ins)->sreg2 = widen->dreg; \
321 } \
322 } while (0)
323 #else
324 #define ADD_WIDEN_OP(ins, arg1, arg2)
325 #endif
327 #define ADD_BINOP(op) do { \
328 MONO_INST_NEW (cfg, ins, (op)); \
329 sp -= 2; \
330 ins->sreg1 = sp [0]->dreg; \
331 ins->sreg2 = sp [1]->dreg; \
332 type_from_op (ins, sp [0], sp [1]); \
333 CHECK_TYPE (ins); \
335 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
336 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
337 MONO_ADD_INS ((cfg)->cbb, (ins)); \
338 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
339 } while (0)
341 #define ADD_UNOP(op) do { \
342 MONO_INST_NEW (cfg, ins, (op)); \
343 sp--; \
344 ins->sreg1 = sp [0]->dreg; \
345 type_from_op (ins, sp [0], NULL); \
346 CHECK_TYPE (ins); \
347 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
348 MONO_ADD_INS ((cfg)->cbb, (ins)); \
349 *sp++ = mono_decompose_opcode (cfg, ins); \
350 } while (0)
352 #define ADD_BINCOND(next_block) do { \
353 MonoInst *cmp; \
354 sp -= 2; \
355 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
356 cmp->sreg1 = sp [0]->dreg; \
357 cmp->sreg2 = sp [1]->dreg; \
358 type_from_op (cmp, sp [0], sp [1]); \
359 CHECK_TYPE (cmp); \
360 type_from_op (ins, sp [0], sp [1]); \
361 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
362 GET_BBLOCK (cfg, tblock, target); \
363 link_bblock (cfg, bblock, tblock); \
364 ins->inst_true_bb = tblock; \
365 if ((next_block)) { \
366 link_bblock (cfg, bblock, (next_block)); \
367 ins->inst_false_bb = (next_block); \
368 start_new_bblock = 1; \
369 } else { \
370 GET_BBLOCK (cfg, tblock, ip); \
371 link_bblock (cfg, bblock, tblock); \
372 ins->inst_false_bb = tblock; \
373 start_new_bblock = 2; \
374 } \
375 if (sp != stack_start) { \
376 handle_stack_args (cfg, stack_start, sp - stack_start); \
377 CHECK_UNVERIFIABLE (cfg); \
378 } \
379 MONO_ADD_INS (bblock, cmp); \
380 MONO_ADD_INS (bblock, ins); \
381 } while (0)
383 /* *
384 * link_bblock: Links two basic blocks
385 *
386 * links two basic blocks in the control flow graph, the 'from'
387 * argument is the starting block and the 'to' argument is the block
388 * the control flow ends to after 'from'.
389 */
390 static void
392 {
396 #if 0
399 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
400 else
405 else
407 }
408 #endif
415 }
416 }
421 }
425 }
432 }
433 }
438 }
442 }
443 }
445 void
447 {
449 }
451 /**
452 * mono_find_block_region:
453 *
454 * We mark each basic block with a region ID. We use that to avoid BB
455 * optimizations when blocks are in different regions.
456 *
457 * Returns:
458 * A region token that encodes where this region is, and information
459 * about the clause owner for this block.
460 *
461 * The region encodes the try/catch/filter clause that owns this block
462 * as well as the type. -1 is a special value that represents a block
463 * that is in none of try/catch/filter.
464 */
465 static int
467 {
474 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
483 else
485 }
489 }
492 }
496 {
508 }
509 }
511 }
513 static void
515 {
523 /* prevent it from being register allocated */
527 }
529 MonoInst *
531 {
533 }
537 {
545 /* prevent it from being register allocated */
551 }
553 /*
554 * Returns the type used in the eval stack when @type is loaded.
555 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
556 */
557 void
559 {
566 }
568 handle_enum:
612 }
622 /* FIXME: all the arguments must be references for now,
623 * later look inside cfg and see if the arg num is
624 * really a reference
625 */
631 }
632 }
634 /*
635 * The following tables are used to quickly validate the IL code in type_from_op ().
636 */
637 static const char
647 };
649 static const char
650 neg_table [] = {
652 };
654 /* reduce the size of this table */
655 static const char
665 };
667 static const char
669 /* Inv i L p F & O vt */
678 };
680 /* reduce the size of this table */
681 static const char
691 };
693 /*
694 * Tables to map from the non-specific opcode to the matching
695 * type-specific opcode.
696 */
697 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
698 static const guint16
701 };
703 /* handles from CEE_NEG to CEE_CONV_U8 */
704 static const guint16
707 };
709 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
710 static const guint16
712 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
713 };
715 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
716 static const guint16
718 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
719 };
721 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
722 static const guint16
724 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
725 };
727 /* handles from CEE_BEQ to CEE_BLT_UN */
728 static const guint16
730 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
731 };
733 /* handles from CEE_CEQ to CEE_CLT_UN */
734 static const guint16
736 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
737 };
739 /*
740 * Sets ins->type (the type on the eval stack) according to the
741 * type of the opcode and the arguments to it.
742 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
743 *
744 * FIXME: this function sets ins->type unconditionally in some cases, but
745 * it should set it to invalid for some types (a conv.x on an object)
746 */
747 static void
751 /* binops */
757 /* FIXME: check unverifiable args for STACK_MP */
779 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
783 else
788 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
814 /* unops */
822 else
843 }
876 #if SIZEOF_REGISTER == 8
878 #else
880 #endif
888 }
956 }
960 }
962 static const char
963 ldind_type [] = {
964 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
965 };
967 #if 0
969 static const char
972 };
974 static int
986 }
987 args++;
988 }
1009 }
1022 }
1023 /*if (!param_table [args [i].type] [sig->params [i]->type])
1024 return 0;*/
1025 }
1027 }
1028 #endif
1030 /*
1031 * When we need a pointer to the current domain many times in a method, we
1032 * call mono_domain_get() once and we store the result in a local variable.
1033 * This function returns the variable that represents the MonoDomain*.
1034 */
1037 {
1041 }
1043 /*
1044 * The got_var contains the address of the Global Offset Table when AOT
1045 * compiling.
1046 */
1047 MonoInst *
1049 {
1050 #ifdef MONO_ARCH_NEED_GOT_VAR
1055 }
1057 #else
1059 #endif
1060 }
1064 {
1069 /* force the var to be stack allocated */
1071 }
1074 }
1089 }
1091 }
1095 {
1130 else
1135 }
1138 }
1142 {
1176 }
1178 }
1180 /*
1181 * We try to share variables when possible
1182 */
1185 {
1189 /* inlining can result in deeper stacks */
1209 }
1211 }
1213 static void
1215 {
1216 /*
1217 * Don't use this if a generic_context is set, since that means AOT can't
1218 * look up the method using just the image+token.
1219 * table == 0 means this is a reference made from a wrapper.
1220 */
1222 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1226 }
1227 }
1229 /*
1230 * This function is called to handle items that are left on the evaluation stack
1231 * at basic block boundaries. What happens is that we save the values to local variables
1232 * and we reload them later when first entering the target basic block (with the
1233 * handle_loaded_temps () function).
1234 * A single joint point will use the same variables (stored in the array bb->out_stack or
1235 * bb->in_stack, if the basic block is before or after the joint point).
1236 *
1237 * This function needs to be called _before_ emitting the last instruction of
1238 * the bb (i.e. before emitting a branch).
1239 * If the stack merge fails at a join point, cfg->unverifiable is set.
1240 */
1241 static void
1243 {
1248 gboolean found;
1256 //printf ("bblock %d has out:", bb->block_num);
1260 /* exception handlers are linked, but they should not be considered for stack args */
1263 //printf (" %d", outb->block_num);
1268 }
1269 }
1270 //printf ("\n");
1274 /*
1275 * try to reuse temps already allocated for this purpouse, if they occupy the same
1276 * stack slot and if they are of the same type.
1277 * This won't cause conflicts since if 'local' is used to
1278 * store one of the values in the in_stack of a bblock, then
1279 * the same variable will be used for the same outgoing stack
1280 * slot as well.
1281 * This doesn't work when inlining methods, since the bblocks
1282 * in the inlined methods do not inherit their in_stack from
1283 * the bblock they are inlined to. See bug #58863 for an
1284 * example.
1285 */
1288 else
1290 }
1291 }
1292 }
1296 /* exception handlers are linked, but they should not be considered for stack args */
1303 }
1305 }
1308 }
1318 }
1320 /*
1321 * It is possible that the out bblocks already have in_stack assigned, and
1322 * the in_stacks differ. In this case, we will store to all the different
1323 * in_stacks.
1324 */
1329 /* Find a bblock which has a different in_stack */
1333 /* exception handlers are linked, but they should not be considered for stack args */
1335 bindex++;
1337 }
1345 }
1349 }
1350 bindex ++;
1351 }
1352 }
1353 }
1355 /* Emit code which loads interface_offsets [klass->interface_id]
1356 * The array is stored in memory before vtable.
1357 */
1358 static void
1359 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1360 {
1368 }
1370 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1371 }
1372 }
1374 static void
1375 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1376 {
1378 #ifdef COMPRESSED_INTERFACE_BITMAP
1386 else
1390 #else
1405 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1411 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1412 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1413 }
1414 #endif
1415 }
1417 /*
1418 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1419 * stored in "klass_reg" implements the interface "klass".
1420 */
1421 static void
1422 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1423 {
1424 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1425 }
1427 /*
1428 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1429 * stored in "vtable_reg" implements the interface "klass".
1430 */
1431 static void
1432 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1433 {
1434 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1435 }
1437 /*
1438 * Emit code which checks whenever the interface id of @klass is smaller than
1439 * than the value given by max_iid_reg.
1440 */
1441 static void
1444 {
1449 }
1450 else
1454 else
1456 }
1458 /* Same as above, but obtains max_iid from a vtable */
1459 static void
1462 {
1465 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1467 }
1469 /* Same as above, but obtains max_iid from a klass */
1470 static void
1473 {
1476 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1478 }
1480 static void
1481 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1482 {
1488 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1491 }
1492 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1502 }
1504 }
1506 static void
1507 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1508 {
1510 }
1512 static void
1513 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1514 {
1522 else
1524 }
1526 /*
1527 * Variant of the above that takes a register to the class, not the vtable.
1528 */
1529 static void
1530 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1531 {
1539 else
1541 }
1544 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1545 {
1554 }
1556 }
1560 {
1562 }
1565 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1566 {
1573 }
1575 }
1577 static void
1578 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1580 static void
1581 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1582 {
1588 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1591 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1592 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1596 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1599 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1606 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1608 }
1611 /* Check that the object is a vector too */
1616 }
1623 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1626 }
1627 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1630 }
1631 }
1633 static void
1634 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1635 {
1637 }
1639 static void
1641 {
1660 #if SIZEOF_REGISTER == 8
1664 #endif
1665 }
1666 }
1672 else
1676 /* This could be optimized further if neccesary */
1681 }
1683 }
1685 #if !NO_UNALIGNED_ACCESS
1691 }
1696 }
1697 }
1698 #endif
1704 }
1709 }
1714 }
1715 }
1717 void
1718 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1719 {
1725 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1729 /* This could be optimized further if neccesary */
1737 }
1738 }
1740 #if !NO_UNALIGNED_ACCESS
1749 }
1750 }
1751 #endif
1760 }
1768 }
1776 }
1777 }
1779 static int
1780 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1781 {
1785 handle_enum:
1829 }
1831 }
1833 /*
1834 * target_type_is_incompatible:
1835 * @cfg: MonoCompile context
1836 *
1837 * Check that the item @arg on the evaluation stack can be stored
1838 * in the target type (can be a local, or field, etc).
1839 * The cfg arg can be used to check if we need verification or just
1840 * validity checks.
1841 *
1842 * Returns: non-0 value if arg can't be stored on a target.
1843 */
1844 static int
1846 {
1851 /* FIXME: check that the pointed to types match */
1857 }
1875 /* STACK_MP is needed when setting pinned locals */
1892 /* FIXME: check type compatibility */
1929 /* FIXME: check type compatibility */
1931 }
1934 /* FIXME: all the arguments must be references for now,
1935 * later look inside cfg and see if the arg num is
1936 * really a reference
1937 */
1944 }
1946 }
1948 /*
1949 * Prepare arguments for passing to a function call.
1950 * Return a non-zero value if the arguments can't be passed to the given
1951 * signature.
1952 * The type checks are not yet complete and some conversions may need
1953 * casts on 32 or 64 bit architectures.
1954 *
1955 * FIXME: implement this using target_type_is_incompatible ()
1956 */
1957 static int
1959 {
1966 args++;
1967 }
1973 }
1976 handle_enum:
1996 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2021 }
2036 }
2037 }
2039 }
2041 static int
2043 {
2057 }
2060 }
2062 static int
2064 {
2078 }
2081 }
2083 #ifdef MONO_ARCH_HAVE_IMT
2084 static void
2086 {
2087 #ifdef MONO_ARCH_IMT_REG
2100 }
2102 #ifdef ENABLE_LLVM
2105 #endif
2107 #else
2109 #endif
2110 }
2111 #endif
2115 {
2123 }
2128 {
2130 #ifdef MONO_ARCH_SOFT_FLOAT
2132 #endif
2136 else
2137 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2147 //g_assert_not_reached ();
2148 }
2155 /*
2156 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2157 * address of return value to increase optimization opportunities.
2158 * Before vtype decomposition, the dreg of the call ins itself represents the
2159 * fact the call modifies the return value. After decomposition, the call will
2160 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2161 * will be transformed into an LDADDR.
2162 */
2166 /* We reference the call too since call->dreg could change during optimization */
2176 #ifdef MONO_ARCH_SOFT_FLOAT
2178 /*
2179 * If the call has a float argument, we would need to do an r8->r4 conversion using
2180 * an icall, but that cannot be done during the call sequence since it would clobber
2181 * the call registers + the stack. So we do it before emitting the call.
2182 */
2189 else
2200 /* The result will be in an int vreg */
2202 }
2203 }
2204 }
2205 #endif
2207 #ifdef ENABLE_LLVM
2210 else
2212 #else
2214 #endif
2220 }
2224 {
2232 }
2234 static void
2236 {
2237 #ifdef MONO_ARCH_RGCTX_REG
2241 #ifdef ENABLE_LLVM
2243 #endif
2244 #else
2245 NOT_IMPLEMENTED;
2246 #endif
2247 }
2250 mono_emit_rgctx_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2251 {
2258 }
2263 }
2266 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2273 {
2274 gboolean might_be_remote;
2281 /* Create the real signature */
2282 /* FIXME: Cache these */
2287 }
2299 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2302 }
2308 else
2318 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2319 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2322 /* Make a call to delegate->invoke_impl */
2329 }
2330 #endif
2337 /*
2338 * the method is not virtual, we just need to ensure this is not null
2339 * and then we can call the method directly.
2340 */
2342 /*
2343 * The check above ensures method is not gshared, this is needed since
2344 * gshared methods can't have wrappers.
2345 */
2347 }
2357 }
2360 /*
2361 * the method is virtual, but we can statically dispatch since either
2362 * it's class or the method itself are sealed.
2363 * But first we need to ensure it's not a null reference.
2364 */
2371 }
2376 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2379 #ifdef MONO_ARCH_HAVE_IMT
2385 }
2386 #endif
2391 }
2396 #ifdef MONO_ARCH_HAVE_IMT
2400 }
2401 #endif
2402 }
2406 }
2411 }
2414 mono_emit_rgctx_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2416 {
2424 }
2432 }
2434 MonoInst*
2436 {
2437 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL);
2438 }
2440 MonoInst*
2443 {
2454 }
2456 MonoInst*
2458 {
2464 }
2466 /*
2467 * mono_emit_abs_call:
2468 *
2469 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2470 */
2474 {
2478 /*
2479 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2480 * handle it.
2481 */
2488 }
2492 {
2497 /*
2498 * Native code might return non register sized integers
2499 * without initializing the upper bits.
2500 */
2516 }
2525 }
2526 }
2527 }
2530 }
2534 {
2540 }
2542 }
2544 #if HAVE_WRITE_BARRIERS
2546 static void
2548 {
2562 /*FIXME support nested value types so this works for: struct X { Y y; int z;} struct Y { object a,b; }*/
2566 }
2567 }
2568 }
2570 static gboolean
2571 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
2572 {
2579 /*types with references can't have alignment smaller than sizeof(void*) */
2583 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
2589 /* We don't unroll more than 5 stores to avoid code bloat. */
2591 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
2599 }
2608 /*tmp = dreg*/
2624 }
2631 /*tmp += sizeof (void*)*/
2635 }
2636 }
2638 /* Those cannot be references since size < sizeof (void*) */
2644 }
2651 }
2658 }
2661 }
2662 #endif
2664 /*
2665 * Emit code to copy a valuetype of type @klass whose address is stored in
2666 * @src->dreg to memory whose address is stored at @dest->dreg.
2667 */
2668 void
2669 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2670 {
2677 /*
2678 * This check breaks with spilled vars... need to handle it during verification anyway.
2679 * g_assert (klass && klass == src->klass && klass == dest->klass);
2680 */
2684 else
2687 #if HAVE_WRITE_BARRIERS
2688 /* if native is true there should be no references in the struct */
2690 /* Avoid barriers when storing to the stack */
2701 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
2702 if ((cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
2712 }
2713 }
2717 }
2718 }
2719 #endif
2722 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2731 }
2732 }
2736 {
2742 }
2744 }
2746 void
2748 {
2751 guint32 align;
2754 /* FIXME: Optimize this for the case when dest is an LDADDR */
2761 }
2768 }
2769 }
2773 {
2806 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2808 }
2817 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2819 }
2820 }
2823 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2824 {
2834 }
2838 {
2839 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2840 }
2845 {
2846 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);
2850 }
2852 /*
2853 * emit_get_rgctx_method:
2854 *
2855 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2856 * normal constants, else emit a load from the rgctx.
2857 */
2861 {
2874 }
2876 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);
2880 }
2881 }
2886 {
2887 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);
2891 }
2893 /*
2894 * On return the caller must check @klass for load errors.
2895 */
2896 static void
2898 {
2915 }
2918 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
2919 else
2920 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
2921 #ifdef MONO_ARCH_VTABLE_REG
2924 #else
2925 NOT_IMPLEMENTED;
2926 #endif
2927 }
2929 /*
2930 * On return the caller must check @array_class for load errors
2931 */
2932 static void
2934 {
2952 }
2973 }
2974 }
2977 }
2979 static void
2981 {
2991 }
2997 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
2999 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3000 }
3001 }
3003 static void
3005 {
3006 /* Reset the variables holding the cast details */
3011 /* It is enough to reset the from field */
3012 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3013 }
3014 }
3016 /**
3017 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3018 * generic code is generated.
3019 */
3022 {
3028 /* FIXME: What if the class is shared? We might not
3029 have to get the address of the method from the
3030 RGCTX. */
3032 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3039 }
3040 }
3044 {
3053 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3054 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3056 /* FIXME: generics */
3059 // Check rank == 0
3064 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3069 /* This assertion is from the unboxcast insn */
3081 }
3083 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_PTR), obj_reg, sizeof (MonoObject));
3089 }
3091 /*
3092 * Returns NULL and set the cfg exception on error.
3093 */
3096 {
3105 /*
3106 FIXME: we cannot get managed_alloc here because we can't get
3107 the class's vtable (because it's not a closed class)
3109 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3110 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3111 */
3115 else
3126 }
3129 }
3136 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3137 /* This happens often in argument checking code, eg. throw new FooException... */
3138 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3144 gboolean pass_lw;
3150 }
3152 #ifndef MONO_CROSS_COMPILE
3154 #endif
3159 }
3166 }
3169 }
3170 }
3173 }
3175 /*
3176 * Returns NULL and set the cfg exception on error.
3177 */
3180 {
3187 /* FIXME: What if the class is shared? We might not
3188 have to get the method address from the RGCTX. */
3190 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3196 }
3197 }
3203 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3206 }
3208 // FIXME: This doesn't work yet (class libs tests fail?)
3209 #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) || mono_class_has_variant_generic_params (klass) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
3211 /*
3212 * Returns NULL and set the cfg exception on error.
3213 */
3216 {
3229 /* Complex case, handle by an icall */
3231 /* obj */
3234 /* klass */
3239 /* Simple case, handled by the code below */
3240 }
3241 }
3258 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3259 /* the remoting code is broken, access the class for now */
3260 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3266 }
3271 }
3276 }
3277 }
3284 }
3286 /*
3287 * Returns NULL and set the cfg exception on error.
3288 */
3291 {
3305 /* Complex case, handle by an icall */
3307 /* obj */
3310 /* klass */
3315 /* Simple case, the code below can handle it */
3316 }
3317 }
3323 /* Do the assignment at the beginning, so the other assignment can be if converted */
3335 /* the is_null_bb target simply copies the input register to the output */
3345 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3349 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3353 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3357 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3367 /* Check that the object is a vector too */
3372 }
3374 /* the is_null_bb target simply copies the input register to the output */
3376 }
3380 /* the is_null_bb target simply copies the input register to the output */
3383 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3385 /* the remoting code is broken, access the class for now */
3386 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3392 }
3397 }
3402 /* the is_null_bb target simply copies the input register to the output */
3404 }
3405 }
3406 }
3418 }
3422 {
3423 /* This opcode takes as input an object reference and a class, and returns:
3424 0) if the object is an instance of the class,
3425 1) if the object is not instance of the class,
3426 2) if the object is a proxy whose type cannot be determined */
3453 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3456 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3464 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3466 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3467 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3470 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3480 }
3498 /* FIXME: */
3504 }
3508 {
3509 /* This opcode takes as input an object reference and a class, and returns:
3510 0) if the object is an instance of the class,
3511 1) if the object is a proxy whose type cannot be determined
3512 an InvalidCastException exception is thrown otherwhise*/
3540 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3552 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3555 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3556 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3559 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3575 }
3583 /* FIXME: */
3589 }
3591 /*
3592 * Returns NULL and set the cfg exception on error.
3593 */
3595 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3596 {
3606 /* Inline the contents of mono_delegate_ctor */
3608 /* Set target field */
3609 /* Optimize away setting of NULL target */
3611 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3613 /* Set method field */
3615 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3617 /*
3618 * To avoid looking up the compiled code belonging to the target method
3619 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3620 * store it, and we fill it after the method has been compiled.
3621 */
3626 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3636 }
3640 }
3641 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3642 }
3644 /* Set invoke_impl field */
3650 }
3651 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3653 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3656 }
3660 {
3663 /* Need to register the icall so it gets an icall wrapper */
3668 /* mono_array_new_va () needs a vararg calling convention */
3671 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3673 }
3675 static void
3677 {
3686 /* Add it to the start of the first bblock */
3690 }
3691 else
3696 /*
3697 * Add a dummy use to keep the got_var alive, since real uses might
3698 * only be generated by the back ends.
3699 * Add it to end_bblock, so the variable's lifetime covers the whole
3700 * method.
3701 * It would be better to make the usage of the got var explicit in all
3702 * cases when the backend needs it (i.e. calls, throw etc.), so this
3703 * wouldn't be needed.
3704 */
3707 }
3712 static gboolean
3714 {
3715 MonoMethodHeaderSummary header;
3717 #ifdef MONO_ARCH_SOFT_FLOAT
3720 #endif
3728 #ifdef MONO_ARCH_HAVE_LMF_OPS
3733 #endif
3739 /*runtime, icall and pinvoke are checked by summary call*/
3746 /* also consider num_locals? */
3747 /* Do the size check early to avoid creating vtables */
3751 else
3754 }
3758 /*
3759 * if we can initialize the class of the method right away, we do,
3760 * otherwise we don't allow inlining if the class needs initialization,
3761 * since it would mean inserting a call to mono_runtime_class_init()
3762 * inside the inlined code
3763 */
3767 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3769 /* No vtable created yet */
3774 /* This makes so that inline cannot trigger */
3775 /* .cctors: too many apps depend on them */
3776 /* running with a specific order... */
3780 }
3783 /* No vtable created yet */
3790 }
3792 /*
3793 * If we're compiling for shared code
3794 * the cctor will need to be run at aot method load time, for example,
3795 * or at the end of the compilation of the inlining method.
3796 */
3797 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3799 }
3801 /*
3802 * CAS - do not inline methods with declarative security
3803 * Note: this has to be before any possible return TRUE;
3804 */
3808 #ifdef MONO_ARCH_SOFT_FLOAT
3809 /* FIXME: */
3815 #endif
3818 }
3820 static gboolean
3822 {
3833 /* The initialization is already done before the method is called */
3837 }
3840 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
3841 {
3843 guint32 size;
3853 #if SIZEOF_REGISTER == 8
3854 /* The array reg is 64 bits but the index reg is only 32 */
3856 /* Not needed */
3861 }
3862 #else
3868 }
3869 #endif
3874 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3878 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
3882 }
3883 #endif
3894 }
3896 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3898 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
3899 {
3913 guint32 size;
3921 /* range checking */
3952 }
3953 #endif
3956 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3957 {
3968 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3969 /* emit_ldelema_2 depends on OP_LMUL */
3972 }
3973 #endif
3980 }
3982 static MonoBreakPolicy
3984 {
3986 }
3990 /**
3991 * mono_set_break_policy:
3992 * policy_callback: the new callback function
3993 *
3994 * Allow embedders to decide wherther to actually obey breakpoint instructions
3995 * (both break IL instructions and Debugger.Break () method calls), for example
3996 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
3997 * untrusted or semi-trusted code.
3998 *
3999 * @policy_callback will be called every time a break point instruction needs to
4000 * be inserted with the method argument being the method that calls Debugger.Break()
4001 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4002 * if it wants the breakpoint to not be effective in the given method.
4003 * #MONO_BREAK_POLICY_ALWAYS is the default.
4004 */
4005 void
4007 {
4010 else
4012 }
4014 static gboolean
4026 }
4027 }
4029 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
4031 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4032 {
4036 /* the bounds check is already done by the callers */
4044 }
4046 }
4049 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4050 {
4052 #ifdef MONO_ARCH_SIMD_INTRINSICS
4057 }
4058 #endif
4061 }
4064 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4065 {
4080 #if SIZEOF_REGISTER == 8
4081 /* The array reg is 64 bits but the index reg is only 32 */
4083 #else
4085 #endif
4088 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4089 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
4091 /* Avoid a warning */
4095 #else
4100 #endif
4105 /* Decompose later to allow more optimizations */
4116 /* The corlib functions check for oob already. */
4119 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4128 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4129 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4133 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
4143 #endif
4192 }
4194 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4199 /*
4200 * Pass the argument normally, the LLVM backend will handle the
4201 * calling convention problems.
4202 */
4203 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4209 }
4216 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4222 }
4225 }
4226 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4229 /* Avoid infinite recursion */
4242 #endif
4248 #if SIZEOF_REGISTER == 8
4250 /* 64 bit reads are already atomic */
4256 }
4257 #endif
4259 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4266 #if SIZEOF_REGISTER == 8
4269 #endif
4283 }
4290 #if SIZEOF_REGISTER == 8
4293 #endif
4307 }
4313 #if SIZEOF_REGISTER == 8
4316 #endif
4326 }
4327 }
4330 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4332 guint32 opcode;
4337 #if SIZEOF_REGISTER == 8
4341 #else
4344 #endif
4345 else
4368 }
4370 #if HAVE_WRITE_BARRIERS
4376 }
4377 #endif
4378 }
4381 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4408 /* g_assert_not_reached (); */
4409 }
4410 #if HAVE_WRITE_BARRIERS
4416 }
4417 #endif
4418 }
4428 else
4432 }
4435 #ifdef TARGET_WIN32
4437 #else
4439 #endif
4441 }
4443 /*
4444 * There is general branches code for Min/Max, but it does not work for
4445 * all inputs:
4446 * http://everything2.com/?node_id=1051618
4447 */
4448 }
4450 #ifdef MONO_ARCH_SIMD_INTRINSICS
4455 }
4456 #endif
4459 }
4461 /*
4462 * This entry point could be used later for arbitrary method
4463 * redirection.
4464 */
4468 {
4470 /* managed string allocation support */
4471 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS)) {
4477 #ifndef MONO_CROSS_COMPILE
4479 #endif
4485 }
4486 }
4488 }
4490 static void
4492 {
4497 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4499 /*
4500 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4501 * would be different than the MonoInst's used to represent arguments, and
4502 * the ldelema implementation can't deal with that.
4503 * Solution: When ldelema is used on an inline argument, create a var for
4504 * it, emit ldelema on that var, and emit the saving code below in
4505 * inline_method () if needed.
4506 */
4509 /* This uses cfg->args [i] which is set by the preceeding line */
4512 sp++;
4513 }
4514 }
4516 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4517 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4519 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4520 static gboolean
4522 {
4531 else
4533 }
4541 //return (strncmp_result <= 0);
4545 }
4546 }
4547 #endif
4549 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4550 static gboolean
4552 {
4562 }
4563 }
4571 //return (strncmp_result <= 0);
4575 }
4576 }
4577 #endif
4579 static int
4580 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4582 {
4590 guint prev_real_offset;
4595 guint32 prev_cil_offset_to_bb_len;
4602 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4605 #endif
4606 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4609 #endif
4612 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4617 }
4619 /* allocate local variables */
4627 }
4629 /* allocate space to store the return value */
4632 }
4640 /* allocate start and end blocks */
4641 /* This is needed so if the inline is aborted, we can clean up */
4665 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
4685 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4689 /* always add some code to avoid block split failures */
4696 /*
4697 * Get rid of the begin and end bblocks if possible to aid local
4698 * optimizations.
4699 */
4702 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4709 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4712 }
4715 }
4718 /*
4719 * If the inlined method contains only a throw, then the ret var is not
4720 * set, so set it to a dummy value.
4721 */
4749 }
4750 }
4754 }
4763 /* This gets rid of the newly added bblocks */
4765 }
4768 }
4770 /*
4771 * Some of these comments may well be out-of-date.
4772 * Design decisions: we do a single pass over the IL code (and we do bblock
4773 * splitting/merging in the few cases when it's required: a back jump to an IL
4774 * address that was not already seen as bblock starting point).
4775 * Code is validated as we go (full verification is still better left to metadata/verify.c).
4776 * Complex operations are decomposed in simpler ones right away. We need to let the
4777 * arch-specific code peek and poke inside this process somehow (except when the
4778 * optimizations can take advantage of the full semantic info of coarse opcodes).
4779 * All the opcodes of the form opcode.s are 'normalized' to opcode.
4780 * MonoInst->opcode initially is the IL opcode or some simplification of that
4781 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4782 * opcode with value bigger than OP_LAST.
4783 * At this point the IR can be handed over to an interpreter, a dumb code generator
4784 * or to the optimizing code generator that will translate it to SSA form.
4785 *
4786 * Profiling directed optimizations.
4787 * We may compile by default with few or no optimizations and instrument the code
4788 * or the user may indicate what methods to optimize the most either in a config file
4789 * or through repeated runs where the compiler applies offline the optimizations to
4790 * each method and then decides if it was worth it.
4791 */
4793 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4794 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4795 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
4796 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4797 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4798 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
4799 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4800 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
4802 /* offset from br.s -> br like opcodes */
4803 #define BIG_BRANCH_OFFSET 13
4805 static gboolean
4807 {
4811 }
4813 static int
4814 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
4815 {
4819 guint cli_addr;
4827 UNVERIFIED;
4831 ip++;
4866 guint32 j;
4876 }
4878 }
4885 }
4890 /* Find the start of the bblock containing the throw */
4894 bb_start --;
4895 }
4898 }
4899 }
4901 unverified:
4904 }
4907 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4908 {
4917 }
4920 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4921 {
4924 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
4928 }
4932 {
4937 else
4942 }
4944 /*
4945 * Returns TRUE if the JIT should abort inlining because "callee"
4946 * is influenced by security attributes.
4947 */
4948 static
4950 {
4951 guint32 result;
4955 }
4962 /* Generate code to throw a SecurityException before the actual call/link */
4970 /* don't hide previous results */
4974 }
4977 }
4981 {
4987 }
4990 }
4992 static void
4994 {
5000 }
5002 /*
5003 * Return the original method is a wrapper is specified. We can only access
5004 * the custom attributes from the original method.
5005 */
5008 {
5012 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
5016 /* in other cases we need to find the original method */
5018 }
5020 static void
5021 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
5023 {
5024 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5025 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
5028 }
5030 static void
5031 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
5033 {
5034 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5035 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
5038 }
5040 /*
5041 * Check that the IL instructions at ip are the array initialization
5042 * sequence and return the pointer to the data and the size.
5043 */
5045 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
5046 {
5047 /*
5048 * newarr[System.Int32]
5049 * dup
5050 * ldtoken field valuetype ...
5051 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5052 */
5057 guint32 rva;
5062 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
5073 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
5080 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5081 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5091 #ifdef ARM_FPU_FPA
5093 #endif
5097 #endif
5100 }
5105 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5110 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5111 /* for aot code we do the lookup on load */
5115 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5118 }
5120 }
5122 }
5124 static void
5126 {
5133 else
5136 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5140 }
5142 static void
5144 {
5148 }
5150 static gboolean
5152 {
5157 else
5160 }
5162 static void
5164 {
5169 /* Optimize reg-reg moves away */
5170 /*
5171 * Can't optimize other opcodes, since sp[0] might point to
5172 * the last ins of a decomposed opcode.
5173 */
5177 }
5178 }
5180 /*
5181 * ldloca inhibits many optimizations so try to get rid of it in common
5182 * cases.
5183 */
5186 {
5196 }
5198 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5201 /* From the INITOBJ case */
5213 }
5217 }
5218 load_error:
5220 }
5222 static gboolean
5224 {
5229 }
5231 }
5233 /*
5234 * mono_method_to_ir:
5235 *
5236 * Translate the .net IL into linear IR.
5237 */
5238 int
5239 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5242 {
5243 MonoError error;
5263 guint num_args;
5266 MonoDeclSecurityActions actions;
5272 /* serialization and xdomain stuff may need access to private fields and methods */
5282 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5296 cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
5297 }
5299 }
5311 /*
5312 * Methods without init_locals set could cause asserts in various passes
5313 * (#497220).
5314 */
5321 }
5323 /* SkipVerification is not allowed if core-clr is enabled */
5327 }
5347 }
5355 }
5357 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5378 /* ENTRY BLOCK */
5384 /* EXIT BLOCK */
5396 }
5397 /* handle exception clauses */
5418 /* todo: is a fault block unsafe to optimize? */
5421 }
5424 /*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);
5425 while (p < end) {
5426 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5427 }*/
5428 /* catch and filter blocks get the exception object on the stack */
5433 /* mostly like handle_stack_args (), but just sets the input args */
5434 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5439 /*
5440 * Add a dummy use for the exvar so its liveness info will be
5441 * correct.
5442 */
5452 /* The filter block shares the exvar with the handler block */
5456 }
5457 }
5463 /*
5464 * In shared generic code with catch
5465 * clauses containing type variables
5466 * the exception handling code has to
5467 * be able to get to the rgctx.
5468 * Therefore we have to make sure that
5469 * the vtable/mrgctx argument (for
5470 * static or generic methods) or the
5471 * "this" argument (for non-static
5472 * methods) are live.
5473 */
5482 }
5483 }
5484 }
5490 }
5492 /* FIRST CODE BLOCK */
5505 }
5506 }
5512 /* at this point having security doesn't mean we have any code to generate */
5514 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5515 * And we do not want to enter the next section (with allocation) if we
5516 * have nothing to generate */
5518 }
5520 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
5527 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
5530 }
5538 }
5541 }
5543 /* not a P/Invoke after all */
5545 }
5546 }
5548 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
5549 /* we use a separate basic block for the initialization code */
5562 }
5564 /* at this point we know, if security is TRUE, that some code needs to be generated */
5571 /* Add code for SecurityAction.Demand */
5574 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5576 }
5578 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
5579 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
5582 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5584 }
5586 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
5589 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
5591 }
5592 }
5594 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
5597 }
5600 /* check if this is native code, e.g. an icall or a p/invoke */
5607 /* if this ia a native call then it can only be JITted from platform code */
5613 }
5614 }
5615 }
5616 }
5617 }
5620 UNVERIFIED;
5624 UNVERIFIED;
5625 }
5632 UNVERIFIED;
5633 }
5636 /* We force the vtable variable here for all shared methods
5637 for the possibility that they might show up in a stack
5638 trace where their exact instantiation is needed. */
5645 /* FIXME: Is there a better way to do this?
5646 We need the variable live for the duration
5647 of the whole method. */
5649 }
5650 }
5652 /* add a check for this != NULL to inlined methods */
5659 }
5666 UNVERIFIED;
5667 }
5669 }
5671 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
5672 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
5680 else
5692 }
5702 }
5713 }
5722 }
5725 }
5726 }
5744 }
5748 }
5749 }
5750 /*
5751 * Sequence points are points where the debugger can place a breakpoint.
5752 * Currently, we generate these automatically at points where the IL
5753 * stack is empty.
5754 */
5758 }
5766 /* TODO: Use an increment here */
5767 #if defined(TARGET_X86)
5772 #else
5775 #endif
5776 }
5779 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
5785 else
5787 ip++;
5793 else
5795 ip++;
5806 ip++;
5817 ip++;
5829 UNVERIFIED;
5834 }
5861 UNVERIFIED;
5884 }
5890 }
5897 UNVERIFIED;
5960 #ifdef TARGET_POWERPC
5961 /* FIXME: Clean this up */
5964 #endif
5966 /* FIXME: we should really allocate this only late in the compilation process */
5986 }
5992 }
5997 #ifdef TARGET_POWERPC
5998 /* FIXME: Clean this up */
6001 #endif
6003 /* FIXME: we should really allocate this only late in the compilation process */
6023 }
6029 }
6034 sp--;
6049 }
6052 ip++;
6055 #ifdef TARGET_X86
6057 /* we need to pop the value from the x86 FP stack */
6059 #endif
6064 INLINE_FAILURE;
6068 UNVERIFIED;
6070 /* FIXME: check the signature matches */
6080 CHECK_CFG_EXCEPTION;
6082 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6083 {
6087 /* Handle tail calls similarly to calls */
6101 }
6102 #else
6104 /* Prevent arguments from being optimized away */
6111 #endif
6116 }
6143 else
6151 /*
6152 * This is a call through a function pointer using a pinvoke
6153 * signature. Have to create a wrapper and call that instead.
6154 * FIXME: This is very slow, need to create a wrapper at JIT time
6155 * instead based on the signature.
6156 */
6161 }
6169 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6170 /*
6171 * This is needed since get_method_constrained can't find
6172 * the method in klass representing a type var.
6173 * The type var is guaranteed to be a reference type in this
6174 * case.
6175 */
6180 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6181 }
6185 }
6192 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6193 }
6196 METHOD_ACCESS_FAILURE;
6197 }
6203 /* MS.NET seems to silently convert this to a callvirt */
6206 {
6207 /*
6208 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
6209 * converts to a callvirt.
6210 *
6211 * tests/bug-515884.il is an example of this behavior
6212 */
6213 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
6215 if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
6217 }
6241 }
6242 }
6250 INLINE_FAILURE;
6251 CHECK_CFG_EXCEPTION;
6252 }
6256 }
6259 UNVERIFIED;
6266 //g_assert (!virtual || fsig->hasthis);
6271 /*
6272 * We have the `constrained.' prefix opcode.
6273 */
6275 /*
6276 * The type parameter is instantiated as a valuetype,
6277 * but that type doesn't override the method we're
6278 * calling, so we need to box `this'.
6279 */
6282 sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
6283 CHECK_CFG_EXCEPTION;
6287 /*
6288 * The type parameter is instantiated as a reference
6289 * type. We have a managed pointer on the stack, so
6290 * we need to dereference it here.
6291 */
6298 }
6301 UNVERIFIED;
6303 /*
6304 * If the callee is a shared method, then its static cctor
6305 * might not get called after the call was patched.
6306 */
6307 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)) {
6310 }
6318 /*
6319 * Pass vtable iff target method might
6320 * be shared, which means that sharing
6321 * is enabled for its class and its
6322 * context is sharable (and it's not a
6323 * generic method).
6324 */
6328 }
6340 }
6348 /* Generic method interface
6349 calls are resolved via a
6350 helper function and don't
6351 need an imt. */
6354 }
6356 /*
6357 * If a shared method calls another
6358 * shared method then the caller must
6359 * have a generic sharing context
6360 * because the magic trampoline
6361 * requires it. FIXME: We shouldn't
6362 * have to force the vtable/mrgctx
6363 * variable here. Instead there
6364 * should be a flag in the cfg to
6365 * request a generic sharing context.
6366 */
6370 }
6380 }
6381 }
6387 /*
6388 * emit_get_rgctx_method () calls mono_class_vtable () so check
6389 * for type load errors before.
6390 */
6393 }
6402 }
6403 }
6411 }
6416 /* Calling virtual generic methods */
6427 /* Prevent inlining of methods that contain indirect calls */
6428 INLINE_FAILURE;
6430 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
6439 #endif
6440 {
6445 /* FIXME: This should be a managed pointer */
6458 }
6463 CHECK_CFG_EXCEPTION;
6468 }
6470 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6471 supported_tail_call = cmethod && MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
6472 #else
6473 supported_tail_call = cmethod && mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6474 #endif
6476 /* Tail prefix */
6477 /* FIXME: runtime generic context pointer for jumps? */
6478 /* FIXME: handle this for generic sharing eventually */
6479 if ((ins_flag & MONO_INST_TAILCALL) && !cfg->generic_sharing_context && !vtable_arg && cmethod && (*ip == CEE_CALL) && supported_tail_call) {
6482 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6483 INLINE_FAILURE;
6485 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6486 /* Handle tail calls similarly to calls */
6488 #else
6494 /*
6495 * We implement tail calls by storing the actual arguments into the
6496 * argument variables, then emitting a CEE_JMP.
6497 */
6499 /* Prevent argument from being register allocated */
6502 }
6503 #endif
6512 CHECK_CFG_EXCEPTION;
6514 /* skip CEE_RET as well */
6518 }
6520 /* Conversion to a JIT intrinsic */
6521 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6525 sp++;
6526 }
6528 CHECK_CFG_EXCEPTION;
6533 }
6535 /* Inlining */
6537 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
6545 /* Prevent inlining of methods that call wrappers */
6546 INLINE_FAILURE;
6549 }
6551 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, allways))) {
6557 /* *sp is already set by inline_method */
6558 sp++;
6563 }
6564 }
6568 /* Tail recursion elimination */
6569 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
6573 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6574 INLINE_FAILURE;
6576 /* keep it simple */
6580 }
6592 /* skip the CEE_RET, too */
6595 else
6600 }
6601 }
6603 /* Generic sharing */
6604 /* FIXME: only do this for generic methods if
6605 they are not shared! */
6611 INLINE_FAILURE;
6616 /*
6617 * We are compiling a call to a
6618 * generic method from shared code,
6619 * which means that we have to look up
6620 * the method in the rgctx and do an
6621 * indirect call.
6622 */
6623 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
6624 }
6626 /* Indirect calls */
6634 else
6635 /* FIXME: what the hell is this??? */
6639 /* Prevent inlining of methods with indirect calls */
6640 INLINE_FAILURE;
6652 /*
6653 * Instead of emitting an indirect call, emit a direct call
6654 * with the contents of the aotconst as the patch info.
6655 */
6656 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
6658 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
6659 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
6663 }
6664 }
6668 CHECK_CFG_EXCEPTION;
6673 }
6675 /* Array methods */
6687 }
6690 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, sp [fsig->param_count]->dreg);
6707 }
6709 CHECK_CFG_EXCEPTION;
6714 }
6721 CHECK_CFG_EXCEPTION;
6726 }
6728 /* Common call */
6729 INLINE_FAILURE;
6734 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, imt_arg);
6736 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, NULL);
6737 }
6742 CHECK_CFG_EXCEPTION;
6747 }
6750 /* return from inlined method */
6751 /*
6752 * If in_count == 0, that means the ret is unreachable due to
6753 * being preceeded by a throw. In that case, inline_method () will
6754 * handle setting the return value
6755 * (test case: test_0_inline_throw ()).
6756 */
6761 //g_assert (returnvar != -1);
6764 }
6770 /*
6771 * Place a seq point here too even through the IL stack is not
6772 * empty, so a step over on
6773 * call <FOO>
6774 * ret
6775 * will work correctly.
6776 */
6779 }
6796 }
6798 #ifdef MONO_ARCH_SOFT_FLOAT
6808 }
6809 #else
6811 #endif
6812 }
6813 }
6814 }
6816 UNVERIFIED;
6818 ip++;
6827 ip++;
6837 }
6855 ip++;
6857 ip++;
6867 ip++;
6878 }
6897 UNVERIFIED;
6898 ip ++;
6902 sp--;
6912 }
6919 #if SIZEOF_REGISTER == 4
6921 /* Convert it to OP_LCOMPARE */
6929 }
6930 #endif
6946 }
6960 ip++;
6978 gboolean use_op_switch;
6986 UNVERIFIED;
6999 }
7002 /*
7003 * Link the current bb with the targets as well, so handle_stack_args
7004 * will set their in_stack correctly.
7005 */
7013 }
7027 #ifdef TARGET_ARM
7028 /* ARM implements SWITCH statements differently */
7029 /* FIXME: Make it use the generic implementation */
7032 #endif
7049 else
7052 #if SIZEOF_REGISTER == 8
7053 /* The upper word might not be zero, and we add it to a 64 bit address later */
7055 #endif
7065 }
7067 /* FIXME: Use load_memindex */
7071 }
7075 }
7100 }
7126 #if HAVE_WRITE_BARRIERS
7127 if (*ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0))) {
7129 /* insert call to write barrier */
7133 }
7134 #endif
7151 /* Use the immediate opcodes if possible */
7160 }
7161 }
7166 ip++;
7191 /* FIXME: Pass opcode to is_inst_imm */
7193 /* Use the immediate opcodes if possible */
7194 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)) {
7201 #if SIZEOF_REGISTER == 8
7203 #else
7206 #endif
7207 }
7208 else
7212 /* Might be followed by an instruction added by ADD_WIDEN_OP */
7215 }
7216 }
7220 ip++;
7237 /* Special case this earlier so we have long constants in the IR */
7242 #if SIZEOF_REGISTER == 8
7245 else
7247 #else
7251 else
7253 #endif
7255 }
7258 }
7259 ip++;
7273 }
7274 ip++;
7286 }
7287 ip++;
7305 CHECK_CFG_EXCEPTION;
7306 ip++;
7316 ip++;
7337 #if HAVE_WRITE_BARRIERS
7343 }
7344 #endif
7347 }
7362 /* Optimize the common ldobj+stloc combination */
7377 }
7387 }
7389 /* Optimize the ldobj+stobj combination */
7390 /* The reference case ends up being a load+store anyway */
7391 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7394 sp --;
7401 }
7410 }
7420 }
7432 }
7443 /*
7444 * Avoid relocations in AOT and save some space by using a
7445 * version of helper_ldstr specialized to mscorlib.
7446 */
7450 /* Avoid creating the string object */
7454 }
7455 }
7456 else
7461 }
7468 }
7469 }
7470 }
7472 sp++;
7478 MonoInst this_ins;
7501 INLINE_FAILURE;
7502 CHECK_CFG_EXCEPTION;
7505 }
7524 }
7525 }
7526 }
7531 /*
7532 * Generate smaller code for the common newobj <exception> instruction in
7533 * argument checking code.
7534 */
7561 }
7566 }
7568 /* move the args to allow room for 'this' in the first position */
7572 }
7574 /* check_call_signature () requires sp[0] to be set */
7578 UNVERIFIED;
7588 /* Avoid varargs in the common case */
7595 else
7600 /* we simply pass a null pointer */
7602 /* now call the string ctor */
7614 /*
7615 * The code generated by mini_emit_virtual_call () expects
7616 * iargs [0] to be a boxed instance, but luckily the vcall
7617 * will be transformed into a normal call there.
7618 */
7627 /*
7628 * TypeInitializationExceptions thrown from the mono_runtime_class_init
7629 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
7630 * As a workaround, we call class cctors before allocating objects.
7631 */
7632 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
7633 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
7635 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
7637 }
7641 }
7647 /* Now call the actual ctor */
7648 /* Avoid virtual calls to ctors if possible */
7653 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
7657 sp++;
7658 }
7660 CHECK_CFG_EXCEPTION;
7671 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
7677 INLINE_FAILURE;
7679 }
7690 INLINE_FAILURE;
7693 }
7694 }
7697 /* Valuetype */
7701 }
7702 else
7708 }
7717 UNVERIFIED;
7725 /* obj */
7728 /* klass */
7735 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7754 }
7757 CHECK_CFG_EXCEPTION;
7761 }
7771 UNVERIFIED;
7779 /* obj */
7782 /* klass */
7786 sp++;
7789 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7808 }
7811 CHECK_CFG_EXCEPTION;
7815 }
7817 }
7832 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
7836 /* obj */
7838 /* klass */
7865 CHECK_CFG_EXCEPTION;
7869 }
7871 }
7878 }
7880 /* UNBOX */
7886 /* LDOBJ */
7892 }
7913 }
7916 UNVERIFIED;
7918 UNVERIFIED;
7919 /* frequent check in generic code: box (struct), brtrue */
7921 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
7922 /*printf ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
7927 ip++;
7929 ip++;
7932 ip++;
7935 }
7940 /*
7941 * This leads to some inconsistency, since the two bblocks are
7942 * not really connected, but it is needed for handling stack
7943 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
7944 * FIXME: This should only be needed if sp != stack_start, but that
7945 * doesn't work for some reason (test failure in mcs/tests on x86).
7946 */
7952 }
7956 }
7960 CHECK_CFG_EXCEPTION;
7964 }
7988 }
7992 }
7998 guint foffset;
8006 }
8008 UNVERIFIED;
8010 UNVERIFIED;
8016 }
8019 }
8023 FIELD_ACCESS_FAILURE;
8026 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
8027 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
8028 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8029 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8030 */
8035 UNVERIFIED;
8036 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8058 }
8067 #if HAVE_WRITE_BARRIERS
8068 if (mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
8069 /* insert call to write barrier */
8080 }
8081 #endif
8084 }
8088 }
8090 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8091 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
8097 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
8112 }
8117 /* Have to compute the address of the variable */
8122 else
8127 }
8145 }
8146 }
8150 }
8156 gboolean is_special_static;
8164 }
8165 else
8171 FIELD_ACCESS_FAILURE;
8173 /* if the class is Critical then transparent code cannot access it's fields */
8177 /*
8178 * We can only support shared generic static
8179 * field access on architectures where the
8180 * trampoline code has been extended to handle
8181 * the generic class init.
8182 */
8183 #ifndef MONO_ARCH_VTABLE_REG
8185 #endif
8192 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8193 * to be called here.
8194 */
8198 }
8206 /* Generate IR to compute the field address */
8207 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
8208 /*
8209 * Fast access to TLS data
8210 * Inline version of get_thread_static_data () in
8211 * threads.c.
8212 */
8213 guint32 offset;
8217 // offset &= 0x7fffffff;
8218 // idx = (offset >> 24) - 1;
8219 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
8224 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
8229 /* For TLS variables, this will return the TLS offset */
8252 }
8265 }
8270 /*
8271 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8272 method->klass->name_space, method->klass->name, method->name,
8273 depth, field->offset);
8274 */
8279 /*
8280 * The pointer we're computing here is
8281 *
8282 * super_info.static_data + field->offset
8283 */
8292 }
8305 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8306 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8308 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8313 /* This makes so that inline cannot trigger */
8314 /* .cctors: too many apps depend on them */
8315 /* running with a specific order... */
8317 INLINE_FAILURE;
8322 }
8323 }
8324 }
8329 else
8335 }
8336 }
8338 /* Generate IR to do the actual load/store operation */
8347 sp--;
8358 }
8365 }
8366 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8372 sp++;
8376 sp++;
8381 sp++;
8385 sp++;
8390 sp++;
8394 sp++;
8400 #ifndef HAVE_MOVING_COLLECTOR
8406 #endif
8409 sp++;
8414 sp++;
8422 }
8423 }
8434 }
8435 }
8439 }
8447 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
8449 #if HAVE_WRITE_BARRIERS
8453 /* insert call to write barrier */
8457 }
8458 #endif
8464 /*
8465 * Array opcodes
8466 */
8471 guint32 field_token;
8492 }
8497 /* FIXME: we cannot get a managed
8498 allocator because we can't get the
8499 open generic class's vtable. We
8500 have the same problem in
8501 handle_alloc(). This
8502 needs to be solved so that we can
8503 have managed allocs of shared
8504 generic classes. */
8505 /*
8506 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
8507 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
8508 */
8511 /* FIXME: Decompose later to help abcrem */
8513 /* vtable */
8516 /* array len */
8521 else
8525 /* Decompose now to avoid problems with references to the domainvar */
8534 /* Decompose later since it is needed by abcrem */
8549 /* Needed so mono_emit_load_get_addr () gets called */
8551 }
8552 }
8559 /*
8560 * we inline/optimize the initialization sequence if possible.
8561 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
8562 * for small sizes open code the memcpy
8563 * ensure the rva field is big enough
8564 */
8565 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))) {
8570 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
8572 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
8575 }
8579 }
8582 }
8587 UNVERIFIED;
8597 ip ++;
8605 UNVERIFIED;
8611 /* we need to make sure that this array is exactly the type it needs
8612 * to be for correctness. the wrappers are lax with their usage
8613 * so we need to ignore them here
8614 */
8619 }
8649 }
8650 else
8654 UNVERIFIED;
8661 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8668 }
8672 else
8675 }
8698 }
8699 else
8703 UNVERIFIED;
8705 /* storing a NULL doesn't need any of the complex checks in stelemref */
8712 UNVERIFIED;
8714 UNVERIFIED;
8725 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8732 }
8733 }
8737 else
8741 }
8756 }
8774 // FIXME:
8777 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
8787 // FIXME:
8792 }
8793 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
8798 }
8813 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
8821 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
8822 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8823 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8829 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
8830 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8831 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8833 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
8834 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
8835 }
8836 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
8844 }
8846 gpointer handle;
8860 }
8863 }
8870 /* This case handles ldtoken
8871 of an open type, like for
8872 typeof(Gen<>). */
8875 /* If we get a MONO_TYPE_CLASS
8876 then we need to provide the
8877 open type, not an
8878 instantiation of it. */
8881 else
8887 else
8889 }
8899 else
8913 }
8934 /* Special case for static synchronized wrappers */
8935 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
8937 /* FIXME: n is not a normal token */
8940 }
8943 }
8946 }
8959 MONO_RGCTX_INFO_TYPE);
8968 }
8973 }
8977 }
8978 }
8983 }
8989 ip++;
9002 ip++;
9005 /*
9006 * Control will leave the method so empty the stack, otherwise
9007 * the next basic block will start with a nonempty stack.
9008 */
9010 sp--;
9011 }
9023 }
9025 /* empty the stack */
9027 sp--;
9028 }
9030 /*
9031 * If this leave statement is in a catch block, check for a
9032 * pending exception, and rethrow it if necessary.
9033 * We avoid doing this in runtime invoke wrappers, since those are called
9034 * by native code which excepts the wrapper to catch all exceptions.
9035 */
9039 /*
9040 * Use <= in the final comparison to handle clauses with multiple
9041 * leave statements, like in bug #78024.
9042 * The ordering of the exception clauses guarantees that we find the
9043 * innermost clause.
9044 */
9045 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) {
9049 /*
9050 MonoInst *load;
9052 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
9053 */
9059 /*
9060 * Currently, we allways rethrow the abort exception, despite the
9061 * fact that this is not correct. See thread6.cs for an example.
9062 * But propagating the abort exception is more important than
9063 * getting the sematics right.
9064 */
9071 }
9072 }
9091 /*
9092 * Link the finally bblock with the target, since it will
9093 * conceptually branch there.
9094 * FIXME: Have to link the bblock containing the endfinally.
9095 */
9098 }
9099 }
9101 }
9112 else
9116 }
9118 /*
9119 * Mono specific opcodes
9120 */
9128 gpointer func;
9147 }
9149 gpointer ptr;
9156 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9166 /* Will be transformed into an AOTCONST later */
9171 }
9172 }
9173 /* FIXME: Generalize this */
9179 }
9184 /* Can't embed random pointers into AOT code */
9187 }
9190 gpointer ptr;
9204 }
9208 }
9215 // FIXME:
9221 }
9238 }
9251 /*
9252 * Similar to LDOBJ, but instead load the unmanaged
9253 * representation of the vtype to the stack.
9254 */
9263 {
9278 }
9281 /*
9282 * Same as RET, but return the native representation of a vtype
9283 * to the caller.
9284 */
9300 }
9304 UNVERIFIED;
9313 }
9324 else
9330 }
9333 #ifdef MONO_ARCH_HAVE_LMF_OPS
9337 #endif
9367 /* It would be easier to call a trampoline, but that would put an
9368 * extra frame on the stack, confusing exception handling. So
9369 * implement it inline using an opcode for now.
9370 */
9373 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9374 /* prevent it from being register allocated */
9376 }
9378 /* Has to use a call inst since it local regalloc expects it */
9386 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
9388 #endif
9394 }
9398 }
9400 }
9406 /* somewhat similar to LDTOKEN */
9409 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
9420 }
9428 /*
9429 * The following transforms:
9430 * CEE_CEQ into OP_CEQ
9431 * CEE_CGT into OP_CGT
9432 * CEE_CGT_UN into OP_CGT_UN
9433 * CEE_CLT into OP_CLT
9434 * CEE_CLT_UN into OP_CLT_UN
9435 */
9444 if ((sp [0]->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
9448 else
9456 /*
9457 * The backends expect the fceq opcodes to do the
9458 * comparison too.
9459 */
9463 }
9468 }
9472 gboolean needs_static_rgctx_invoke;
9491 METHOD_ACCESS_FAILURE;
9495 INLINE_FAILURE;
9496 CHECK_CFG_EXCEPTION;
9499 }
9501 /*
9502 * Optimize the common case of ldftn+delegate creation
9503 */
9504 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
9505 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
9517 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE) && !defined(HAVE_WRITE_BARRIERS)
9518 /* FIXME: SGEN support */
9524 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9526 sp --;
9528 CHECK_CFG_EXCEPTION;
9530 sp ++;
9532 }
9533 #endif
9534 }
9535 }
9544 }
9561 INLINE_FAILURE;
9562 CHECK_CFG_EXCEPTION;
9565 }
9575 else
9581 }
9608 UNVERIFIED;
9632 }
9638 }
9646 UNVERIFIED;
9655 UNVERIFIED;
9657 /*
9658 * Inlining this into a loop in a parent could lead to
9659 * stack overflows which is different behavior than the
9660 * non-inlined case, thus disable inlining in this case.
9661 */
9684 UNVERIFIED;
9696 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
9700 }
9701 }
9704 UNVERIFIED;
9707 }
9710 /* FIXME: record alignment? we can assume 1 for now */
9721 /* Can't inline tail calls at this time */
9734 else
9744 else
9755 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
9757 } 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)) {
9758 /* emit_memset only works when val == 0 */
9770 }
9771 }
9775 }
9782 /* we ignore the no-nullcheck for now since we
9783 * really do it explicitly only when doing callvirt->call
9784 */
9793 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
9796 }
9797 }
9816 }
9818 guint32 align;
9824 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic) {
9832 }
9837 }
9844 // FIXME:
9847 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9849 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
9853 }
9864 UNVERIFIED;
9868 UNVERIFIED;
9869 }
9871 }
9874 UNVERIFIED;
9878 UNVERIFIED;
9879 }
9880 }
9882 UNVERIFIED;
9895 }
9899 }
9902 }
9904 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
9906 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
9908 #endif
9943 }
9944 }
9945 }
9948 /* Emit initialization for ref vars */
9949 // FIXME: Avoid duplication initialization for IL locals.
9955 }
9956 }
9958 /* Add a sequence point for method entry/exit events */
9964 }
9976 }
9977 }
9985 /* Method is too large */
9993 }
10002 exception_exit:
10006 inline_failure:
10009 load_error:
10013 unverified:
10017 cleanup:
10023 }
10025 static int
10027 {
10041 }
10044 }
10048 int
10050 {
10112 #if defined(TARGET_X86) || defined (TARGET_AMD64)
10117 #endif
10118 #if defined(TARGET_AMD64)
10121 #endif
10132 }
10135 }
10137 static int
10139 {
10165 }
10168 }
10170 static int
10172 {
10191 }
10194 }
10196 int
10198 {
10199 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10200 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10212 #if SIZEOF_REGISTER == 8
10215 #endif
10216 }
10217 #endif
10220 }
10224 {
10225 #if defined(TARGET_X86)
10257 }
10258 #endif
10260 #if defined(TARGET_AMD64)
10261 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10312 }
10313 #endif
10316 }
10320 {
10321 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10329 }
10330 #endif
10333 }
10337 {
10338 #ifdef TARGET_X86
10339 /* FIXME: This has sign extension issues */
10340 /*
10341 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10342 return OP_X86_COMPARE_MEMBASE8_IMM;
10343 */
10345 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10357 }
10358 #endif
10360 #ifdef TARGET_AMD64
10361 /* FIXME: This has sign extension issues */
10362 /*
10363 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10364 return OP_X86_COMPARE_MEMBASE8_IMM;
10365 */
10372 /* FIXME: This only works for 32 bit immediates
10373 case OP_COMPARE_IMM:
10374 case OP_LCOMPARE_IMM:
10375 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10376 return OP_AMD64_COMPARE_MEMBASE_IMM;
10377 */
10391 }
10392 #endif
10395 }
10399 {
10400 #ifdef TARGET_X86
10401 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10418 }
10419 #endif
10421 #ifdef TARGET_AMD64
10462 }
10463 #endif
10466 }
10468 int
10470 {
10472 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
10477 #endif
10478 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
10484 #endif
10487 }
10488 }
10490 #ifndef DISABLE_JIT
10492 /**
10493 * mono_handle_global_vregs:
10494 *
10495 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
10496 * for them.
10497 */
10498 void
10500 {
10507 #ifdef MONO_ARCH_SIMD_INTRINSICS
10510 #endif
10512 /* Find local vregs used in more than one bb */
10524 gint32 prev_bb;
10554 }
10556 #if SIZEOF_REGISTER == 4
10557 /* In the LLVM case, the long opcodes are not decomposed */
10559 /*
10560 * Since some instructions reference the original long vreg,
10561 * and some reference the two component vregs, it is quite hard
10562 * to determine when it needs to be global. So be conservative.
10563 */
10565 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10569 }
10571 /*
10572 * Make the component vregs volatile since the optimizations can
10573 * get confused otherwise.
10574 */
10577 }
10578 #endif
10584 /* 0 is a valid block num */
10587 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
10599 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10602 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
10609 }
10610 }
10612 /* Flag as having been used in more than one bb */
10614 }
10615 }
10616 }
10617 }
10619 /* If a variable is used in only one bblock, convert it into a local vreg */
10630 #if SIZEOF_REGISTER == 8
10632 #endif
10633 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
10634 /* Enabling this screws up the fp stack on x86 */
10636 #endif
10637 /* Arguments are implicitly global */
10638 /* Putting R4 vars into registers doesn't work currently */
10639 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) {
10640 /*
10641 * Make that the variable's liveness interval doesn't contain a call, since
10642 * that would cause the lvreg to be spilled, making the whole optimization
10643 * useless.
10644 */
10645 /* This is too slow for JIT compilation */
10646 #if 0
10666 }
10667 }
10672 ins_index ++;
10673 }
10677 }
10678 #endif
10684 }
10686 }
10687 }
10689 /*
10690 * Compress the varinfo and vars tables so the liveness computation is faster and
10691 * takes up less space.
10692 */
10704 #if SIZEOF_REGISTER == 4
10706 /* Modify the two component vars too */
10713 }
10714 #endif
10715 }
10716 pos ++;
10717 }
10718 }
10722 }
10724 /**
10725 * mono_spill_global_vars:
10726 *
10727 * Generate spill code for variables which are not allocated to registers,
10728 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
10729 * code is generated which could be optimized by the local optimization passes.
10730 */
10731 void
10733 {
10749 /* FIXME: Move this function to mini.c */
10753 #ifdef MONO_ARCH_SIMD_INTRINSICS
10755 #endif
10757 #if SIZEOF_REGISTER == 4
10758 /* Create MonoInsts for longs */
10785 }
10788 }
10789 }
10790 }
10791 #endif
10793 /* FIXME: widening and truncation */
10795 /*
10796 * As an optimization, when a variable allocated to the stack is first loaded into
10797 * an lvreg, we will remember the lvreg and use it the next time instead of loading
10798 * the variable again.
10799 */
10805 /*
10806 * These arrays contain the first and last instructions accessing a given
10807 * variable.
10808 * Since we emit bblocks in the same order we process them here, and we
10809 * don't split live ranges, these will precisely describe the live range of
10810 * the variable, i.e. the instruction range where a valid value can be found
10811 * in the variables location.
10812 * The live range is computed using the liveness info computed by the liveness pass.
10813 * We can't use vmv->range, since that is an abstract live range, and we need
10814 * one which is instruction precise.
10815 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
10816 */
10817 /* FIXME: Only do this if debugging info is requested */
10823 /* Add spill loads/stores */
10830 /* Clear vreg_to_lvreg array */
10848 /*
10849 * We handle LDADDR here as well, since it can only be decomposed
10850 * when variable addresses are known.
10851 */
10856 /* Happens on SPARC/S390 where vtypes are passed by reference */
10861 }
10867 NOT_IMPLEMENTED;
10874 }
10878 }
10883 }
10885 /*
10886 * Store opcodes have destbasereg in the dreg, but in reality, it is an
10887 * src register.
10888 * FIXME:
10889 */
10903 else
10913 }
10915 /***************/
10916 /* DREG */
10917 /***************/
10919 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
10933 } 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)) {
10934 /*
10935 * Instead of emitting a load+store, use a _membase opcode.
10936 */
10946 }
10949 guint32 lvreg;
10955 /* Invalidate any previous lvreg for this vreg */
10963 }
10968 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
10970 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
10973 }
10977 /* Try to fuse the store into the instruction itself */
10978 /* FIXME: Add more instructions */
10979 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
10985 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
11003 // FIXME: The backends expect the base reg to be in inst_basereg
11010 /* printf ("INS: "); mono_print_ins (ins); */
11011 /* Create a store instruction */
11012 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
11014 /* Insert it after the instruction */
11019 /*
11020 * We can't assign ins->dreg to var->dreg here, since the
11021 * sregs could use it. So set a flag, and do it after
11022 * the sregs.
11023 */
11024 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)))
11026 }
11027 }
11028 }
11033 }
11034 }
11036 /************/
11037 /* SREGS */
11038 /************/
11049 guint32 load_opcode;
11053 //mono_inst_set_src_registers (ins, sregs);
11057 }
11068 /* The variable is already loaded to an lvreg */
11072 //mono_inst_set_src_registers (ins, sregs);
11074 }
11076 /* Try to fuse the load into the instruction */
11080 //mono_inst_set_src_registers (ins, sregs);
11085 //mono_inst_set_src_registers (ins, sregs);
11092 //printf ("%d ", srcindex); mono_print_ins (ins);
11096 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) {
11098 /*
11099 * sreg refers to the value loaded by the load
11100 * emitted below, but we need to use ins->dreg
11101 * since it refers to the store emitted earlier.
11102 */
11104 }
11109 }
11110 }
11113 //mono_inst_set_src_registers (ins, sregs);
11116 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
11118 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
11121 }
11123 #if SIZEOF_REGISTER == 4
11125 #endif
11129 }
11130 }
11135 }
11136 }
11137 }
11146 }
11152 }
11155 /* Clear vreg_to_lvreg array */
11162 }
11166 }
11168 /* Extend the live range based on the liveness info */
11174 /* The liveness info is incomplete */
11178 /* Live from at least the first ins of this bb */
11181 }
11184 /* Live at least until the last ins of this bb */
11187 }
11188 }
11189 }
11190 }
11192 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11193 /*
11194 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11195 * by storing the current native offset into MonoMethodVar->live_range_start/end.
11196 */
11207 }
11214 else
11216 }
11217 }
11218 }
11219 #endif
11225 }
11227 /**
11228 * FIXME:
11229 * - use 'iadd' instead of 'int_add'
11230 * - handling ovf opcodes: decompose in method_to_ir.
11231 * - unify iregs/fregs
11232 * -> partly done, the missing parts are:
11233 * - a more complete unification would involve unifying the hregs as well, so
11234 * code wouldn't need if (fp) all over the place. but that would mean the hregs
11235 * would no longer map to the machine hregs, so the code generators would need to
11236 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11237 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11238 * fp/non-fp branches speeds it up by about 15%.
11239 * - use sext/zext opcodes instead of shifts
11240 * - add OP_ICALL
11241 * - get rid of TEMPLOADs if possible and use vregs instead
11242 * - clean up usage of OP_P/OP_ opcodes
11243 * - cleanup usage of DUMMY_USE
11244 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11245 * stack
11246 * - set the stack type and allocate a dreg in the EMIT_NEW macros
11247 * - get rid of all the <foo>2 stuff when the new JIT is ready.
11248 * - make sure handle_stack_args () is called before the branch is emitted
11249 * - when the new IR is done, get rid of all unused stuff
11250 * - COMPARE/BEQ as separate instructions or unify them ?
11251 * - keeping them separate allows specialized compare instructions like
11252 * compare_imm, compare_membase
11253 * - most back ends unify fp compare+branch, fp compare+ceq
11254 * - integrate mono_save_args into inline_method
11255 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11256 * - handle long shift opts on 32 bit platforms somehow: they require
11257 * 3 sregs (2 for arg1 and 1 for arg2)
11258 * - make byref a 'normal' type.
11259 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11260 * variable if needed.
11261 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11262 * like inline_method.
11263 * - remove inlining restrictions
11264 * - fix LNEG and enable cfold of INEG
11265 * - generalize x86 optimizations like ldelema as a peephole optimization
11266 * - add store_mem_imm for amd64
11267 * - optimize the loading of the interruption flag in the managed->native wrappers
11268 * - avoid special handling of OP_NOP in passes
11269 * - move code inserting instructions into one function/macro.
11270 * - try a coalescing phase after liveness analysis
11271 * - add float -> vreg conversion + local optimizations on !x86
11272 * - figure out how to handle decomposed branches during optimizations, ie.
11273 * compare+branch, op_jump_table+op_br etc.
11274 * - promote RuntimeXHandles to vregs
11275 * - vtype cleanups:
11276 * - add a NEW_VARLOADA_VREG macro
11277 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11278 * accessing vtype fields.
11279 * - get rid of I8CONST on 64 bit platforms
11280 * - dealing with the increase in code size due to branches created during opcode
11281 * decomposition:
11282 * - use extended basic blocks
11283 * - all parts of the JIT
11284 * - handle_global_vregs () && local regalloc
11285 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11286 * - sources of increase in code size:
11287 * - vtypes
11288 * - long compares
11289 * - isinst and castclass
11290 * - lvregs not allocated to global registers even if used multiple times
11291 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11292 * meaningful.
11293 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11294 * - add all micro optimizations from the old JIT
11295 * - put tree optimizations into the deadce pass
11296 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11297 * specific function.
11298 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11299 * fcompare + branchCC.
11300 * - create a helper function for allocating a stack slot, taking into account
11301 * MONO_CFG_HAS_SPILLUP.
11302 * - merge r68207.
11303 * - merge the ia64 switch changes.
11304 * - optimize mono_regstate2_alloc_int/float.
11305 * - fix the pessimistic handling of variables accessed in exception handler blocks.
11306 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11307 * parts of the tree could be separated by other instructions, killing the tree
11308 * arguments, or stores killing loads etc. Also, should we fold loads into other
11309 * instructions if the result of the load is used multiple times ?
11310 * - make the REM_IMM optimization in mini-x86.c arch-independent.
11311 * - LAST MERGE: 108395.
11312 * - when returning vtypes in registers, generate IR and append it to the end of the
11313 * last bb instead of doing it in the epilog.
11314 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
11315 */
11317 /*
11319 NOTES
11320 -----
11322 - When to decompose opcodes:
11323 - earlier: this makes some optimizations hard to implement, since the low level IR
11324 no longer contains the neccessary information. But it is easier to do.
11325 - later: harder to implement, enables more optimizations.
11326 - Branches inside bblocks:
11327 - created when decomposing complex opcodes.
11328 - branches to another bblock: harmless, but not tracked by the branch
11329 optimizations, so need to branch to a label at the start of the bblock.
11330 - branches to inside the same bblock: very problematic, trips up the local
11331 reg allocator. Can be fixed by spitting the current bblock, but that is a
11332 complex operation, since some local vregs can become global vregs etc.
11333 - Local/global vregs:
11334 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
11335 local register allocator.
11336 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
11337 structure, created by mono_create_var (). Assigned to hregs or the stack by
11338 the global register allocator.
11339 - When to do optimizations like alu->alu_imm:
11340 - earlier -> saves work later on since the IR will be smaller/simpler
11341 - later -> can work on more instructions
11342 - Handling of valuetypes:
11343 - When a vtype is pushed on the stack, a new temporary is created, an
11344 instruction computing its address (LDADDR) is emitted and pushed on
11345 the stack. Need to optimize cases when the vtype is used immediately as in
11346 argument passing, stloc etc.
11347 - Instead of the to_end stuff in the old JIT, simply call the function handling
11348 the values on the stack before emitting the last instruction of the bb.
11349 */