| blob | 2bb20a8e07141da8a4a3a29bfa596b1463cb1105 |
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 #ifdef HAVE_VALGRIND_MEMCHECK_H
31 #include <valgrind/memcheck.h>
32 #endif
34 #include <mono/metadata/assembly.h>
35 #include <mono/metadata/loader.h>
36 #include <mono/metadata/tabledefs.h>
37 #include <mono/metadata/class.h>
38 #include <mono/metadata/object.h>
39 #include <mono/metadata/exception.h>
40 #include <mono/metadata/opcodes.h>
41 #include <mono/metadata/mono-endian.h>
42 #include <mono/metadata/tokentype.h>
43 #include <mono/metadata/tabledefs.h>
44 #include <mono/metadata/marshal.h>
45 #include <mono/metadata/debug-helpers.h>
46 #include <mono/metadata/mono-debug.h>
47 #include <mono/metadata/gc-internal.h>
48 #include <mono/metadata/security-manager.h>
49 #include <mono/metadata/threads-types.h>
50 #include <mono/metadata/security-core-clr.h>
51 #include <mono/metadata/monitor.h>
52 #include <mono/utils/mono-compiler.h>
61 #define BRANCH_COST 100
62 #define INLINE_LENGTH_LIMIT 20
63 #define INLINE_FAILURE do {\
64 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
65 goto inline_failure;\
66 } while (0)
67 #define CHECK_CFG_EXCEPTION do {\
68 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
69 goto exception_exit;\
70 } while (0)
71 #define METHOD_ACCESS_FAILURE do { \
72 char *method_fname = mono_method_full_name (method, TRUE); \
73 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
74 cfg->exception_type = MONO_EXCEPTION_METHOD_ACCESS; \
75 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
76 g_free (method_fname); \
77 g_free (cil_method_fname); \
78 goto exception_exit; \
79 } while (0)
80 #define FIELD_ACCESS_FAILURE do { \
81 char *method_fname = mono_method_full_name (method, TRUE); \
82 char *field_fname = mono_field_full_name (field); \
83 cfg->exception_type = MONO_EXCEPTION_FIELD_ACCESS; \
84 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
85 g_free (method_fname); \
86 g_free (field_fname); \
87 goto exception_exit; \
88 } while (0)
89 #define GENERIC_SHARING_FAILURE(opcode) do { \
90 if (cfg->generic_sharing_context) { \
91 if (cfg->verbose_level > 2) \
92 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__); \
93 cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED; \
94 goto exception_exit; \
95 } \
96 } while (0)
98 /* Determine whenever 'ins' represents a load of the 'this' argument */
99 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
107 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
108 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
111 /* helper methods signature */
118 /*
119 * Instruction metadata
120 */
121 #ifdef MINI_OP
122 #undef MINI_OP
123 #endif
124 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2,
130 #if SIZEOF_REGISTER == 8
131 #define LREG IREG
132 #else
134 #endif
135 /* keep in sync with the enum in mini.h */
136 const char
137 ins_info[] = {
139 };
140 #undef MINI_OP
144 #define MONO_INIT_VARINFO(vi,id) do { \
145 (vi)->range.first_use.pos.bid = 0xffff; \
146 (vi)->reg = -1; \
147 (vi)->idx = (id); \
148 } while (0)
150 guint32
152 {
154 }
156 guint32
158 {
160 }
162 guint32
164 {
166 }
168 guint32
170 {
172 }
174 guint
176 {
180 handle_enum:
206 #if SIZEOF_REGISTER == 8
208 #else
210 #endif
219 }
234 }
236 }
238 void
240 {
253 }
255 /*
256 * Can't put this at the beginning, since other files reference stuff from this
257 * file.
258 */
259 #ifndef DISABLE_JIT
261 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
263 #define GET_BBLOCK(cfg,tblock,ip) do { \
264 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
265 if (!(tblock)) { \
266 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
267 NEW_BBLOCK (cfg, (tblock)); \
268 (tblock)->cil_code = (ip); \
269 ADD_BBLOCK (cfg, (tblock)); \
270 } \
271 } while (0)
273 #if defined(__i386__) || defined(__x86_64__)
274 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
275 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
276 (dest)->dreg = alloc_preg ((cfg)); \
277 (dest)->sreg1 = (sr1); \
278 (dest)->sreg2 = (sr2); \
279 (dest)->inst_imm = (imm); \
280 (dest)->backend.shift_amount = (shift); \
281 MONO_ADD_INS ((cfg)->cbb, (dest)); \
282 } while (0)
283 #endif
285 #if SIZEOF_REGISTER == 8
286 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
288 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
289 MonoInst *widen; \
290 int dr = alloc_preg (cfg); \
291 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
292 (ins)->sreg2 = widen->dreg; \
293 } \
294 } while (0)
295 #else
296 #define ADD_WIDEN_OP(ins, arg1, arg2)
297 #endif
299 #define ADD_BINOP(op) do { \
300 MONO_INST_NEW (cfg, ins, (op)); \
301 sp -= 2; \
302 ins->sreg1 = sp [0]->dreg; \
303 ins->sreg2 = sp [1]->dreg; \
304 type_from_op (ins, sp [0], sp [1]); \
305 CHECK_TYPE (ins); \
307 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
308 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
309 MONO_ADD_INS ((cfg)->cbb, (ins)); \
310 *sp++ = ins; \
311 mono_decompose_opcode ((cfg), (ins)); \
312 } while (0)
314 #define ADD_UNOP(op) do { \
315 MONO_INST_NEW (cfg, ins, (op)); \
316 sp--; \
317 ins->sreg1 = sp [0]->dreg; \
318 type_from_op (ins, sp [0], NULL); \
319 CHECK_TYPE (ins); \
320 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
321 MONO_ADD_INS ((cfg)->cbb, (ins)); \
322 *sp++ = ins; \
323 mono_decompose_opcode (cfg, ins); \
324 } while (0)
326 #define ADD_BINCOND(next_block) do { \
327 MonoInst *cmp; \
328 sp -= 2; \
329 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
330 cmp->sreg1 = sp [0]->dreg; \
331 cmp->sreg2 = sp [1]->dreg; \
332 type_from_op (cmp, sp [0], sp [1]); \
333 CHECK_TYPE (cmp); \
334 type_from_op (ins, sp [0], sp [1]); \
335 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
336 GET_BBLOCK (cfg, tblock, target); \
337 link_bblock (cfg, bblock, tblock); \
338 ins->inst_true_bb = tblock; \
339 if ((next_block)) { \
340 link_bblock (cfg, bblock, (next_block)); \
341 ins->inst_false_bb = (next_block); \
342 start_new_bblock = 1; \
343 } else { \
344 GET_BBLOCK (cfg, tblock, ip); \
345 link_bblock (cfg, bblock, tblock); \
346 ins->inst_false_bb = tblock; \
347 start_new_bblock = 2; \
348 } \
349 if (sp != stack_start) { \
350 handle_stack_args (cfg, stack_start, sp - stack_start); \
351 CHECK_UNVERIFIABLE (cfg); \
352 } \
353 MONO_ADD_INS (bblock, cmp); \
354 MONO_ADD_INS (bblock, ins); \
355 } while (0)
357 /* *
358 * link_bblock: Links two basic blocks
359 *
360 * links two basic blocks in the control flow graph, the 'from'
361 * argument is the starting block and the 'to' argument is the block
362 * the control flow ends to after 'from'.
363 */
364 static void
366 {
370 #if 0
373 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
374 else
379 else
381 }
382 #endif
389 }
390 }
395 }
399 }
406 }
407 }
412 }
416 }
417 }
419 void
421 {
423 }
425 /**
426 * mono_find_block_region:
427 *
428 * We mark each basic block with a region ID. We use that to avoid BB
429 * optimizations when blocks are in different regions.
430 *
431 * Returns:
432 * A region token that encodes where this region is, and information
433 * about the clause owner for this block.
434 *
435 * The region encodes the try/catch/filter clause that owns this block
436 * as well as the type. -1 is a special value that represents a block
437 * that is in none of try/catch/filter.
438 */
439 static int
441 {
447 /* first search for handlers and filters */
450 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
459 else
461 }
462 }
464 /* search the try blocks */
469 }
472 }
476 {
492 }
493 }
494 }
496 }
498 static void
500 {
508 /* prevent it from being register allocated */
512 }
516 {
518 }
522 {
530 /* prevent it from being register allocated */
536 }
538 /*
539 * Returns the type used in the eval stack when @type is loaded.
540 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
541 */
542 void
544 {
551 }
553 handle_enum:
597 }
607 /* FIXME: all the arguments must be references for now,
608 * later look inside cfg and see if the arg num is
609 * really a reference
610 */
616 }
617 }
619 /*
620 * The following tables are used to quickly validate the IL code in type_from_op ().
621 */
622 static const char
632 };
634 static const char
635 neg_table [] = {
637 };
639 /* reduce the size of this table */
640 static const char
650 };
652 static const char
654 /* Inv i L p F & O vt */
663 };
665 /* reduce the size of this table */
666 static const char
676 };
678 /*
679 * Tables to map from the non-specific opcode to the matching
680 * type-specific opcode.
681 */
682 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
683 static const guint16
686 };
688 /* handles from CEE_NEG to CEE_CONV_U8 */
689 static const guint16
692 };
694 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
695 static const guint16
697 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
698 };
700 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
701 static const guint16
703 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
704 };
706 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
707 static const guint16
709 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
710 };
712 /* handles from CEE_BEQ to CEE_BLT_UN */
713 static const guint16
715 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
716 };
718 /* handles from CEE_CEQ to CEE_CLT_UN */
719 static const guint16
721 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
722 };
724 /*
725 * Sets ins->type (the type on the eval stack) according to the
726 * type of the opcode and the arguments to it.
727 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
728 *
729 * FIXME: this function sets ins->type unconditionally in some cases, but
730 * it should set it to invalid for some types (a conv.x on an object)
731 */
732 static void
736 /* binops */
742 /* FIXME: check unverifiable args for STACK_MP */
764 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
768 else
773 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
799 /* unops */
807 else
828 }
861 #if SIZEOF_REGISTER == 8
863 #else
865 #endif
873 }
941 }
945 }
947 static const char
948 ldind_type [] = {
949 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
950 };
952 #if 0
954 static const char
957 };
959 static int
971 }
972 args++;
973 }
994 }
1007 }
1008 /*if (!param_table [args [i].type] [sig->params [i]->type])
1009 return 0;*/
1010 }
1012 }
1013 #endif
1015 /*
1016 * When we need a pointer to the current domain many times in a method, we
1017 * call mono_domain_get() once and we store the result in a local variable.
1018 * This function returns the variable that represents the MonoDomain*.
1019 */
1022 {
1026 }
1028 /*
1029 * The got_var contains the address of the Global Offset Table when AOT
1030 * compiling.
1031 */
1034 {
1035 #ifdef MONO_ARCH_NEED_GOT_VAR
1040 }
1042 #else
1044 #endif
1045 }
1049 {
1054 /* force the var to be stack allocated */
1056 }
1059 }
1074 }
1076 }
1080 {
1114 else
1119 }
1122 }
1126 {
1160 }
1162 }
1164 /*
1165 * We try to share variables when possible
1166 */
1169 {
1173 /* inlining can result in deeper stacks */
1193 }
1195 }
1197 static void
1199 {
1200 /*
1201 * Don't use this if a generic_context is set, since that means AOT can't
1202 * look up the method using just the image+token.
1203 * table == 0 means this is a reference made from a wrapper.
1204 */
1206 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1210 }
1211 }
1213 /*
1214 * This function is called to handle items that are left on the evaluation stack
1215 * at basic block boundaries. What happens is that we save the values to local variables
1216 * and we reload them later when first entering the target basic block (with the
1217 * handle_loaded_temps () function).
1218 * A single joint point will use the same variables (stored in the array bb->out_stack or
1219 * bb->in_stack, if the basic block is before or after the joint point).
1220 *
1221 * This function needs to be called _before_ emitting the last instruction of
1222 * the bb (i.e. before emitting a branch).
1223 * If the stack merge fails at a join point, cfg->unverifiable is set.
1224 */
1225 static void
1227 {
1232 gboolean found;
1240 //printf ("bblock %d has out:", bb->block_num);
1244 /* exception handlers are linked, but they should not be considered for stack args */
1247 //printf (" %d", outb->block_num);
1252 }
1253 }
1254 //printf ("\n");
1258 /*
1259 * try to reuse temps already allocated for this purpouse, if they occupy the same
1260 * stack slot and if they are of the same type.
1261 * This won't cause conflicts since if 'local' is used to
1262 * store one of the values in the in_stack of a bblock, then
1263 * the same variable will be used for the same outgoing stack
1264 * slot as well.
1265 * This doesn't work when inlining methods, since the bblocks
1266 * in the inlined methods do not inherit their in_stack from
1267 * the bblock they are inlined to. See bug #58863 for an
1268 * example.
1269 */
1272 else
1274 }
1275 }
1276 }
1280 /* exception handlers are linked, but they should not be considered for stack args */
1287 }
1289 }
1292 }
1302 }
1304 /*
1305 * It is possible that the out bblocks already have in_stack assigned, and
1306 * the in_stacks differ. In this case, we will store to all the different
1307 * in_stacks.
1308 */
1313 /* Find a bblock which has a different in_stack */
1317 /* exception handlers are linked, but they should not be considered for stack args */
1319 bindex++;
1321 }
1329 }
1333 }
1334 bindex ++;
1335 }
1336 }
1337 }
1339 /* Emit code which loads interface_offsets [klass->interface_id]
1340 * The array is stored in memory before vtable.
1341 */
1342 static void
1343 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1344 {
1352 }
1354 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1355 }
1356 }
1358 /*
1359 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1360 * stored in "klass_reg" implements the interface "klass".
1361 */
1362 static void
1363 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1364 {
1368 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap));
1380 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1386 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1387 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1388 }
1389 }
1391 /*
1392 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1393 * stored in "vtable_reg" implements the interface "klass".
1394 */
1395 static void
1396 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1397 {
1401 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap));
1413 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1419 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1420 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1421 }
1422 }
1424 /*
1425 * Emit code which checks whenever the interface id of @klass is smaller than
1426 * than the value given by max_iid_reg.
1427 */
1428 static void
1431 {
1436 }
1437 else
1441 else
1443 }
1445 /* Same as above, but obtains max_iid from a vtable */
1446 static void
1449 {
1452 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1454 }
1456 /* Same as above, but obtains max_iid from a klass */
1457 static void
1460 {
1463 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1465 }
1467 static void
1468 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1469 {
1475 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1478 }
1479 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1487 }
1489 }
1491 static void
1492 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1493 {
1501 else
1503 }
1505 /*
1506 * Variant of the above that takes a register to the class, not the vtable.
1507 */
1508 static void
1509 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1510 {
1518 else
1520 }
1524 {
1531 }
1533 }
1536 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1537 {
1544 }
1546 }
1548 static void
1549 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1550 {
1555 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1558 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1559 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1563 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1566 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1573 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1575 }
1578 /* Check that the object is a vector too */
1583 }
1590 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1593 }
1594 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1597 }
1598 }
1600 static void
1602 {
1621 #if SIZEOF_REGISTER == 8
1625 #endif
1626 }
1627 }
1633 else
1637 /* This could be optimized further if neccesary */
1642 }
1644 }
1646 #if !NO_UNALIGNED_ACCESS
1652 }
1657 }
1658 }
1659 #endif
1665 }
1670 }
1675 }
1676 }
1680 void
1681 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1682 {
1689 /* This could be optimized further if neccesary */
1697 }
1698 }
1700 #if !NO_UNALIGNED_ACCESS
1709 }
1710 }
1711 #endif
1720 }
1728 }
1736 }
1737 }
1739 #ifndef DISABLE_JIT
1741 static int
1742 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1743 {
1747 handle_enum:
1791 }
1793 }
1795 /*
1796 * target_type_is_incompatible:
1797 * @cfg: MonoCompile context
1798 *
1799 * Check that the item @arg on the evaluation stack can be stored
1800 * in the target type (can be a local, or field, etc).
1801 * The cfg arg can be used to check if we need verification or just
1802 * validity checks.
1803 *
1804 * Returns: non-0 value if arg can't be stored on a target.
1805 */
1806 static int
1808 {
1813 /* FIXME: check that the pointed to types match */
1819 }
1837 /* STACK_MP is needed when setting pinned locals */
1854 /* FIXME: check type compatibility */
1891 /* FIXME: check type compatibility */
1893 }
1896 /* FIXME: all the arguments must be references for now,
1897 * later look inside cfg and see if the arg num is
1898 * really a reference
1899 */
1906 }
1908 }
1910 /*
1911 * Prepare arguments for passing to a function call.
1912 * Return a non-zero value if the arguments can't be passed to the given
1913 * signature.
1914 * The type checks are not yet complete and some conversions may need
1915 * casts on 32 or 64 bit architectures.
1916 *
1917 * FIXME: implement this using target_type_is_incompatible ()
1918 */
1919 static int
1921 {
1928 args++;
1929 }
1935 }
1938 handle_enum:
1958 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
1983 }
1998 }
1999 }
2001 }
2003 static int
2005 {
2019 }
2022 }
2024 static int
2026 {
2040 }
2043 }
2045 #ifdef MONO_ARCH_HAVE_IMT
2046 static void
2048 {
2049 #ifdef MONO_ARCH_IMT_REG
2062 }
2065 #else
2067 #endif
2068 }
2069 #endif
2073 {
2081 }
2089 {
2091 #ifdef MONO_ARCH_SOFT_FLOAT
2093 #endif
2095 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2108 /*
2109 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2110 * address of return value to increase optimization opportunities.
2111 * Before vtype decomposition, the dreg of the call ins itself represents the
2112 * fact the call modifies the return value. After decomposition, the call will
2113 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2114 * will be transformed into an LDADDR.
2115 */
2119 /* We reference the call too since call->dreg could change during optimization */
2129 #ifdef MONO_ARCH_SOFT_FLOAT
2130 /*
2131 * If the call has a float argument, we would need to do an r8->r4 conversion using
2132 * an icall, but that cannot be done during the call sequence since it would clobber
2133 * the call registers + the stack. So we do it before emitting the call.
2134 */
2141 else
2152 /* The result will be in an int vreg */
2154 }
2155 }
2156 #endif
2164 }
2168 {
2176 }
2179 mono_emit_rgctx_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2180 {
2181 #ifdef MONO_ARCH_RGCTX_REG
2188 }
2193 }
2195 #else
2198 #endif
2199 }
2204 {
2210 /* Create the real signature */
2211 /* FIXME: Cache these */
2216 }
2226 }
2235 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2236 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2237 /* Make a call to delegate->invoke_impl */
2244 }
2245 #endif
2251 /*
2252 * the method is not virtual, we just need to ensure this is not null
2253 * and then we can call the method directly.
2254 */
2257 }
2263 }
2270 }
2273 /*
2274 * the method is virtual, but we can statically dispatch since either
2275 * it's class or the method itself are sealed.
2276 * But first we need to ensure it's not a null reference.
2277 */
2286 }
2294 #ifdef MONO_ARCH_HAVE_IMT
2300 }
2301 #endif
2306 }
2311 #ifdef MONO_ARCH_HAVE_IMT
2315 }
2316 #endif
2317 }
2321 }
2326 }
2329 mono_emit_rgctx_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2331 {
2337 #ifdef MONO_ARCH_RGCTX_REG
2340 #else
2341 NOT_IMPLEMENTED;
2342 #endif
2343 }
2348 #ifdef MONO_ARCH_RGCTX_REG
2351 #else
2352 NOT_IMPLEMENTED;
2353 #endif
2354 }
2357 }
2361 {
2362 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL);
2363 }
2365 MonoInst*
2368 {
2379 }
2383 {
2389 }
2391 /*
2392 * mono_emit_abs_call:
2393 *
2394 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2395 */
2399 {
2403 /*
2404 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2405 * handle it.
2406 */
2413 }
2417 {
2423 }
2425 }
2427 /*
2428 * Emit code to copy a valuetype of type @klass whose address is stored in
2429 * @src->dreg to memory whose address is stored at @dest->dreg.
2430 */
2431 void
2432 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2433 {
2440 /*
2441 * This check breaks with spilled vars... need to handle it during verification anyway.
2442 * g_assert (klass && klass == src->klass && klass == dest->klass);
2443 */
2447 else
2450 #if HAVE_WRITE_BARRIERS
2451 /* if native is true there should be no references in the struct */
2453 /* Avoid barriers when storing to the stack */
2461 }
2462 }
2463 #endif
2466 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2475 }
2476 }
2480 {
2486 }
2488 }
2490 void
2492 {
2495 guint32 align;
2498 /* FIXME: Optimize this for the case when dest is an LDADDR */
2505 }
2512 }
2513 }
2517 {
2550 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2552 }
2561 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2563 }
2564 }
2567 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2568 {
2578 }
2582 {
2583 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2584 }
2589 {
2590 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);
2594 }
2599 {
2600 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);
2604 }
2609 {
2610 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);
2614 }
2616 static void
2618 {
2636 }
2648 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, mono_class_vtable (cfg->domain, array_class));
2649 }
2650 }
2653 }
2655 static void
2657 {
2667 }
2673 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
2675 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
2676 }
2677 }
2679 static void
2681 {
2682 /* Reset the variables holding the cast details */
2687 /* It is enough to reset the from field */
2688 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
2689 }
2690 }
2692 /**
2693 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
2694 * generic code is generated.
2695 */
2698 {
2704 /* FIXME: What if the class is shared? We might not
2705 have to get the address of the method from the
2706 RGCTX. */
2708 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
2715 }
2716 }
2720 {
2730 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
2732 /* FIXME: generics */
2735 // Check rank == 0
2740 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
2745 /* This assertion is from the unboxcast insn */
2757 }
2759 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_PTR), obj_reg, sizeof (MonoObject));
2765 }
2769 {
2778 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
2779 /* This happens often in argument checking code, eg. throw new FooException... */
2780 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
2786 gboolean pass_lw;
2791 }
2798 }
2801 }
2802 }
2805 }
2809 gboolean for_box)
2810 {
2815 /*
2816 FIXME: we cannot get managed_alloc here because we can't get
2817 the class's vtable (because it's not a closed class)
2819 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
2820 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
2821 */
2831 }
2835 }
2838 }
2842 {
2848 }
2852 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
2855 }
2858 handle_box_from_inst (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used, MonoInst *data_inst)
2859 {
2864 /* FIXME: What if the class is shared? We might not
2865 have to get the method address from the RGCTX. */
2867 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
2874 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
2877 }
2878 }
2882 {
2902 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
2903 /* the remoting code is broken, access the class for now */
2910 }
2915 }
2916 }
2923 }
2927 {
2938 /* Do the assignment at the beginning, so the other assignment can be if converted */
2948 /* the is_null_bb target simply copies the input register to the output */
2959 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
2963 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
2967 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
2971 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
2981 /* Check that the object is a vector too */
2986 }
2988 /* the is_null_bb target simply copies the input register to the output */
2990 }
2993 /* the is_null_bb target simply copies the input register to the output */
2996 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
2997 /* the remoting code is broken, access the class for now */
3004 }
3009 /* the is_null_bb target simply copies the input register to the output */
3011 }
3012 }
3013 }
3025 }
3029 {
3030 /* This opcode takes as input an object reference and a class, and returns:
3031 0) if the object is an instance of the class,
3032 1) if the object is not instance of the class,
3033 2) if the object is a proxy whose type cannot be determined */
3060 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3063 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3071 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3073 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3074 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3077 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3087 }
3105 /* FIXME: */
3111 }
3115 {
3116 /* This opcode takes as input an object reference and a class, and returns:
3117 0) if the object is an instance of the class,
3118 1) if the object is a proxy whose type cannot be determined
3119 an InvalidCastException exception is thrown otherwhise*/
3145 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3157 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3160 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3161 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3164 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3180 }
3188 /* FIXME: */
3194 }
3197 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method)
3198 {
3206 /* Inline the contents of mono_delegate_ctor */
3208 /* Set target field */
3209 /* Optimize away setting of NULL target */
3211 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3213 /* Set method field */
3215 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3217 /*
3218 * To avoid looking up the compiled code belonging to the target method
3219 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3220 * store it, and we fill it after the method has been compiled.
3221 */
3233 }
3237 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3238 }
3240 /* Set invoke_impl field */
3246 }
3247 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3249 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3252 }
3256 {
3259 /* Need to register the icall so it gets an icall wrapper */
3264 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3266 }
3268 static void
3270 {
3279 /* Add it to the start of the first bblock */
3283 }
3284 else
3289 /*
3290 * Add a dummy use to keep the got_var alive, since real uses might
3291 * only be generated by the back ends.
3292 * Add it to end_bblock, so the variable's lifetime covers the whole
3293 * method.
3294 * It would be better to make the usage of the got var explicit in all
3295 * cases when the backend needs it (i.e. calls, throw etc.), so this
3296 * wouldn't be needed.
3297 */
3300 }
3305 static gboolean
3307 {
3310 #ifdef MONO_ARCH_SOFT_FLOAT
3313 #endif
3318 #ifdef MONO_ARCH_HAVE_LMF_OPS
3323 #endif
3326 /* Avoid inflating the header */
3328 else
3340 /* also consider num_locals? */
3341 /* Do the size check early to avoid creating vtables */
3345 else
3348 }
3352 /*
3353 * if we can initialize the class of the method right away, we do,
3354 * otherwise we don't allow inlining if the class needs initialization,
3355 * since it would mean inserting a call to mono_runtime_class_init()
3356 * inside the inlined code
3357 */
3362 /* No vtable created yet */
3367 /* This makes so that inline cannot trigger */
3368 /* .cctors: too many apps depend on them */
3369 /* running with a specific order... */
3373 }
3376 /* No vtable created yet */
3383 }
3385 /*
3386 * If we're compiling for shared code
3387 * the cctor will need to be run at aot method load time, for example,
3388 * or at the end of the compilation of the inlining method.
3389 */
3390 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3392 }
3394 /*
3395 * CAS - do not inline methods with declarative security
3396 * Note: this has to be before any possible return TRUE;
3397 */
3401 #ifdef MONO_ARCH_SOFT_FLOAT
3402 /* FIXME: */
3408 #endif
3411 }
3413 static gboolean
3415 {
3426 /* The initialization is already done before the method is called */
3430 }
3434 {
3436 guint32 size;
3446 #if SIZEOF_REGISTER == 8
3447 /* The array reg is 64 bits but the index reg is only 32 */
3450 #else
3456 }
3457 #endif
3461 #if defined(__i386__) || defined(__x86_64__)
3465 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
3469 }
3470 #endif
3481 }
3483 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3485 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
3486 {
3500 guint32 size;
3508 /* range checking */
3539 }
3540 #endif
3543 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3544 {
3555 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3556 /* emit_ldelema_2 depends on OP_LMUL */
3559 }
3560 #endif
3567 }
3570 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
3571 {
3586 #if SIZEOF_REGISTER == 8
3587 /* The array reg is 64 bits but the index reg is only 32 */
3589 #else
3591 #endif
3594 #if defined(__i386__) || defined(__x86_64__)
3595 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
3597 /* Avoid a warning */
3601 #else
3606 #endif
3611 /* Decompose later to allow more optimizations */
3622 /* The corlib functions check for oob already. */
3625 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
3633 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3634 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
3638 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
3648 #endif
3687 if (strcmp (cmethod->name, "get_CurrentThread") == 0 && (ins = mono_arch_get_thread_intrinsic (cfg))) {
3700 }
3702 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
3721 }
3722 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
3725 /* Avoid infinite recursion */
3738 #endif
3753 #if SIZEOF_REGISTER == 8
3755 /* 64 bit reads are already atomic */
3761 }
3762 #endif
3764 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
3771 #if SIZEOF_REGISTER == 8
3774 #endif
3788 }
3795 #if SIZEOF_REGISTER == 8
3798 #endif
3812 }
3818 #if SIZEOF_REGISTER == 8
3821 #endif
3831 }
3832 }
3835 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
3837 guint32 opcode;
3841 #if SIZEOF_REGISTER == 8
3846 #else
3850 #endif
3851 else
3874 }
3875 }
3878 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS_IMM
3879 /*
3880 * Can't implement CompareExchange methods this way since they have
3881 * three arguments. We can implement one of the common cases, where the new
3882 * value is a constant.
3883 */
3895 }
3896 /* The I8 case is hard to detect, since the arg might be a conv.i8 (iconst) tree */
3897 }
3908 }
3911 #ifdef PLATFORM_WIN32
3913 #else
3915 #endif
3917 }
3919 /*
3920 * There is general branches code for Min/Max, but it does not work for
3921 * all inputs:
3922 * http://everything2.com/?node_id=1051618
3923 */
3924 }
3926 #ifdef MONO_ARCH_SIMD_INTRINSICS
3931 }
3932 #endif
3935 }
3937 /*
3938 * This entry point could be used later for arbitrary method
3939 * redirection.
3940 */
3944 {
3946 /* managed string allocation support */
3956 }
3957 }
3959 }
3961 static void
3963 {
3968 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
3970 /*
3971 * FIXME: We should use *args++ = sp [0], but that would mean the arg
3972 * would be different than the MonoInst's used to represent arguments, and
3973 * the ldelema implementation can't deal with that.
3974 * Solution: When ldelema is used on an inline argument, create a var for
3975 * it, emit ldelema on that var, and emit the saving code below in
3976 * inline_method () if needed.
3977 */
3980 /* This uses cfg->args [i] which is set by the preceeding line */
3983 sp++;
3984 }
3985 }
3987 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
3988 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
3990 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
3991 static gboolean
3993 {
4002 else
4004 }
4012 //return (strncmp_result <= 0);
4016 }
4017 }
4018 #endif
4020 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4021 static gboolean
4023 {
4033 }
4034 }
4042 //return (strncmp_result <= 0);
4046 }
4047 }
4048 #endif
4050 static int
4051 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4053 {
4061 guint prev_real_offset;
4066 guint32 prev_cil_offset_to_bb_len;
4073 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4076 #endif
4077 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4080 #endif
4083 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4088 }
4089 /* allocate space to store the return value */
4092 }
4094 /* allocate local variables */
4101 /* allocate start and end blocks */
4102 /* This is needed so if the inline is aborted, we can clean up */
4125 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
4144 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4148 /* always add some code to avoid block split failures */
4155 /*
4156 * Get rid of the begin and end bblocks if possible to aid local
4157 * optimizations.
4158 */
4161 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4168 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4171 }
4174 }
4177 /*
4178 * If the inlined method contains only a throw, then the ret var is not
4179 * set, so set it to a dummy value.
4180 */
4208 }
4209 }
4213 }
4221 /* This gets rid of the newly added bblocks */
4223 }
4225 }
4227 /*
4228 * Some of these comments may well be out-of-date.
4229 * Design decisions: we do a single pass over the IL code (and we do bblock
4230 * splitting/merging in the few cases when it's required: a back jump to an IL
4231 * address that was not already seen as bblock starting point).
4232 * Code is validated as we go (full verification is still better left to metadata/verify.c).
4233 * Complex operations are decomposed in simpler ones right away. We need to let the
4234 * arch-specific code peek and poke inside this process somehow (except when the
4235 * optimizations can take advantage of the full semantic info of coarse opcodes).
4236 * All the opcodes of the form opcode.s are 'normalized' to opcode.
4237 * MonoInst->opcode initially is the IL opcode or some simplification of that
4238 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4239 * opcode with value bigger than OP_LAST.
4240 * At this point the IR can be handed over to an interpreter, a dumb code generator
4241 * or to the optimizing code generator that will translate it to SSA form.
4242 *
4243 * Profiling directed optimizations.
4244 * We may compile by default with few or no optimizations and instrument the code
4245 * or the user may indicate what methods to optimize the most either in a config file
4246 * or through repeated runs where the compiler applies offline the optimizations to
4247 * each method and then decides if it was worth it.
4248 */
4250 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4251 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4252 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
4253 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4254 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4255 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
4256 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4257 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
4259 /* offset from br.s -> br like opcodes */
4260 #define BIG_BRANCH_OFFSET 13
4262 static gboolean
4264 {
4268 }
4270 static int
4271 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
4272 {
4276 guint cli_addr;
4284 UNVERIFIED;
4288 ip++;
4323 guint32 j;
4333 }
4335 }
4342 }
4347 /* Find the start of the bblock containing the throw */
4351 bb_start --;
4352 }
4355 }
4356 }
4358 unverified:
4361 }
4364 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4365 {
4374 }
4377 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4378 {
4381 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
4385 }
4389 {
4394 else
4399 }
4401 /*
4402 * Returns TRUE if the JIT should abort inlining because "callee"
4403 * is influenced by security attributes.
4404 */
4405 static
4407 {
4408 guint32 result;
4412 }
4419 /* Generate code to throw a SecurityException before the actual call/link */
4427 /* don't hide previous results */
4431 }
4434 }
4438 {
4445 }
4448 }
4450 static void
4453 {
4460 }
4464 {
4471 }
4474 }
4476 static void
4477 emit_throw_field_access_exception (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
4479 {
4486 }
4488 /*
4489 * Return the original method is a wrapper is specified. We can only access
4490 * the custom attributes from the original method.
4491 */
4494 {
4498 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
4502 /* in other cases we need to find the original method */
4504 }
4506 static void
4507 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
4509 {
4510 /* there's no restriction to access Transparent or SafeCritical fields, so we only check calls to Critical methods */
4511 if (mono_security_core_clr_class_level (mono_field_get_parent (field)) != MONO_SECURITY_CORE_CLR_CRITICAL)
4514 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4519 /* caller is Critical! only SafeCritical and Critical callers can access the field, so we throw if caller is Transparent */
4522 }
4524 static void
4525 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
4527 {
4528 /* there's no restriction to call Transparent or SafeCritical code, so we only check calls to Critical methods */
4532 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4537 /* caller is Critical! only SafeCritical and Critical callers can call it, so we throw if the caller is Transparent */
4540 }
4542 /*
4543 * Check that the IL instructions at ip are the array initialization
4544 * sequence and return the pointer to the data and the size.
4545 */
4547 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
4548 {
4549 /*
4550 * newarr[System.Int32]
4551 * dup
4552 * ldtoken field valuetype ...
4553 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
4554 */
4559 guint32 rva;
4564 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
4575 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
4582 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
4583 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
4593 #ifdef ARM_FPU_FPA
4595 #endif
4599 #endif
4602 }
4607 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
4612 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
4613 /* for aot code we do the lookup on load */
4617 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
4620 }
4622 }
4624 }
4626 static void
4628 {
4634 else
4637 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
4640 }
4642 static void
4644 {
4648 }
4650 static gboolean
4652 {
4657 else
4660 }
4662 /**
4663 * mono_decompose_array_access_opts:
4664 *
4665 * Decompose array access opcodes.
4666 * This should be in decompose.c, but it emits calls so it has to stay here until
4667 * the old JIT is gone.
4668 */
4669 void
4671 {
4674 /*
4675 * Unlike decompose_long_opts, this pass does not alter the CFG of the method so it
4676 * can be executed anytime. It should be run before decompose_long
4677 */
4679 /**
4680 * Create a dummy bblock and emit code into it so we can use the normal
4681 * code generation macros.
4682 */
4691 gboolean restart;
4724 MonoVTable *vtable = mono_class_vtable (cfg->domain, mono_array_class_get (ins->inst_newa_class, 1));
4734 }
4743 }
4748 /* Replace the original instruction with the new code sequence */
4754 }
4755 else
4757 }
4758 }
4761 }
4762 }
4766 gint64 vall;
4770 #ifdef MONO_ARCH_SOFT_FLOAT
4772 /**
4773 * mono_decompose_soft_float:
4774 *
4775 * Soft float support on ARM. We store each double value in a pair of integer vregs,
4776 * similar to long support on 32 bit platforms. 32 bit float values require special
4777 * handling when used as locals, arguments, and in calls.
4778 * One big problem with soft-float is that there are few r4 test cases in our test suite.
4779 */
4780 void
4782 {
4785 /*
4786 * This pass creates long opcodes, so it should be run before decompose_long_opts ().
4787 */
4789 /**
4790 * Create a dummy bblock and emit code into it so we can use the normal
4791 * code generation macros.
4792 */
4799 gboolean restart;
4812 /* Most fp operations are handled automatically by opcode emulation */
4816 DVal d;
4820 }
4822 DVal d;
4823 /* We load the r8 value */
4827 }
4847 }
4858 /* Arg 1 is the double value */
4862 /* Arg 2 is the address to store to */
4864 EMIT_NEW_BIALU_IMM (cfg, iargs [1], OP_PADD_IMM, addr_reg, ins->inst_destbasereg, ins->inst_offset);
4868 }
4875 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, addr_reg, ins->inst_basereg, ins->inst_offset);
4879 }
4889 /* Convert the call into a call returning an int */
4904 }
4908 /* FIXME: Optimize this */
4910 /* Emit an r4->r8 conversion */
4911 EMIT_NEW_VARLOADA_VREG (cfg, iargs [0], call2->inst.dreg, &mono_defaults.int32_class->byval_arg);
4927 }
4928 }
4930 }
4936 /* Convert fcompare+fbcc to icall+icompare+beq */
4941 /* Create dummy MonoInst's for the arguments */
4960 /* The call sequence might include fp ins */
4963 /* Skip fbcc or fccc */
4966 }
4976 /* Convert fccc to icall+icompare+iceq */
4981 /* Create dummy MonoInst's for the arguments */
4992 /* The call sequence might include fp ins */
4995 }
5000 /* Convert to icall+icompare+cond_exc+move */
5002 /* Create dummy MonoInst's for the arguments */
5015 /* Do the assignment if the value is finite */
5020 }
5022 if (spec [MONO_INST_SRC1] == 'f' || spec [MONO_INST_SRC2] == 'f' || spec [MONO_INST_DEST] == 'f') {
5025 }
5027 }
5032 /* Replace the original instruction with the new code sequence */
5038 }
5039 else
5041 }
5042 }
5045 }
5048 }
5050 #endif
5052 static void
5054 {
5059 /* Optimize reg-reg moves away */
5060 /*
5061 * Can't optimize other opcodes, since sp[0] might point to
5062 * the last ins of a decomposed opcode.
5063 */
5067 }
5068 }
5070 /*
5071 * ldloca inhibits many optimizations so try to get rid of it in common
5072 * cases.
5073 */
5076 {
5086 }
5088 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5091 /* From the INITOBJ case */
5103 }
5107 }
5108 load_error:
5110 }
5112 static gboolean
5114 {
5119 }
5121 }
5123 /*
5124 * mono_method_to_ir:
5125 *
5126 * Translate the .net IL into linear IR.
5127 */
5128 int
5129 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5132 {
5151 guint num_args;
5154 MonoDeclSecurityActions actions;
5159 /* serialization and xdomain stuff may need access to private fields and methods */
5169 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5188 }
5190 /* SkipVerification is not allowed if core-clr is enabled */
5194 }
5214 }
5222 }
5224 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5245 /* ENTRY BLOCK */
5251 /* EXIT BLOCK */
5263 }
5264 /* handle exception clauses */
5285 /* todo: is a fault block unsafe to optimize? */
5288 }
5291 /*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);
5292 while (p < end) {
5293 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5294 }*/
5295 /* catch and filter blocks get the exception object on the stack */
5300 /* mostly like handle_stack_args (), but just sets the input args */
5301 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5306 /*
5307 * Add a dummy use for the exvar so its liveness info will be
5308 * correct.
5309 */
5319 /* The filter block shares the exvar with the handler block */
5323 }
5324 }
5330 /*
5331 * In shared generic code with catch
5332 * clauses containing type variables
5333 * the exception handling code has to
5334 * be able to get to the rgctx.
5335 * Therefore we have to make sure that
5336 * the vtable/mrgctx argument (for
5337 * static or generic methods) or the
5338 * "this" argument (for non-static
5339 * methods) are live.
5340 */
5349 }
5350 }
5351 }
5357 }
5359 /* FIRST CODE BLOCK */
5372 }
5373 }
5379 /* at this point having security doesn't mean we have any code to generate */
5381 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5382 * And we do not want to enter the next section (with allocation) if we
5383 * have nothing to generate */
5385 }
5387 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
5394 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
5397 }
5405 }
5408 }
5410 /* not a P/Invoke after all */
5412 }
5413 }
5415 if ((header->init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
5416 /* we use a separate basic block for the initialization code */
5429 }
5431 /* at this point we know, if security is TRUE, that some code needs to be generated */
5438 /* Add code for SecurityAction.Demand */
5441 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5443 }
5445 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
5446 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
5449 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5451 }
5453 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
5456 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
5458 }
5459 }
5461 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
5464 }
5473 }
5474 }
5475 }
5476 }
5479 UNVERIFIED;
5483 UNVERIFIED;
5484 }
5491 UNVERIFIED;
5492 }
5495 /* We force the vtable variable here for all shared methods
5496 for the possibility that they might show up in a stack
5497 trace where their exact instantiation is needed. */
5504 /* FIXME: Is there a better way to do this?
5505 We need the variable live for the duration
5506 of the whole method. */
5508 }
5509 }
5511 /* add a check for this != NULL to inlined methods */
5520 }
5522 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
5523 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
5532 else
5544 }
5554 }
5565 }
5574 }
5577 }
5578 }
5586 /* TODO: Use an increment here */
5587 #if defined(__i386__)
5592 #else
5595 #endif
5596 }
5599 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
5605 else
5607 ip++;
5612 ip++;
5623 ip++;
5634 ip++;
5646 UNVERIFIED;
5651 }
5678 UNVERIFIED;
5701 }
5707 }
5714 UNVERIFIED;
5775 /* FIXME: we should really allocate this only late in the compilation process */
5790 }
5793 /* FIXME: we should really allocate this only late in the compilation process */
5808 }
5813 sp--;
5828 }
5831 ip++;
5834 #ifdef __i386__
5836 /* we need to pop the value from the x86 FP stack */
5838 #endif
5843 INLINE_FAILURE;
5847 UNVERIFIED;
5849 /* FIXME: check the signature matches */
5859 CHECK_CFG_EXCEPTION;
5861 #ifdef __x86_64__
5862 {
5866 /* Handle tail calls similarly to calls */
5880 }
5881 #else
5883 /* Prevent arguments from being optimized away */
5890 #endif
5895 }
5921 else
5932 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
5933 /*
5934 * This is needed since get_method_constrained can't find
5935 * the method in klass representing a type var.
5936 * The type var is guaranteed to be a reference type in this
5937 * case.
5938 */
5943 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
5944 }
5948 }
5955 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
5956 }
5959 METHOD_ACCESS_FAILURE;
5960 }
5966 /* MS.NET seems to silently convert this to a callvirt */
5986 }
5987 }
5995 INLINE_FAILURE;
5996 CHECK_CFG_EXCEPTION;
5997 }
6001 }
6004 UNVERIFIED;
6011 //g_assert (!virtual || fsig->hasthis);
6016 /*
6017 * We have the `constrained.' prefix opcode.
6018 */
6022 /*
6023 * The type parameter is instantiated as a valuetype,
6024 * but that type doesn't override the method we're
6025 * calling, so we need to box `this'.
6026 */
6034 /*
6035 * The type parameter is instantiated as a reference
6036 * type. We have a managed pointer on the stack, so
6037 * we need to dereference it here.
6038 */
6045 }
6048 UNVERIFIED;
6057 /*
6058 * Pass vtable iff target method might
6059 * be shared, which means that sharing
6060 * is enabled for its class and its
6061 * context is sharable (and it's not a
6062 * generic method).
6063 */
6067 }
6079 }
6087 /* Generic method interface
6088 calls are resolved via a
6089 helper function and don't
6090 need an imt. */
6093 }
6095 /*
6096 * If a shared method calls another
6097 * shared method then the caller must
6098 * have a generic sharing context
6099 * because the magic trampoline
6100 * requires it. FIXME: We shouldn't
6101 * have to force the vtable/mrgctx
6102 * variable here. Instead there
6103 * should be a flag in the cfg to
6104 * request a generic sharing context.
6105 */
6109 }
6119 }
6120 }
6129 }
6136 }
6137 }
6145 }
6153 }
6155 /* Calling virtual generic methods */
6166 /* Prevent inlining of methods that contain indirect calls */
6167 INLINE_FAILURE;
6169 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK
6179 }
6182 #endif
6183 {
6188 /* FIXME: This should be a managed pointer */
6202 }
6207 }
6215 }
6217 /* Tail prefix */
6218 /* FIXME: runtime generic context pointer for jumps? */
6219 /* FIXME: handle this for generic sharing eventually */
6220 if ((ins_flag & MONO_INST_TAILCALL) && !cfg->generic_sharing_context && !vtable_arg && cmethod && (*ip == CEE_CALL) &&
6221 (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)))) {
6224 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6225 INLINE_FAILURE;
6232 #ifdef __x86_64__
6233 /* Handle tail calls similarly to calls */
6237 #else
6238 /*
6239 * We implement tail calls by storing the actual arguments into the
6240 * argument variables, then emitting a CEE_JMP.
6241 */
6243 /* Prevent argument from being register allocated */
6246 }
6247 #endif
6255 /* skip CEE_RET as well */
6259 }
6261 /* Conversion to a JIT intrinsic */
6262 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6266 sp++;
6267 }
6272 }
6274 /* Inlining */
6276 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
6284 /* Prevent inlining of methods that call wrappers */
6285 INLINE_FAILURE;
6288 }
6290 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, allways))) {
6296 /* *sp is already set by inline_method */
6297 sp++;
6302 }
6303 }
6307 /* Tail recursion elimination */
6308 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
6312 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6313 INLINE_FAILURE;
6315 /* keep it simple */
6319 }
6331 /* skip the CEE_RET, too */
6334 else
6339 }
6340 }
6342 /* Generic sharing */
6343 /* FIXME: only do this for generic methods if
6344 they are not shared! */
6350 INLINE_FAILURE;
6355 /*
6356 * We are compiling a call to a
6357 * generic method from shared code,
6358 * which means that we have to look up
6359 * the method in the rgctx and do an
6360 * indirect call.
6361 */
6362 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
6363 }
6365 /* Indirect calls */
6373 else
6374 /* FIXME: what the hell is this??? */
6378 /* Prevent inlining of methods with indirect calls */
6379 INLINE_FAILURE;
6382 #ifdef MONO_ARCH_RGCTX_REG
6391 #else
6392 NOT_IMPLEMENTED;
6393 #endif
6396 /*
6397 * Instead of emitting an indirect call, emit a direct call
6398 * with the contents of the aotconst as the patch info.
6399 */
6400 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
6404 }
6405 }
6410 /*
6411 * Native code might return non register sized integers
6412 * without initializing the upper bits.
6413 */
6429 }
6438 }
6439 }
6442 }
6447 }
6449 /* Array methods */
6461 }
6464 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, sp [fsig->param_count]->dreg);
6480 }
6485 }
6495 }
6497 /* Common call */
6498 INLINE_FAILURE;
6503 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, imt_arg);
6505 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, NULL);
6506 }
6514 }
6517 /* return from inlined method */
6518 /*
6519 * If in_count == 0, that means the ret is unreachable due to
6520 * being preceeded by a throw. In that case, inline_method () will
6521 * handle setting the return value
6522 * (test case: test_0_inline_throw ()).
6523 */
6528 //g_assert (returnvar != -1);
6531 }
6551 }
6553 #ifdef MONO_ARCH_SOFT_FLOAT
6563 }
6564 #else
6566 #endif
6567 }
6568 }
6569 }
6571 UNVERIFIED;
6573 ip++;
6582 ip++;
6592 }
6610 ip++;
6612 ip++;
6622 ip++;
6633 }
6652 UNVERIFIED;
6653 ip ++;
6657 sp--;
6667 }
6674 #if SIZEOF_REGISTER == 4
6676 /* Convert it to OP_LCOMPARE */
6684 }
6685 #endif
6701 }
6715 ip++;
6733 gboolean use_op_switch;
6741 UNVERIFIED;
6754 }
6757 /*
6758 * Link the current bb with the targets as well, so handle_stack_args
6759 * will set their in_stack correctly.
6760 */
6768 }
6782 #ifdef __arm__
6783 /* ARM implements SWITCH statements differently */
6784 /* FIXME: Make it use the generic implementation */
6787 #endif
6799 else
6802 #if SIZEOF_REGISTER == 8
6803 /* The upper word might not be zero, and we add it to a 64 bit address later */
6805 #endif
6815 }
6817 /* FIXME: Use load_memindex */
6821 }
6825 }
6850 }
6871 #if HAVE_WRITE_BARRIERS
6872 if (*ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0))) {
6873 /* insert call to write barrier */
6877 ip++;
6879 }
6880 #endif
6901 /* Use the immediate opcodes if possible */
6910 }
6911 }
6917 ip++;
6942 /* FIXME: Pass opcode to is_inst_imm */
6944 /* Use the immediate opcodes if possible */
6945 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)) {
6952 #if SIZEOF_REGISTER == 8
6954 #else
6957 #endif
6958 }
6959 else
6963 /* Might be followed by an instruction added by ADD_WIDEN_OP */
6966 }
6967 }
6972 ip++;
6989 /* Special case this earlier so we have long constants in the IR */
6994 #if SIZEOF_REGISTER == 8
6997 else
6999 #else
7003 else
7005 #endif
7007 }
7010 }
7011 ip++;
7025 }
7026 ip++;
7038 }
7039 ip++;
7057 ip++;
7067 ip++;
7089 }
7104 /* Optimize the common ldobj+stloc combination */
7119 }
7129 }
7131 /* Optimize the ldobj+stobj combination */
7132 /* The reference case ends up being a load+store anyway */
7133 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 9) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7136 sp --;
7143 }
7152 }
7162 }
7174 }
7185 /*
7186 * Avoid relocations in AOT and save some space by using a
7187 * version of helper_ldstr specialized to mscorlib.
7188 */
7192 /* Avoid creating the string object */
7196 }
7197 }
7198 else
7203 }
7210 }
7211 }
7212 }
7214 sp++;
7220 MonoInst this_ins;
7241 INLINE_FAILURE;
7242 CHECK_CFG_EXCEPTION;
7245 }
7255 }
7265 }
7266 }
7267 }
7272 /*
7273 * Generate smaller code for the common newobj <exception> instruction in
7274 * argument checking code.
7275 */
7302 }
7307 }
7309 /* move the args to allow room for 'this' in the first position */
7313 }
7315 /* check_call_signature () requires sp[0] to be set */
7319 UNVERIFIED;
7331 }
7333 /* Avoid varargs in the common case */
7338 else
7343 /* we simply pass a null pointer */
7345 /* now call the string ctor */
7357 /*
7358 * The code generated by mini_emit_virtual_call () expects
7359 * iargs [0] to be a boxed instance, but luckily the vcall
7360 * will be transformed into a normal call there.
7361 */
7368 else
7379 /*
7380 * TypeInitializationExceptions thrown from the mono_runtime_class_init
7381 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
7382 * As a workaround, we call class cctors before allocating objects.
7383 */
7384 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
7385 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
7387 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
7389 }
7393 }
7398 /* Now call the actual ctor */
7399 /* Avoid virtual calls to ctors if possible */
7409 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
7415 INLINE_FAILURE;
7417 }
7428 INLINE_FAILURE;
7431 if (mono_method_is_generic_sharable_impl (cmethod, TRUE) && ((MonoCallInst*)ins)->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
7433 }
7434 }
7437 /* Valuetype */
7441 }
7442 else
7448 }
7457 UNVERIFIED;
7465 /* obj */
7468 /* klass */
7495 }
7501 }
7511 UNVERIFIED;
7519 /* obj */
7522 /* klass */
7526 sp++;
7548 }
7554 }
7556 }
7571 /* CASTCLASS */
7575 /* obj */
7577 /* klass */
7607 }
7609 }
7616 }
7618 /* UNBOX */
7624 /* LDOBJ */
7630 }
7651 }
7654 UNVERIFIED;
7656 UNVERIFIED;
7657 /* frequent check in generic code: box (struct), brtrue */
7659 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
7660 /*printf ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
7665 ip++;
7667 ip++;
7670 ip++;
7673 }
7678 /*
7679 * This leads to some inconsistency, since the two bblocks are
7680 * not really connected, but it is needed for handling stack
7681 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
7682 * FIXME: This should only be needed if sp != stack_start, but that
7683 * doesn't work for some reason (test failure in mcs/tests on x86).
7684 */
7690 }
7694 }
7702 else
7708 }
7713 }
7737 }
7741 }
7747 guint foffset;
7755 }
7757 UNVERIFIED;
7759 UNVERIFIED;
7765 }
7768 }
7772 FIELD_ACCESS_FAILURE;
7775 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
7776 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
7777 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
7778 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
7779 */
7784 UNVERIFIED;
7785 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
7807 }
7811 #if HAVE_WRITE_BARRIERS
7812 if (mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
7813 /* insert call to write barrier */
7822 }
7823 #endif
7828 }
7832 }
7834 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
7835 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
7841 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
7842 if ((cfg->opt & MONO_OPT_INLINE) && !MONO_TYPE_ISSTRUCT (mono_method_signature (wrapper)->ret)) {
7856 }
7861 /* Have to compute the address of the variable */
7866 else
7871 }
7886 }
7887 }
7891 }
7897 gboolean is_special_static;
7905 }
7906 else
7912 FIELD_ACCESS_FAILURE;
7914 /* if the class is Critical then transparent code cannot access it's fields */
7918 /*
7919 * We can only support shared generic static
7920 * field access on architectures where the
7921 * trampoline code has been extended to handle
7922 * the generic class init.
7923 */
7924 #ifndef MONO_ARCH_VTABLE_REG
7926 #endif
7933 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
7934 * to be called here.
7935 */
7939 }
7947 /* Generate IR to compute the field address */
7961 }
7966 /*
7967 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
7968 method->klass->name_space, method->klass->name, method->name,
7969 depth, field->offset);
7970 */
7979 // FIXME: This doesn't work since it tries to pass the argument
7980 // in the normal way, instead of using MONO_ARCH_VTABLE_REG
7981 /*
7982 * The vtable pointer is always passed in a register regardless of
7983 * the calling convention, so assign it manually, and make a call
7984 * using a signature without parameters.
7985 */
7986 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable);
7987 #ifdef MONO_ARCH_VTABLE_REG
7990 #else
7991 NOT_IMPLEMENTED;
7992 #endif
7993 }
7995 /*
7996 * The pointer we're computing here is
7997 *
7998 * super_info.static_data + field->offset
7999 */
8008 }
8021 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8022 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8024 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8029 /* This makes so that inline cannot trigger */
8030 /* .cctors: too many apps depend on them */
8031 /* running with a specific order... */
8033 INLINE_FAILURE;
8038 }
8039 }
8040 }
8045 else
8048 /*
8049 * insert call to mono_threads_get_static_data (GPOINTER_TO_UINT (addr))
8050 * This could be later optimized to do just a couple of
8051 * memory dereferences with constant offsets.
8052 */
8056 }
8057 }
8059 /* Generate IR to do the actual load/store operation */
8068 sp--;
8079 }
8086 }
8087 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8093 sp++;
8097 sp++;
8102 sp++;
8106 sp++;
8111 sp++;
8115 sp++;
8117 #ifndef HAVE_MOVING_COLLECTOR
8129 sp++;
8131 #endif
8135 sp++;
8143 }
8144 }
8155 }
8156 }
8160 }
8168 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
8175 /*
8176 * Array opcodes
8177 */
8182 guint32 field_token;
8199 /* FIXME: Decompose later to help abcrem */
8201 /* vtable */
8205 /* array len */
8211 /* Decompose now to avoid problems with references to the domainvar */
8220 /* Decompose later since it is needed by abcrem */
8231 /* Needed so mono_emit_load_get_addr () gets called */
8233 }
8234 }
8241 /*
8242 * we inline/optimize the initialization sequence if possible.
8243 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
8244 * for small sizes open code the memcpy
8245 * ensure the rva field is big enough
8246 */
8247 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))) {
8252 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
8254 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
8257 }
8261 }
8264 }
8269 UNVERIFIED;
8279 ip ++;
8287 UNVERIFIED;
8293 /* we need to make sure that this array is exactly the type it needs
8294 * to be for correctness. the wrappers are lax with their usage
8295 * so we need to ignore them here
8296 */
8328 }
8329 else
8333 UNVERIFIED;
8340 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8347 }
8351 else
8354 }
8377 }
8378 else
8382 UNVERIFIED;
8384 /* storing a NULL doesn't need any of the complex checks in stelemref */
8391 UNVERIFIED;
8393 UNVERIFIED;
8404 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8411 }
8412 }
8416 else
8420 }
8436 }
8454 // FIXME:
8457 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
8467 // FIXME:
8472 }
8473 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
8478 }
8493 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
8501 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
8502 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8503 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8509 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
8510 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8511 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8513 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
8514 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
8515 }
8516 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
8524 }
8526 gpointer handle;
8540 }
8543 }
8550 /* This case handles ldtoken
8551 of an open type, like for
8552 typeof(Gen<>). */
8555 /* If we get a MONO_TYPE_CLASS
8556 then we need to provide the
8557 open type, not an
8558 instantiation of it. */
8561 else
8567 else
8569 }
8579 else
8593 }
8615 }
8628 MONO_RGCTX_INFO_TYPE);
8637 }
8642 }
8646 }
8647 }
8652 }
8658 ip++;
8671 ip++;
8674 /*
8675 * Control will leave the method so empty the stack, otherwise
8676 * the next basic block will start with a nonempty stack.
8677 */
8679 sp--;
8680 }
8692 }
8694 /* empty the stack */
8696 sp--;
8697 }
8699 /*
8700 * If this leave statement is in a catch block, check for a
8701 * pending exception, and rethrow it if necessary.
8702 */
8706 /*
8707 * Use <= in the final comparison to handle clauses with multiple
8708 * leave statements, like in bug #78024.
8709 * The ordering of the exception clauses guarantees that we find the
8710 * innermost clause.
8711 */
8712 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)) {
8716 /*
8717 MonoInst *load;
8719 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
8720 */
8726 /*
8727 * Currently, we allways rethrow the abort exception, despite the
8728 * fact that this is not correct. See thread6.cs for an example.
8729 * But propagating the abort exception is more important than
8730 * getting the sematics right.
8731 */
8738 }
8739 }
8749 }
8751 }
8762 else
8766 }
8768 /*
8769 * Mono specific opcodes
8770 */
8778 gpointer func;
8797 }
8799 gpointer ptr;
8806 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
8816 /* Will be transformed into an AOTCONST later */
8821 }
8822 }
8823 /* FIXME: Generalize this */
8829 }
8834 /* Can't embed random pointers into AOT code */
8837 }
8840 gpointer ptr;
8854 }
8858 }
8865 // FIXME:
8871 }
8888 }
8901 /*
8902 * Similar to LDOBJ, but instead load the unmanaged
8903 * representation of the vtype to the stack.
8904 */
8913 {
8928 }
8931 /*
8932 * Same as RET, but return the native representation of a vtype
8933 * to the caller.
8934 */
8950 }
8954 UNVERIFIED;
8963 }
8974 else
8980 }
8983 #ifdef MONO_ARCH_HAVE_LMF_OPS
8987 #endif
9017 }
9019 }
9025 /* somewhat similar to LDTOKEN */
9028 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
9039 }
9047 /*
9048 * The following transforms:
9049 * CEE_CEQ into OP_CEQ
9050 * CEE_CGT into OP_CGT
9051 * CEE_CGT_UN into OP_CGT_UN
9052 * CEE_CLT into OP_CLT
9053 * CEE_CLT_UN into OP_CLT_UN
9054 */
9063 if ((sp [0]->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
9067 else
9075 /*
9076 * The backends expect the fceq opcodes to do the
9077 * comparison too.
9078 */
9082 }
9087 }
9091 gboolean needs_static_rgctx_invoke;
9110 METHOD_ACCESS_FAILURE;
9114 INLINE_FAILURE;
9115 CHECK_CFG_EXCEPTION;
9118 }
9120 /*
9121 * Optimize the common case of ldftn+delegate creation
9122 */
9123 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE) && !defined(HAVE_WRITE_BARRIERS)
9124 /* FIXME: SGEN support */
9125 /* FIXME: handle shared static generic methods */
9126 /* FIXME: handle this in shared code */
9127 if (!needs_static_rgctx_invoke && !context_used && (sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
9128 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
9139 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9141 sp --;
9144 sp ++;
9146 }
9147 }
9148 #endif
9159 }
9166 }
9183 INLINE_FAILURE;
9184 CHECK_CFG_EXCEPTION;
9187 }
9199 }
9204 }
9231 UNVERIFIED;
9255 }
9261 }
9269 UNVERIFIED;
9278 UNVERIFIED;
9280 /*
9281 * Inlining this into a loop in a parent could lead to
9282 * stack overflows which is different behavior than the
9283 * non-inlined case, thus disable inlining in this case.
9284 */
9307 UNVERIFIED;
9319 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
9323 }
9324 }
9327 UNVERIFIED;
9330 }
9333 /* FIXME: record alignment? we can assume 1 for now */
9344 /* Can't inline tail calls at this time */
9357 else
9375 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
9377 } 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)) {
9378 /* emit_memset only works when val == 0 */
9390 }
9391 }
9395 }
9402 /* we ignore the no-nullcheck for now since we
9403 * really do it explicitly only when doing callvirt->call
9404 */
9413 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
9416 }
9417 }
9432 }
9434 guint32 align;
9448 }
9453 }
9460 // FIXME:
9463 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9465 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
9469 }
9476 }
9478 }
9481 }
9482 }
9484 UNVERIFIED;
9497 }
9501 }
9504 }
9539 }
9540 }
9541 }
9553 }
9554 }
9562 /* Method is too large */
9568 }
9575 exception_exit:
9581 inline_failure:
9586 load_error:
9592 unverified:
9597 }
9599 static int
9601 {
9615 }
9618 }
9622 int
9624 {
9686 #if defined(__i386__) || defined (__x86_64__)
9691 #endif
9692 #if defined(__x86_64__)
9695 #endif
9706 }
9709 }
9711 static int
9713 {
9739 }
9742 }
9744 static int
9746 {
9765 }
9768 }
9770 int
9772 {
9773 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
9774 #if defined(__i386__) || defined(__x86_64__)
9786 #if SIZEOF_REGISTER == 8
9789 #endif
9790 }
9791 #endif
9794 }
9798 {
9799 #if defined(__i386__)
9831 }
9832 #endif
9834 #if defined(__x86_64__)
9835 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
9886 }
9887 #endif
9890 }
9894 {
9895 #if defined(__i386__) || defined(__x86_64__)
9903 }
9904 #endif
9907 }
9911 {
9912 #ifdef __i386__
9913 /* FIXME: This has sign extension issues */
9914 /*
9915 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
9916 return OP_X86_COMPARE_MEMBASE8_IMM;
9917 */
9919 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
9931 }
9932 #endif
9934 #ifdef __x86_64__
9935 /* FIXME: This has sign extension issues */
9936 /*
9937 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
9938 return OP_X86_COMPARE_MEMBASE8_IMM;
9939 */
9946 /* FIXME: This only works for 32 bit immediates
9947 case OP_COMPARE_IMM:
9948 case OP_LCOMPARE_IMM:
9949 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
9950 return OP_AMD64_COMPARE_MEMBASE_IMM;
9951 */
9965 }
9966 #endif
9969 }
9973 {
9974 #ifdef __i386__
9975 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
9992 }
9993 #endif
9995 #ifdef __x86_64__
10036 }
10037 #endif
10040 }
10042 int
10044 {
10046 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
10050 #endif
10051 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
10056 #endif
10060 }
10061 }
10063 #ifndef DISABLE_JIT
10065 /**
10066 * mono_handle_global_vregs:
10067 *
10068 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
10069 * for them.
10070 */
10071 void
10073 {
10080 #ifdef MONO_ARCH_SIMD_INTRINSICS
10083 #endif
10085 /* Find local vregs used in more than one bb */
10097 gint32 prev_bb;
10122 }
10124 #if SIZEOF_REGISTER == 4
10126 /*
10127 * Since some instructions reference the original long vreg,
10128 * and some reference the two component vregs, it is quite hard
10129 * to determine when it needs to be global. So be conservative.
10130 */
10132 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10136 }
10138 /*
10139 * Make the component vregs volatile since the optimizations can
10140 * get confused otherwise.
10141 */
10144 }
10145 #endif
10151 /* 0 is a valid block num */
10154 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
10166 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
10173 }
10174 }
10176 /* Flag as having been used in more than one bb */
10178 }
10179 }
10180 }
10181 }
10183 /* If a variable is used in only one bblock, convert it into a local vreg */
10194 #if SIZEOF_REGISTER == 8
10196 #endif
10197 #if !defined(__i386__) && !defined(MONO_ARCH_SOFT_FLOAT)
10198 /* Enabling this screws up the fp stack on x86 */
10200 #endif
10201 /* Arguments are implicitly global */
10202 /* Putting R4 vars into registers doesn't work currently */
10203 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) {
10204 /*
10205 * Make that the variable's liveness interval doesn't contain a call, since
10206 * that would cause the lvreg to be spilled, making the whole optimization
10207 * useless.
10208 */
10209 /* This is too slow for JIT compilation */
10210 #if 0
10230 }
10231 }
10236 ins_index ++;
10237 }
10241 }
10242 #endif
10248 }
10250 }
10251 }
10253 /*
10254 * Compress the varinfo and vars tables so the liveness computation is faster and
10255 * takes up less space.
10256 */
10268 #if SIZEOF_REGISTER == 4
10270 /* Modify the two component vars too */
10277 }
10278 #endif
10279 }
10280 pos ++;
10281 }
10282 }
10286 }
10288 /**
10289 * mono_spill_global_vars:
10290 *
10291 * Generate spill code for variables which are not allocated to registers,
10292 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
10293 * code is generated which could be optimized by the local optimization passes.
10294 */
10295 void
10297 {
10313 /* FIXME: Move this function to mini.c */
10317 #ifdef MONO_ARCH_SIMD_INTRINSICS
10319 #endif
10321 #if SIZEOF_REGISTER == 4
10322 /* Create MonoInsts for longs */
10328 #ifdef MONO_ARCH_SOFT_FLOAT
10330 #endif
10348 }
10351 }
10352 }
10353 }
10354 #endif
10356 /* FIXME: widening and truncation */
10358 /*
10359 * As an optimization, when a variable allocated to the stack is first loaded into
10360 * an lvreg, we will remember the lvreg and use it the next time instead of loading
10361 * the variable again.
10362 */
10368 /*
10369 * These arrays contain the first and last instructions accessing a given
10370 * variable.
10371 * Since we emit bblocks in the same order we process them here, and we
10372 * don't split live ranges, these will precisely describe the live range of
10373 * the variable, i.e. the instruction range where a valid value can be found
10374 * in the variables location.
10375 */
10376 /* FIXME: Only do this if debugging info is requested */
10382 /* Add spill loads/stores */
10389 /* Clear vreg_to_lvreg array */
10406 /*
10407 * We handle LDADDR here as well, since it can only be decomposed
10408 * when variable addresses are known.
10409 */
10414 /* Happens on SPARC/S390 where vtypes are passed by reference */
10419 }
10425 NOT_IMPLEMENTED;
10432 }
10436 }
10441 }
10443 /*
10444 * Store opcodes have destbasereg in the dreg, but in reality, it is an
10445 * src register.
10446 * FIXME:
10447 */
10460 else
10467 /***************/
10468 /* DREG */
10469 /***************/
10471 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
10485 } 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)) {
10486 /*
10487 * Instead of emitting a load+store, use a _membase opcode.
10488 */
10498 }
10501 guint32 lvreg;
10507 /* Invalidate any previous lvreg for this vreg */
10512 #ifdef MONO_ARCH_SOFT_FLOAT
10516 }
10517 #endif
10522 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
10524 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
10527 }
10531 /* Try to fuse the store into the instruction itself */
10532 /* FIXME: Add more instructions */
10533 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
10538 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
10555 // FIXME: The backends expect the base reg to be in inst_basereg
10562 /* printf ("INS: "); mono_print_ins (ins); */
10563 /* Create a store instruction */
10564 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
10566 /* Insert it after the instruction */
10571 /*
10572 * We can't assign ins->dreg to var->dreg here, since the
10573 * sregs could use it. So set a flag, and do it after
10574 * the sregs.
10575 */
10576 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)))
10578 }
10579 }
10580 }
10585 }
10586 }
10588 /************/
10589 /* SREGS */
10590 /************/
10600 guint32 load_opcode;
10605 else
10610 }
10619 /* The variable is already loaded to an lvreg */
10624 else
10627 }
10629 /* Try to fuse the load into the instruction */
10643 //printf ("%d ", srcindex); mono_print_ins (ins);
10647 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) {
10649 /*
10650 * sreg refers to the value loaded by the load
10651 * emitted below, but we need to use ins->dreg
10652 * since it refers to the store emitted earlier.
10653 */
10655 }
10659 }
10660 }
10664 else
10668 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
10670 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
10673 }
10675 #if SIZEOF_REGISTER == 4
10677 #endif
10681 }
10682 }
10687 }
10688 }
10689 }
10696 }
10702 }
10705 /* Clear vreg_to_lvreg array */
10709 }
10713 }
10714 }
10716 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
10717 /*
10718 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
10719 * by storing the current native offset into MonoMethodVar->live_range_start/end.
10720 */
10729 }
10734 }
10735 }
10736 #endif
10742 }
10744 /**
10745 * FIXME:
10746 * - use 'iadd' instead of 'int_add'
10747 * - handling ovf opcodes: decompose in method_to_ir.
10748 * - unify iregs/fregs
10749 * -> partly done, the missing parts are:
10750 * - a more complete unification would involve unifying the hregs as well, so
10751 * code wouldn't need if (fp) all over the place. but that would mean the hregs
10752 * would no longer map to the machine hregs, so the code generators would need to
10753 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
10754 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
10755 * fp/non-fp branches speeds it up by about 15%.
10756 * - use sext/zext opcodes instead of shifts
10757 * - add OP_ICALL
10758 * - get rid of TEMPLOADs if possible and use vregs instead
10759 * - clean up usage of OP_P/OP_ opcodes
10760 * - cleanup usage of DUMMY_USE
10761 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
10762 * stack
10763 * - set the stack type and allocate a dreg in the EMIT_NEW macros
10764 * - get rid of all the <foo>2 stuff when the new JIT is ready.
10765 * - make sure handle_stack_args () is called before the branch is emitted
10766 * - when the new IR is done, get rid of all unused stuff
10767 * - COMPARE/BEQ as separate instructions or unify them ?
10768 * - keeping them separate allows specialized compare instructions like
10769 * compare_imm, compare_membase
10770 * - most back ends unify fp compare+branch, fp compare+ceq
10771 * - integrate mono_save_args into inline_method
10772 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
10773 * - handle long shift opts on 32 bit platforms somehow: they require
10774 * 3 sregs (2 for arg1 and 1 for arg2)
10775 * - make byref a 'normal' type.
10776 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
10777 * variable if needed.
10778 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
10779 * like inline_method.
10780 * - remove inlining restrictions
10781 * - fix LNEG and enable cfold of INEG
10782 * - generalize x86 optimizations like ldelema as a peephole optimization
10783 * - add store_mem_imm for amd64
10784 * - optimize the loading of the interruption flag in the managed->native wrappers
10785 * - avoid special handling of OP_NOP in passes
10786 * - move code inserting instructions into one function/macro.
10787 * - try a coalescing phase after liveness analysis
10788 * - add float -> vreg conversion + local optimizations on !x86
10789 * - figure out how to handle decomposed branches during optimizations, ie.
10790 * compare+branch, op_jump_table+op_br etc.
10791 * - promote RuntimeXHandles to vregs
10792 * - vtype cleanups:
10793 * - add a NEW_VARLOADA_VREG macro
10794 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
10795 * accessing vtype fields.
10796 * - get rid of I8CONST on 64 bit platforms
10797 * - dealing with the increase in code size due to branches created during opcode
10798 * decomposition:
10799 * - use extended basic blocks
10800 * - all parts of the JIT
10801 * - handle_global_vregs () && local regalloc
10802 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
10803 * - sources of increase in code size:
10804 * - vtypes
10805 * - long compares
10806 * - isinst and castclass
10807 * - lvregs not allocated to global registers even if used multiple times
10808 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
10809 * meaningful.
10810 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
10811 * - add all micro optimizations from the old JIT
10812 * - put tree optimizations into the deadce pass
10813 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
10814 * specific function.
10815 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
10816 * fcompare + branchCC.
10817 * - create a helper function for allocating a stack slot, taking into account
10818 * MONO_CFG_HAS_SPILLUP.
10819 * - merge r68207.
10820 * - merge the ia64 switch changes.
10821 * - optimize mono_regstate2_alloc_int/float.
10822 * - fix the pessimistic handling of variables accessed in exception handler blocks.
10823 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
10824 * parts of the tree could be separated by other instructions, killing the tree
10825 * arguments, or stores killing loads etc. Also, should we fold loads into other
10826 * instructions if the result of the load is used multiple times ?
10827 * - make the REM_IMM optimization in mini-x86.c arch-independent.
10828 * - LAST MERGE: 108395.
10829 * - when returning vtypes in registers, generate IR and append it to the end of the
10830 * last bb instead of doing it in the epilog.
10831 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
10832 */
10834 /*
10836 NOTES
10837 -----
10839 - When to decompose opcodes:
10840 - earlier: this makes some optimizations hard to implement, since the low level IR
10841 no longer contains the neccessary information. But it is easier to do.
10842 - later: harder to implement, enables more optimizations.
10843 - Branches inside bblocks:
10844 - created when decomposing complex opcodes.
10845 - branches to another bblock: harmless, but not tracked by the branch
10846 optimizations, so need to branch to a label at the start of the bblock.
10847 - branches to inside the same bblock: very problematic, trips up the local
10848 reg allocator. Can be fixed by spitting the current bblock, but that is a
10849 complex operation, since some local vregs can become global vregs etc.
10850 - Local/global vregs:
10851 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
10852 local register allocator.
10853 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
10854 structure, created by mono_create_var (). Assigned to hregs or the stack by
10855 the global register allocator.
10856 - When to do optimizations like alu->alu_imm:
10857 - earlier -> saves work later on since the IR will be smaller/simpler
10858 - later -> can work on more instructions
10859 - Handling of valuetypes:
10860 - When a vtype is pushed on the stack, a new temporary is created, an
10861 instruction computing its address (LDADDR) is emitted and pushed on
10862 the stack. Need to optimize cases when the vtype is used immediately as in
10863 argument passing, stloc etc.
10864 - Instead of the to_end stuff in the old JIT, simply call the function handling
10865 the values on the stack before emitting the last instruction of the bb.
10866 */