| blob | 98c27ed01ac103577f2c13c871015393624687a3 |
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>
62 #define BRANCH_COST 100
63 #define INLINE_LENGTH_LIMIT 20
64 #define INLINE_FAILURE do {\
65 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
66 goto inline_failure;\
67 } while (0)
68 #define CHECK_CFG_EXCEPTION do {\
69 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
70 goto exception_exit;\
71 } while (0)
72 #define METHOD_ACCESS_FAILURE do { \
73 char *method_fname = mono_method_full_name (method, TRUE); \
74 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
75 cfg->exception_type = MONO_EXCEPTION_METHOD_ACCESS; \
76 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
77 g_free (method_fname); \
78 g_free (cil_method_fname); \
79 goto exception_exit; \
80 } while (0)
81 #define FIELD_ACCESS_FAILURE do { \
82 char *method_fname = mono_method_full_name (method, TRUE); \
83 char *field_fname = mono_field_full_name (field); \
84 cfg->exception_type = MONO_EXCEPTION_FIELD_ACCESS; \
85 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
86 g_free (method_fname); \
87 g_free (field_fname); \
88 goto exception_exit; \
89 } while (0)
90 #define GENERIC_SHARING_FAILURE(opcode) do { \
91 if (cfg->generic_sharing_context) { \
92 if (cfg->verbose_level > 2) \
93 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__); \
94 cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED; \
95 goto exception_exit; \
96 } \
97 } while (0)
99 /* Determine whenever 'ins' represents a load of the 'this' argument */
100 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
108 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
109 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
112 /* helper methods signature */
119 /*
120 * Instruction metadata
121 */
122 #ifdef MINI_OP
123 #undef MINI_OP
124 #endif
125 #ifdef MINI_OP3
126 #undef MINI_OP3
127 #endif
129 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
135 #if SIZEOF_REGISTER == 8
136 #define LREG IREG
137 #else
139 #endif
140 /* keep in sync with the enum in mini.h */
141 const char
142 ins_info[] = {
144 };
145 #undef MINI_OP
146 #undef MINI_OP3
148 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
149 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
150 /*
151 * This should contain the index of the last sreg + 1. This is not the same
152 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
153 */
156 };
157 #undef MINI_OP
158 #undef MINI_OP3
162 #define MONO_INIT_VARINFO(vi,id) do { \
163 (vi)->range.first_use.pos.bid = 0xffff; \
164 (vi)->reg = -1; \
165 (vi)->idx = (id); \
166 } while (0)
168 void
170 {
174 }
176 guint32
178 {
180 }
182 guint32
184 {
186 }
188 guint32
190 {
192 }
194 guint32
196 {
198 }
200 guint
202 {
206 handle_enum:
232 #if SIZEOF_REGISTER == 8
234 #else
236 #endif
245 }
260 }
262 }
264 void
266 {
279 }
281 /*
282 * Can't put this at the beginning, since other files reference stuff from this
283 * file.
284 */
285 #ifndef DISABLE_JIT
287 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
289 #define GET_BBLOCK(cfg,tblock,ip) do { \
290 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
291 if (!(tblock)) { \
292 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
293 NEW_BBLOCK (cfg, (tblock)); \
294 (tblock)->cil_code = (ip); \
295 ADD_BBLOCK (cfg, (tblock)); \
296 } \
297 } while (0)
299 #if defined(TARGET_X86) || defined(TARGET_AMD64)
300 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
301 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
302 (dest)->dreg = alloc_preg ((cfg)); \
303 (dest)->sreg1 = (sr1); \
304 (dest)->sreg2 = (sr2); \
305 (dest)->inst_imm = (imm); \
306 (dest)->backend.shift_amount = (shift); \
307 MONO_ADD_INS ((cfg)->cbb, (dest)); \
308 } while (0)
309 #endif
311 #if SIZEOF_REGISTER == 8
312 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
314 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
315 MonoInst *widen; \
316 int dr = alloc_preg (cfg); \
317 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
318 (ins)->sreg2 = widen->dreg; \
319 } \
320 } while (0)
321 #else
322 #define ADD_WIDEN_OP(ins, arg1, arg2)
323 #endif
325 #define ADD_BINOP(op) do { \
326 MONO_INST_NEW (cfg, ins, (op)); \
327 sp -= 2; \
328 ins->sreg1 = sp [0]->dreg; \
329 ins->sreg2 = sp [1]->dreg; \
330 type_from_op (ins, sp [0], sp [1]); \
331 CHECK_TYPE (ins); \
333 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
334 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
335 MONO_ADD_INS ((cfg)->cbb, (ins)); \
336 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
337 } while (0)
339 #define ADD_UNOP(op) do { \
340 MONO_INST_NEW (cfg, ins, (op)); \
341 sp--; \
342 ins->sreg1 = sp [0]->dreg; \
343 type_from_op (ins, sp [0], NULL); \
344 CHECK_TYPE (ins); \
345 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
346 MONO_ADD_INS ((cfg)->cbb, (ins)); \
347 *sp++ = mono_decompose_opcode (cfg, ins); \
348 } while (0)
350 #define ADD_BINCOND(next_block) do { \
351 MonoInst *cmp; \
352 sp -= 2; \
353 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
354 cmp->sreg1 = sp [0]->dreg; \
355 cmp->sreg2 = sp [1]->dreg; \
356 type_from_op (cmp, sp [0], sp [1]); \
357 CHECK_TYPE (cmp); \
358 type_from_op (ins, sp [0], sp [1]); \
359 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
360 GET_BBLOCK (cfg, tblock, target); \
361 link_bblock (cfg, bblock, tblock); \
362 ins->inst_true_bb = tblock; \
363 if ((next_block)) { \
364 link_bblock (cfg, bblock, (next_block)); \
365 ins->inst_false_bb = (next_block); \
366 start_new_bblock = 1; \
367 } else { \
368 GET_BBLOCK (cfg, tblock, ip); \
369 link_bblock (cfg, bblock, tblock); \
370 ins->inst_false_bb = tblock; \
371 start_new_bblock = 2; \
372 } \
373 if (sp != stack_start) { \
374 handle_stack_args (cfg, stack_start, sp - stack_start); \
375 CHECK_UNVERIFIABLE (cfg); \
376 } \
377 MONO_ADD_INS (bblock, cmp); \
378 MONO_ADD_INS (bblock, ins); \
379 } while (0)
381 /* *
382 * link_bblock: Links two basic blocks
383 *
384 * links two basic blocks in the control flow graph, the 'from'
385 * argument is the starting block and the 'to' argument is the block
386 * the control flow ends to after 'from'.
387 */
388 static void
390 {
394 #if 0
397 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
398 else
403 else
405 }
406 #endif
413 }
414 }
419 }
423 }
430 }
431 }
436 }
440 }
441 }
443 void
445 {
447 }
449 /**
450 * mono_find_block_region:
451 *
452 * We mark each basic block with a region ID. We use that to avoid BB
453 * optimizations when blocks are in different regions.
454 *
455 * Returns:
456 * A region token that encodes where this region is, and information
457 * about the clause owner for this block.
458 *
459 * The region encodes the try/catch/filter clause that owns this block
460 * as well as the type. -1 is a special value that represents a block
461 * that is in none of try/catch/filter.
462 */
463 static int
465 {
473 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
482 else
484 }
488 }
491 }
495 {
511 }
512 }
513 }
515 }
517 static void
519 {
527 /* prevent it from being register allocated */
531 }
535 {
537 }
541 {
549 /* prevent it from being register allocated */
555 }
557 /*
558 * Returns the type used in the eval stack when @type is loaded.
559 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
560 */
561 void
563 {
570 }
572 handle_enum:
616 }
626 /* FIXME: all the arguments must be references for now,
627 * later look inside cfg and see if the arg num is
628 * really a reference
629 */
635 }
636 }
638 /*
639 * The following tables are used to quickly validate the IL code in type_from_op ().
640 */
641 static const char
651 };
653 static const char
654 neg_table [] = {
656 };
658 /* reduce the size of this table */
659 static const char
669 };
671 static const char
673 /* Inv i L p F & O vt */
682 };
684 /* reduce the size of this table */
685 static const char
695 };
697 /*
698 * Tables to map from the non-specific opcode to the matching
699 * type-specific opcode.
700 */
701 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
702 static const guint16
705 };
707 /* handles from CEE_NEG to CEE_CONV_U8 */
708 static const guint16
711 };
713 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
714 static const guint16
716 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
717 };
719 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
720 static const guint16
722 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
723 };
725 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
726 static const guint16
728 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
729 };
731 /* handles from CEE_BEQ to CEE_BLT_UN */
732 static const guint16
734 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
735 };
737 /* handles from CEE_CEQ to CEE_CLT_UN */
738 static const guint16
740 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
741 };
743 /*
744 * Sets ins->type (the type on the eval stack) according to the
745 * type of the opcode and the arguments to it.
746 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
747 *
748 * FIXME: this function sets ins->type unconditionally in some cases, but
749 * it should set it to invalid for some types (a conv.x on an object)
750 */
751 static void
755 /* binops */
761 /* FIXME: check unverifiable args for STACK_MP */
783 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
787 else
792 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
818 /* unops */
826 else
847 }
880 #if SIZEOF_REGISTER == 8
882 #else
884 #endif
892 }
960 }
964 }
966 static const char
967 ldind_type [] = {
968 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
969 };
971 #if 0
973 static const char
976 };
978 static int
990 }
991 args++;
992 }
1013 }
1026 }
1027 /*if (!param_table [args [i].type] [sig->params [i]->type])
1028 return 0;*/
1029 }
1031 }
1032 #endif
1034 /*
1035 * When we need a pointer to the current domain many times in a method, we
1036 * call mono_domain_get() once and we store the result in a local variable.
1037 * This function returns the variable that represents the MonoDomain*.
1038 */
1041 {
1045 }
1047 /*
1048 * The got_var contains the address of the Global Offset Table when AOT
1049 * compiling.
1050 */
1051 MonoInst *
1053 {
1054 #ifdef MONO_ARCH_NEED_GOT_VAR
1059 }
1061 #else
1063 #endif
1064 }
1068 {
1073 /* force the var to be stack allocated */
1075 }
1078 }
1093 }
1095 }
1099 {
1133 else
1138 }
1141 }
1145 {
1179 }
1181 }
1183 /*
1184 * We try to share variables when possible
1185 */
1188 {
1192 /* inlining can result in deeper stacks */
1212 }
1214 }
1216 static void
1218 {
1219 /*
1220 * Don't use this if a generic_context is set, since that means AOT can't
1221 * look up the method using just the image+token.
1222 * table == 0 means this is a reference made from a wrapper.
1223 */
1225 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1229 }
1230 }
1232 /*
1233 * This function is called to handle items that are left on the evaluation stack
1234 * at basic block boundaries. What happens is that we save the values to local variables
1235 * and we reload them later when first entering the target basic block (with the
1236 * handle_loaded_temps () function).
1237 * A single joint point will use the same variables (stored in the array bb->out_stack or
1238 * bb->in_stack, if the basic block is before or after the joint point).
1239 *
1240 * This function needs to be called _before_ emitting the last instruction of
1241 * the bb (i.e. before emitting a branch).
1242 * If the stack merge fails at a join point, cfg->unverifiable is set.
1243 */
1244 static void
1246 {
1251 gboolean found;
1259 //printf ("bblock %d has out:", bb->block_num);
1263 /* exception handlers are linked, but they should not be considered for stack args */
1266 //printf (" %d", outb->block_num);
1271 }
1272 }
1273 //printf ("\n");
1277 /*
1278 * try to reuse temps already allocated for this purpouse, if they occupy the same
1279 * stack slot and if they are of the same type.
1280 * This won't cause conflicts since if 'local' is used to
1281 * store one of the values in the in_stack of a bblock, then
1282 * the same variable will be used for the same outgoing stack
1283 * slot as well.
1284 * This doesn't work when inlining methods, since the bblocks
1285 * in the inlined methods do not inherit their in_stack from
1286 * the bblock they are inlined to. See bug #58863 for an
1287 * example.
1288 */
1291 else
1293 }
1294 }
1295 }
1299 /* exception handlers are linked, but they should not be considered for stack args */
1306 }
1308 }
1311 }
1321 }
1323 /*
1324 * It is possible that the out bblocks already have in_stack assigned, and
1325 * the in_stacks differ. In this case, we will store to all the different
1326 * in_stacks.
1327 */
1332 /* Find a bblock which has a different in_stack */
1336 /* exception handlers are linked, but they should not be considered for stack args */
1338 bindex++;
1340 }
1348 }
1352 }
1353 bindex ++;
1354 }
1355 }
1356 }
1358 /* Emit code which loads interface_offsets [klass->interface_id]
1359 * The array is stored in memory before vtable.
1360 */
1361 static void
1362 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1363 {
1371 }
1373 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1374 }
1375 }
1377 /*
1378 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1379 * stored in "klass_reg" implements the interface "klass".
1380 */
1381 static void
1382 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1383 {
1387 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap));
1399 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1405 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1406 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1407 }
1408 }
1410 /*
1411 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1412 * stored in "vtable_reg" implements the interface "klass".
1413 */
1414 static void
1415 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1416 {
1420 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap));
1432 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1438 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1439 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1440 }
1441 }
1443 /*
1444 * Emit code which checks whenever the interface id of @klass is smaller than
1445 * than the value given by max_iid_reg.
1446 */
1447 static void
1450 {
1455 }
1456 else
1460 else
1462 }
1464 /* Same as above, but obtains max_iid from a vtable */
1465 static void
1468 {
1471 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1473 }
1475 /* Same as above, but obtains max_iid from a klass */
1476 static void
1479 {
1482 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1484 }
1486 static void
1487 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1488 {
1494 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1497 }
1498 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1506 }
1508 }
1510 static void
1511 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1512 {
1520 else
1522 }
1524 /*
1525 * Variant of the above that takes a register to the class, not the vtable.
1526 */
1527 static void
1528 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1529 {
1537 else
1539 }
1543 {
1550 }
1552 }
1555 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1556 {
1563 }
1565 }
1567 static void
1568 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1569 {
1574 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1577 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1578 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1582 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1585 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1592 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1594 }
1597 /* Check that the object is a vector too */
1602 }
1609 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1612 }
1613 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1616 }
1617 }
1619 static void
1621 {
1640 #if SIZEOF_REGISTER == 8
1644 #endif
1645 }
1646 }
1652 else
1656 /* This could be optimized further if neccesary */
1661 }
1663 }
1665 #if !NO_UNALIGNED_ACCESS
1671 }
1676 }
1677 }
1678 #endif
1684 }
1689 }
1694 }
1695 }
1699 void
1700 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1701 {
1708 /* This could be optimized further if neccesary */
1716 }
1717 }
1719 #if !NO_UNALIGNED_ACCESS
1728 }
1729 }
1730 #endif
1739 }
1747 }
1755 }
1756 }
1758 #ifndef DISABLE_JIT
1760 static int
1761 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1762 {
1766 handle_enum:
1810 }
1812 }
1814 /*
1815 * target_type_is_incompatible:
1816 * @cfg: MonoCompile context
1817 *
1818 * Check that the item @arg on the evaluation stack can be stored
1819 * in the target type (can be a local, or field, etc).
1820 * The cfg arg can be used to check if we need verification or just
1821 * validity checks.
1822 *
1823 * Returns: non-0 value if arg can't be stored on a target.
1824 */
1825 static int
1827 {
1832 /* FIXME: check that the pointed to types match */
1838 }
1856 /* STACK_MP is needed when setting pinned locals */
1873 /* FIXME: check type compatibility */
1910 /* FIXME: check type compatibility */
1912 }
1915 /* FIXME: all the arguments must be references for now,
1916 * later look inside cfg and see if the arg num is
1917 * really a reference
1918 */
1925 }
1927 }
1929 /*
1930 * Prepare arguments for passing to a function call.
1931 * Return a non-zero value if the arguments can't be passed to the given
1932 * signature.
1933 * The type checks are not yet complete and some conversions may need
1934 * casts on 32 or 64 bit architectures.
1935 *
1936 * FIXME: implement this using target_type_is_incompatible ()
1937 */
1938 static int
1940 {
1947 args++;
1948 }
1954 }
1957 handle_enum:
1977 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2002 }
2017 }
2018 }
2020 }
2022 static int
2024 {
2038 }
2041 }
2043 static int
2045 {
2059 }
2062 }
2064 #ifdef MONO_ARCH_HAVE_IMT
2065 static void
2067 {
2068 #ifdef MONO_ARCH_IMT_REG
2081 }
2084 #else
2086 #endif
2087 }
2088 #endif
2092 {
2100 }
2108 {
2110 #ifdef MONO_ARCH_SOFT_FLOAT
2112 #endif
2116 else
2117 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2127 //g_assert_not_reached ();
2128 }
2135 /*
2136 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2137 * address of return value to increase optimization opportunities.
2138 * Before vtype decomposition, the dreg of the call ins itself represents the
2139 * fact the call modifies the return value. After decomposition, the call will
2140 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2141 * will be transformed into an LDADDR.
2142 */
2146 /* We reference the call too since call->dreg could change during optimization */
2156 #ifdef MONO_ARCH_SOFT_FLOAT
2157 /*
2158 * If the call has a float argument, we would need to do an r8->r4 conversion using
2159 * an icall, but that cannot be done during the call sequence since it would clobber
2160 * the call registers + the stack. So we do it before emitting the call.
2161 */
2168 else
2179 /* The result will be in an int vreg */
2181 }
2182 }
2183 #endif
2185 #ifdef ENABLE_LLVM
2188 else
2190 #else
2192 #endif
2198 }
2202 {
2210 }
2213 mono_emit_rgctx_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2214 {
2215 #ifdef MONO_ARCH_RGCTX_REG
2222 }
2228 }
2230 #else
2233 #endif
2234 }
2237 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2244 {
2245 gboolean might_be_remote;
2252 /* Create the real signature */
2253 /* FIXME: Cache these */
2258 }
2270 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2273 }
2279 else
2289 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2290 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2291 /* Make a call to delegate->invoke_impl */
2298 }
2299 #endif
2305 /*
2306 * the method is not virtual, we just need to ensure this is not null
2307 * and then we can call the method directly.
2308 */
2311 }
2317 }
2324 }
2327 /*
2328 * the method is virtual, but we can statically dispatch since either
2329 * it's class or the method itself are sealed.
2330 * But first we need to ensure it's not a null reference.
2331 */
2340 }
2348 #ifdef MONO_ARCH_HAVE_IMT
2354 }
2355 #endif
2360 }
2365 #ifdef MONO_ARCH_HAVE_IMT
2369 }
2370 #endif
2371 }
2375 }
2380 }
2383 mono_emit_rgctx_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2385 {
2391 #ifdef MONO_ARCH_RGCTX_REG
2394 #else
2395 NOT_IMPLEMENTED;
2396 #endif
2397 }
2402 #ifdef MONO_ARCH_RGCTX_REG
2406 #else
2407 NOT_IMPLEMENTED;
2408 #endif
2409 }
2412 }
2416 {
2417 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL);
2418 }
2420 MonoInst*
2423 {
2434 }
2438 {
2444 }
2446 /*
2447 * mono_emit_abs_call:
2448 *
2449 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2450 */
2454 {
2458 /*
2459 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2460 * handle it.
2461 */
2468 }
2472 {
2477 /*
2478 * Native code might return non register sized integers
2479 * without initializing the upper bits.
2480 */
2496 }
2505 }
2506 }
2507 }
2510 }
2514 {
2520 }
2522 }
2524 /*
2525 * Emit code to copy a valuetype of type @klass whose address is stored in
2526 * @src->dreg to memory whose address is stored at @dest->dreg.
2527 */
2528 void
2529 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2530 {
2537 /*
2538 * This check breaks with spilled vars... need to handle it during verification anyway.
2539 * g_assert (klass && klass == src->klass && klass == dest->klass);
2540 */
2544 else
2547 #if HAVE_WRITE_BARRIERS
2548 /* if native is true there should be no references in the struct */
2550 /* Avoid barriers when storing to the stack */
2565 }
2568 }
2569 }
2570 #endif
2573 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2582 }
2583 }
2587 {
2593 }
2595 }
2597 void
2599 {
2602 guint32 align;
2605 /* FIXME: Optimize this for the case when dest is an LDADDR */
2612 }
2619 }
2620 }
2624 {
2657 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2659 }
2668 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2670 }
2671 }
2674 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2675 {
2685 }
2689 {
2690 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2691 }
2696 {
2697 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);
2701 }
2706 {
2707 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);
2711 }
2716 {
2717 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);
2721 }
2723 /*
2724 * On return the caller must check @klass for load errors.
2725 */
2726 static void
2728 {
2745 }
2747 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
2748 #ifdef MONO_ARCH_VTABLE_REG
2751 #else
2752 NOT_IMPLEMENTED;
2753 #endif
2754 }
2756 /*
2757 * On return the caller must check @array_class for load errors
2758 */
2759 static void
2761 {
2779 }
2800 }
2801 }
2804 }
2806 static void
2808 {
2818 }
2824 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
2826 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
2827 }
2828 }
2830 static void
2832 {
2833 /* Reset the variables holding the cast details */
2838 /* It is enough to reset the from field */
2839 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
2840 }
2841 }
2843 /**
2844 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
2845 * generic code is generated.
2846 */
2849 {
2855 /* FIXME: What if the class is shared? We might not
2856 have to get the address of the method from the
2857 RGCTX. */
2859 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
2866 }
2867 }
2871 {
2881 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
2883 /* FIXME: generics */
2886 // Check rank == 0
2891 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
2896 /* This assertion is from the unboxcast insn */
2908 }
2910 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_PTR), obj_reg, sizeof (MonoObject));
2916 }
2918 /*
2919 * Returns NULL and set the cfg exception on error.
2920 */
2923 {
2932 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
2933 /* This happens often in argument checking code, eg. throw new FooException... */
2934 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
2940 gboolean pass_lw;
2946 }
2948 #ifndef MONO_CROSS_COMPILE
2950 #endif
2955 }
2962 }
2965 }
2966 }
2969 }
2973 gboolean for_box)
2974 {
2979 /*
2980 FIXME: we cannot get managed_alloc here because we can't get
2981 the class's vtable (because it's not a closed class)
2983 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
2984 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
2985 */
2995 }
2999 }
3002 }
3004 /*
3005 * Returns NULL and set the cfg exception on error.
3006 */
3009 {
3015 }
3021 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3024 }
3027 handle_box_from_inst (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used, MonoInst *data_inst)
3028 {
3033 /* FIXME: What if the class is shared? We might not
3034 have to get the method address from the RGCTX. */
3036 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3043 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3046 }
3047 }
3049 /*
3050 * Returns NULL and set the cfg exception on error.
3051 */
3054 {
3074 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3075 /* the remoting code is broken, access the class for now */
3076 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3082 }
3087 }
3092 }
3093 }
3100 }
3102 /*
3103 * Returns NULL and set the cfg exception on error.
3104 */
3107 {
3118 /* Do the assignment at the beginning, so the other assignment can be if converted */
3128 /* the is_null_bb target simply copies the input register to the output */
3139 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3143 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3147 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3151 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3161 /* Check that the object is a vector too */
3166 }
3168 /* the is_null_bb target simply copies the input register to the output */
3170 }
3173 /* the is_null_bb target simply copies the input register to the output */
3176 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3177 /* the remoting code is broken, access the class for now */
3178 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3184 }
3189 }
3194 /* the is_null_bb target simply copies the input register to the output */
3196 }
3197 }
3198 }
3210 }
3214 {
3215 /* This opcode takes as input an object reference and a class, and returns:
3216 0) if the object is an instance of the class,
3217 1) if the object is not instance of the class,
3218 2) if the object is a proxy whose type cannot be determined */
3245 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3248 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3256 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3258 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3259 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3262 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3272 }
3290 /* FIXME: */
3296 }
3300 {
3301 /* This opcode takes as input an object reference and a class, and returns:
3302 0) if the object is an instance of the class,
3303 1) if the object is a proxy whose type cannot be determined
3304 an InvalidCastException exception is thrown otherwhise*/
3330 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3342 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3345 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3346 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3349 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3365 }
3373 /* FIXME: */
3379 }
3381 /*
3382 * Returns NULL and set the cfg exception on error.
3383 */
3385 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method)
3386 {
3396 /* Inline the contents of mono_delegate_ctor */
3398 /* Set target field */
3399 /* Optimize away setting of NULL target */
3401 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3403 /* Set method field */
3405 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3407 /*
3408 * To avoid looking up the compiled code belonging to the target method
3409 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3410 * store it, and we fill it after the method has been compiled.
3411 */
3423 }
3427 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3428 }
3430 /* Set invoke_impl field */
3436 }
3437 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3439 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3442 }
3446 {
3449 /* Need to register the icall so it gets an icall wrapper */
3454 /* mono_array_new_va () needs a vararg calling convention */
3457 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3459 }
3461 static void
3463 {
3472 /* Add it to the start of the first bblock */
3476 }
3477 else
3482 /*
3483 * Add a dummy use to keep the got_var alive, since real uses might
3484 * only be generated by the back ends.
3485 * Add it to end_bblock, so the variable's lifetime covers the whole
3486 * method.
3487 * It would be better to make the usage of the got var explicit in all
3488 * cases when the backend needs it (i.e. calls, throw etc.), so this
3489 * wouldn't be needed.
3490 */
3493 }
3498 static gboolean
3500 {
3503 #ifdef MONO_ARCH_SOFT_FLOAT
3506 #endif
3514 #ifdef MONO_ARCH_HAVE_LMF_OPS
3519 #endif
3522 /* Avoid inflating the header */
3524 else
3536 /* also consider num_locals? */
3537 /* Do the size check early to avoid creating vtables */
3541 else
3544 }
3548 /*
3549 * if we can initialize the class of the method right away, we do,
3550 * otherwise we don't allow inlining if the class needs initialization,
3551 * since it would mean inserting a call to mono_runtime_class_init()
3552 * inside the inlined code
3553 */
3557 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3559 /* No vtable created yet */
3564 /* This makes so that inline cannot trigger */
3565 /* .cctors: too many apps depend on them */
3566 /* running with a specific order... */
3570 }
3573 /* No vtable created yet */
3580 }
3582 /*
3583 * If we're compiling for shared code
3584 * the cctor will need to be run at aot method load time, for example,
3585 * or at the end of the compilation of the inlining method.
3586 */
3587 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3589 }
3591 /*
3592 * CAS - do not inline methods with declarative security
3593 * Note: this has to be before any possible return TRUE;
3594 */
3598 #ifdef MONO_ARCH_SOFT_FLOAT
3599 /* FIXME: */
3605 #endif
3608 }
3610 static gboolean
3612 {
3623 /* The initialization is already done before the method is called */
3627 }
3631 {
3633 guint32 size;
3643 #if SIZEOF_REGISTER == 8
3644 /* The array reg is 64 bits but the index reg is only 32 */
3647 #else
3653 }
3654 #endif
3658 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3662 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
3666 }
3667 #endif
3678 }
3680 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3682 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
3683 {
3697 guint32 size;
3705 /* range checking */
3736 }
3737 #endif
3740 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3741 {
3752 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3753 /* emit_ldelema_2 depends on OP_LMUL */
3756 }
3757 #endif
3764 }
3767 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
3768 {
3783 #if SIZEOF_REGISTER == 8
3784 /* The array reg is 64 bits but the index reg is only 32 */
3786 #else
3788 #endif
3791 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3792 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
3794 /* Avoid a warning */
3798 #else
3803 #endif
3808 /* Decompose later to allow more optimizations */
3819 /* The corlib functions check for oob already. */
3822 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
3830 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
3831 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
3835 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
3845 #endif
3884 if (strcmp (cmethod->name, "get_CurrentThread") == 0 && (ins = mono_arch_get_thread_intrinsic (cfg))) {
3897 }
3899 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
3918 }
3919 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
3922 /* Avoid infinite recursion */
3935 #endif
3950 #if SIZEOF_REGISTER == 8
3952 /* 64 bit reads are already atomic */
3958 }
3959 #endif
3961 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
3968 #if SIZEOF_REGISTER == 8
3971 #endif
3985 }
3992 #if SIZEOF_REGISTER == 8
3995 #endif
4009 }
4015 #if SIZEOF_REGISTER == 8
4018 #endif
4028 }
4029 }
4032 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4034 guint32 opcode;
4039 #if SIZEOF_REGISTER == 8
4043 #else
4046 #endif
4047 else
4070 }
4072 #if HAVE_WRITE_BARRIERS
4076 }
4077 #endif
4078 }
4081 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4108 /* g_assert_not_reached (); */
4109 }
4110 #if HAVE_WRITE_BARRIERS
4114 }
4115 #endif
4116 }
4127 }
4130 #ifdef PLATFORM_WIN32
4132 #else
4134 #endif
4136 }
4138 /*
4139 * There is general branches code for Min/Max, but it does not work for
4140 * all inputs:
4141 * http://everything2.com/?node_id=1051618
4142 */
4143 }
4145 #ifdef MONO_ARCH_SIMD_INTRINSICS
4150 }
4151 #endif
4154 }
4156 /*
4157 * This entry point could be used later for arbitrary method
4158 * redirection.
4159 */
4163 {
4165 /* managed string allocation support */
4172 #ifndef MONO_CROSS_COMPILE
4174 #endif
4180 }
4181 }
4183 }
4185 static void
4187 {
4192 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4194 /*
4195 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4196 * would be different than the MonoInst's used to represent arguments, and
4197 * the ldelema implementation can't deal with that.
4198 * Solution: When ldelema is used on an inline argument, create a var for
4199 * it, emit ldelema on that var, and emit the saving code below in
4200 * inline_method () if needed.
4201 */
4204 /* This uses cfg->args [i] which is set by the preceeding line */
4207 sp++;
4208 }
4209 }
4211 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4212 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4214 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4215 static gboolean
4217 {
4226 else
4228 }
4236 //return (strncmp_result <= 0);
4240 }
4241 }
4242 #endif
4244 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4245 static gboolean
4247 {
4257 }
4258 }
4266 //return (strncmp_result <= 0);
4270 }
4271 }
4272 #endif
4274 static int
4275 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4277 {
4285 guint prev_real_offset;
4290 guint32 prev_cil_offset_to_bb_len;
4297 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4300 #endif
4301 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4304 #endif
4307 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4312 }
4313 /* allocate space to store the return value */
4316 }
4318 /* allocate local variables */
4325 /* allocate start and end blocks */
4326 /* This is needed so if the inline is aborted, we can clean up */
4350 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
4370 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4374 /* always add some code to avoid block split failures */
4381 /*
4382 * Get rid of the begin and end bblocks if possible to aid local
4383 * optimizations.
4384 */
4387 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4394 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4397 }
4400 }
4403 /*
4404 * If the inlined method contains only a throw, then the ret var is not
4405 * set, so set it to a dummy value.
4406 */
4434 }
4435 }
4439 }
4447 /* This gets rid of the newly added bblocks */
4449 }
4451 }
4453 /*
4454 * Some of these comments may well be out-of-date.
4455 * Design decisions: we do a single pass over the IL code (and we do bblock
4456 * splitting/merging in the few cases when it's required: a back jump to an IL
4457 * address that was not already seen as bblock starting point).
4458 * Code is validated as we go (full verification is still better left to metadata/verify.c).
4459 * Complex operations are decomposed in simpler ones right away. We need to let the
4460 * arch-specific code peek and poke inside this process somehow (except when the
4461 * optimizations can take advantage of the full semantic info of coarse opcodes).
4462 * All the opcodes of the form opcode.s are 'normalized' to opcode.
4463 * MonoInst->opcode initially is the IL opcode or some simplification of that
4464 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4465 * opcode with value bigger than OP_LAST.
4466 * At this point the IR can be handed over to an interpreter, a dumb code generator
4467 * or to the optimizing code generator that will translate it to SSA form.
4468 *
4469 * Profiling directed optimizations.
4470 * We may compile by default with few or no optimizations and instrument the code
4471 * or the user may indicate what methods to optimize the most either in a config file
4472 * or through repeated runs where the compiler applies offline the optimizations to
4473 * each method and then decides if it was worth it.
4474 */
4476 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4477 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4478 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
4479 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4480 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4481 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
4482 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4483 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
4485 /* offset from br.s -> br like opcodes */
4486 #define BIG_BRANCH_OFFSET 13
4488 static gboolean
4490 {
4494 }
4496 static int
4497 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
4498 {
4502 guint cli_addr;
4510 UNVERIFIED;
4514 ip++;
4549 guint32 j;
4559 }
4561 }
4568 }
4573 /* Find the start of the bblock containing the throw */
4577 bb_start --;
4578 }
4581 }
4582 }
4584 unverified:
4587 }
4590 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4591 {
4600 }
4603 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4604 {
4607 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
4611 }
4615 {
4620 else
4625 }
4627 /*
4628 * Returns TRUE if the JIT should abort inlining because "callee"
4629 * is influenced by security attributes.
4630 */
4631 static
4633 {
4634 guint32 result;
4638 }
4645 /* Generate code to throw a SecurityException before the actual call/link */
4653 /* don't hide previous results */
4657 }
4660 }
4664 {
4670 }
4673 }
4675 static void
4677 {
4683 }
4685 /*
4686 * Return the original method is a wrapper is specified. We can only access
4687 * the custom attributes from the original method.
4688 */
4691 {
4695 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
4699 /* in other cases we need to find the original method */
4701 }
4703 static void
4704 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
4706 {
4707 /* there's no restriction to access Transparent or SafeCritical fields, so we only check calls to Critical methods */
4708 if (mono_security_core_clr_class_level (mono_field_get_parent (field)) != MONO_SECURITY_CORE_CLR_CRITICAL)
4711 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4716 /* caller is Critical! only SafeCritical and Critical callers can access the field, so we throw if caller is Transparent */
4719 }
4721 static void
4722 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
4724 {
4725 /* there's no restriction to call Transparent or SafeCritical code, so we only check calls to Critical methods */
4729 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4734 /* caller is Critical! only SafeCritical and Critical callers can call it, so we throw if the caller is Transparent */
4737 }
4739 /*
4740 * Check that the IL instructions at ip are the array initialization
4741 * sequence and return the pointer to the data and the size.
4742 */
4744 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
4745 {
4746 /*
4747 * newarr[System.Int32]
4748 * dup
4749 * ldtoken field valuetype ...
4750 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
4751 */
4756 guint32 rva;
4761 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
4772 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
4779 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
4780 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
4790 #ifdef ARM_FPU_FPA
4792 #endif
4796 #endif
4799 }
4804 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
4809 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
4810 /* for aot code we do the lookup on load */
4814 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
4817 }
4819 }
4821 }
4823 static void
4825 {
4831 else
4834 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
4837 }
4839 static void
4841 {
4845 }
4847 static gboolean
4849 {
4854 else
4857 }
4859 /**
4860 * mono_decompose_array_access_opts:
4861 *
4862 * Decompose array access opcodes.
4863 * This should be in decompose.c, but it emits calls so it has to stay here until
4864 * the old JIT is gone.
4865 */
4866 void
4868 {
4871 /*
4872 * Unlike decompose_long_opts, this pass does not alter the CFG of the method so it
4873 * can be executed anytime. It should be run before decompose_long
4874 */
4876 /**
4877 * Create a dummy bblock and emit code into it so we can use the normal
4878 * code generation macros.
4879 */
4888 gboolean restart;
4921 MonoVTable *vtable = mono_class_vtable (cfg->domain, mono_array_class_get (ins->inst_newa_class, 1));
4923 g_assert (vtable); /*This shall not fail since we check for this condition on OP_NEWARR creation*/
4931 }
4940 }
4945 /* Replace the original instruction with the new code sequence */
4951 }
4952 else
4954 }
4955 }
4958 }
4959 }
4963 gint64 vall;
4967 #ifdef MONO_ARCH_SOFT_FLOAT
4969 /**
4970 * mono_decompose_soft_float:
4971 *
4972 * Soft float support on ARM. We store each double value in a pair of integer vregs,
4973 * similar to long support on 32 bit platforms. 32 bit float values require special
4974 * handling when used as locals, arguments, and in calls.
4975 * One big problem with soft-float is that there are few r4 test cases in our test suite.
4976 */
4977 void
4979 {
4982 /*
4983 * This pass creates long opcodes, so it should be run before decompose_long_opts ().
4984 */
4986 /**
4987 * Create a dummy bblock and emit code into it so we can use the normal
4988 * code generation macros.
4989 */
4996 gboolean restart;
5009 /* Most fp operations are handled automatically by opcode emulation */
5013 DVal d;
5017 }
5019 DVal d;
5020 /* We load the r8 value */
5024 }
5044 }
5055 /* Arg 1 is the double value */
5059 /* Arg 2 is the address to store to */
5061 EMIT_NEW_BIALU_IMM (cfg, iargs [1], OP_PADD_IMM, addr_reg, ins->inst_destbasereg, ins->inst_offset);
5065 }
5072 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, addr_reg, ins->inst_basereg, ins->inst_offset);
5076 }
5086 /* Convert the call into a call returning an int */
5101 }
5105 /* FIXME: Optimize this */
5107 /* Emit an r4->r8 conversion */
5108 EMIT_NEW_VARLOADA_VREG (cfg, iargs [0], call2->inst.dreg, &mono_defaults.int32_class->byval_arg);
5124 }
5125 }
5127 }
5133 /* Convert fcompare+fbcc to icall+icompare+beq */
5138 /* Create dummy MonoInst's for the arguments */
5157 /* The call sequence might include fp ins */
5160 /* Skip fbcc or fccc */
5163 }
5173 /* Convert fccc to icall+icompare+iceq */
5178 /* Create dummy MonoInst's for the arguments */
5189 /* The call sequence might include fp ins */
5192 }
5197 /* Convert to icall+icompare+cond_exc+move */
5199 /* Create dummy MonoInst's for the arguments */
5212 /* Do the assignment if the value is finite */
5217 }
5219 if (spec [MONO_INST_SRC1] == 'f' || spec [MONO_INST_SRC2] == 'f' || spec [MONO_INST_DEST] == 'f') {
5222 }
5224 }
5229 /* Replace the original instruction with the new code sequence */
5235 }
5236 else
5238 }
5239 }
5242 }
5245 }
5247 #endif
5249 static void
5251 {
5256 /* Optimize reg-reg moves away */
5257 /*
5258 * Can't optimize other opcodes, since sp[0] might point to
5259 * the last ins of a decomposed opcode.
5260 */
5264 }
5265 }
5267 /*
5268 * ldloca inhibits many optimizations so try to get rid of it in common
5269 * cases.
5270 */
5273 {
5283 }
5285 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5288 /* From the INITOBJ case */
5300 }
5304 }
5305 load_error:
5307 }
5309 static gboolean
5311 {
5316 }
5318 }
5320 /*
5321 * mono_method_to_ir:
5322 *
5323 * Translate the .net IL into linear IR.
5324 */
5325 int
5326 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5329 {
5348 guint num_args;
5351 MonoDeclSecurityActions actions;
5357 /* serialization and xdomain stuff may need access to private fields and methods */
5367 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5385 /*
5386 * Methods without init_locals set could cause asserts in various passes
5387 * (#497220).
5388 */
5395 }
5397 /* SkipVerification is not allowed if core-clr is enabled */
5401 }
5421 }
5429 }
5431 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5452 /* ENTRY BLOCK */
5458 /* EXIT BLOCK */
5470 }
5471 /* handle exception clauses */
5492 /* todo: is a fault block unsafe to optimize? */
5495 }
5498 /*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);
5499 while (p < end) {
5500 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5501 }*/
5502 /* catch and filter blocks get the exception object on the stack */
5507 /* mostly like handle_stack_args (), but just sets the input args */
5508 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5513 /*
5514 * Add a dummy use for the exvar so its liveness info will be
5515 * correct.
5516 */
5526 /* The filter block shares the exvar with the handler block */
5530 }
5531 }
5537 /*
5538 * In shared generic code with catch
5539 * clauses containing type variables
5540 * the exception handling code has to
5541 * be able to get to the rgctx.
5542 * Therefore we have to make sure that
5543 * the vtable/mrgctx argument (for
5544 * static or generic methods) or the
5545 * "this" argument (for non-static
5546 * methods) are live.
5547 */
5556 }
5557 }
5558 }
5564 }
5566 /* FIRST CODE BLOCK */
5579 }
5580 }
5586 /* at this point having security doesn't mean we have any code to generate */
5588 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5589 * And we do not want to enter the next section (with allocation) if we
5590 * have nothing to generate */
5592 }
5594 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
5601 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
5604 }
5612 }
5615 }
5617 /* not a P/Invoke after all */
5619 }
5620 }
5622 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
5623 /* we use a separate basic block for the initialization code */
5636 }
5638 /* at this point we know, if security is TRUE, that some code needs to be generated */
5645 /* Add code for SecurityAction.Demand */
5648 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5650 }
5652 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
5653 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
5656 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5658 }
5660 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
5663 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
5665 }
5666 }
5668 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
5671 }
5674 /* check if this is native code, e.g. an icall or a p/invoke */
5681 /* if this ia a native call then it can only be JITted from platform code */
5687 }
5688 }
5689 }
5690 }
5691 }
5694 UNVERIFIED;
5698 UNVERIFIED;
5699 }
5706 UNVERIFIED;
5707 }
5710 /* We force the vtable variable here for all shared methods
5711 for the possibility that they might show up in a stack
5712 trace where their exact instantiation is needed. */
5719 /* FIXME: Is there a better way to do this?
5720 We need the variable live for the duration
5721 of the whole method. */
5723 }
5724 }
5726 /* add a check for this != NULL to inlined methods */
5735 }
5737 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
5738 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
5747 else
5759 }
5769 }
5780 }
5789 }
5792 }
5793 }
5795 /*
5796 * Sequence points are points where the debugger can place a breakpoint.
5797 * Currently, we generate these automatically at points where the IL
5798 * stack is empty.
5799 */
5803 }
5811 /* TODO: Use an increment here */
5812 #if defined(TARGET_X86)
5817 #else
5820 #endif
5821 }
5824 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
5830 else
5832 ip++;
5837 ip++;
5848 ip++;
5859 ip++;
5871 UNVERIFIED;
5876 }
5903 UNVERIFIED;
5926 }
5932 }
5939 UNVERIFIED;
6002 #ifdef TARGET_POWERPC
6003 /* FIXME: Clean this up */
6006 #endif
6008 /* FIXME: we should really allocate this only late in the compilation process */
6028 }
6034 }
6039 #ifdef TARGET_POWERPC
6040 /* FIXME: Clean this up */
6043 #endif
6045 /* FIXME: we should really allocate this only late in the compilation process */
6065 }
6071 }
6076 sp--;
6091 }
6094 ip++;
6097 #ifdef TARGET_X86
6099 /* we need to pop the value from the x86 FP stack */
6101 #endif
6106 INLINE_FAILURE;
6110 UNVERIFIED;
6112 /* FIXME: check the signature matches */
6122 CHECK_CFG_EXCEPTION;
6124 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6125 {
6129 /* Handle tail calls similarly to calls */
6143 }
6144 #else
6146 /* Prevent arguments from being optimized away */
6153 #endif
6158 }
6185 else
6196 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6197 /*
6198 * This is needed since get_method_constrained can't find
6199 * the method in klass representing a type var.
6200 * The type var is guaranteed to be a reference type in this
6201 * case.
6202 */
6207 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6208 }
6212 }
6219 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6220 }
6223 METHOD_ACCESS_FAILURE;
6224 }
6230 /* MS.NET seems to silently convert this to a callvirt */
6250 }
6251 }
6259 INLINE_FAILURE;
6260 CHECK_CFG_EXCEPTION;
6261 }
6265 }
6268 UNVERIFIED;
6275 //g_assert (!virtual || fsig->hasthis);
6280 /*
6281 * We have the `constrained.' prefix opcode.
6282 */
6284 /*
6285 * The type parameter is instantiated as a valuetype,
6286 * but that type doesn't override the method we're
6287 * calling, so we need to box `this'.
6288 */
6292 CHECK_CFG_EXCEPTION;
6296 /*
6297 * The type parameter is instantiated as a reference
6298 * type. We have a managed pointer on the stack, so
6299 * we need to dereference it here.
6300 */
6307 }
6310 UNVERIFIED;
6312 /*
6313 * If the callee is a shared method, then its static cctor
6314 * might not get called after the call was patched.
6315 */
6316 if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
6319 }
6327 /*
6328 * Pass vtable iff target method might
6329 * be shared, which means that sharing
6330 * is enabled for its class and its
6331 * context is sharable (and it's not a
6332 * generic method).
6333 */
6337 }
6349 }
6357 /* Generic method interface
6358 calls are resolved via a
6359 helper function and don't
6360 need an imt. */
6363 }
6365 /*
6366 * If a shared method calls another
6367 * shared method then the caller must
6368 * have a generic sharing context
6369 * because the magic trampoline
6370 * requires it. FIXME: We shouldn't
6371 * have to force the vtable/mrgctx
6372 * variable here. Instead there
6373 * should be a flag in the cfg to
6374 * request a generic sharing context.
6375 */
6379 }
6389 }
6390 }
6399 }
6406 }
6407 }
6415 }
6423 }
6425 /* Calling virtual generic methods */
6436 /* Prevent inlining of methods that contain indirect calls */
6437 INLINE_FAILURE;
6439 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && !defined(ENABLE_LLVM)
6449 }
6452 #endif
6453 {
6458 /* FIXME: This should be a managed pointer */
6472 }
6477 }
6485 }
6487 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6488 supported_tail_call = cmethod && MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
6489 #else
6490 supported_tail_call = cmethod && mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6491 #endif
6493 /* Tail prefix */
6494 /* FIXME: runtime generic context pointer for jumps? */
6495 /* FIXME: handle this for generic sharing eventually */
6496 if ((ins_flag & MONO_INST_TAILCALL) && !cfg->generic_sharing_context && !vtable_arg && cmethod && (*ip == CEE_CALL) && supported_tail_call) {
6499 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6500 INLINE_FAILURE;
6502 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6503 /* Handle tail calls similarly to calls */
6505 #else
6511 /*
6512 * We implement tail calls by storing the actual arguments into the
6513 * argument variables, then emitting a CEE_JMP.
6514 */
6516 /* Prevent argument from being register allocated */
6519 }
6520 #endif
6528 /* skip CEE_RET as well */
6532 }
6534 /* Conversion to a JIT intrinsic */
6535 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6539 sp++;
6540 }
6545 }
6547 /* Inlining */
6549 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
6557 /* Prevent inlining of methods that call wrappers */
6558 INLINE_FAILURE;
6561 }
6563 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, allways))) {
6569 /* *sp is already set by inline_method */
6570 sp++;
6575 }
6576 }
6580 /* Tail recursion elimination */
6581 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
6585 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6586 INLINE_FAILURE;
6588 /* keep it simple */
6592 }
6604 /* skip the CEE_RET, too */
6607 else
6612 }
6613 }
6615 /* Generic sharing */
6616 /* FIXME: only do this for generic methods if
6617 they are not shared! */
6623 INLINE_FAILURE;
6628 /*
6629 * We are compiling a call to a
6630 * generic method from shared code,
6631 * which means that we have to look up
6632 * the method in the rgctx and do an
6633 * indirect call.
6634 */
6635 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
6636 }
6638 /* Indirect calls */
6646 else
6647 /* FIXME: what the hell is this??? */
6651 /* Prevent inlining of methods with indirect calls */
6652 INLINE_FAILURE;
6655 #ifdef MONO_ARCH_RGCTX_REG
6665 #else
6666 NOT_IMPLEMENTED;
6667 #endif
6670 /*
6671 * Instead of emitting an indirect call, emit a direct call
6672 * with the contents of the aotconst as the patch info.
6673 */
6674 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
6676 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
6677 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
6681 }
6682 }
6689 }
6691 /* Array methods */
6703 }
6706 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, sp [fsig->param_count]->dreg);
6723 }
6728 }
6738 }
6740 /* Common call */
6741 INLINE_FAILURE;
6746 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, imt_arg);
6748 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, NULL);
6749 }
6757 }
6760 /* return from inlined method */
6761 /*
6762 * If in_count == 0, that means the ret is unreachable due to
6763 * being preceeded by a throw. In that case, inline_method () will
6764 * handle setting the return value
6765 * (test case: test_0_inline_throw ()).
6766 */
6771 //g_assert (returnvar != -1);
6774 }
6794 }
6796 #ifdef MONO_ARCH_SOFT_FLOAT
6806 }
6807 #else
6809 #endif
6810 }
6811 }
6812 }
6814 UNVERIFIED;
6816 ip++;
6825 ip++;
6835 }
6853 ip++;
6855 ip++;
6865 ip++;
6876 }
6895 UNVERIFIED;
6896 ip ++;
6900 sp--;
6910 }
6917 #if SIZEOF_REGISTER == 4
6919 /* Convert it to OP_LCOMPARE */
6927 }
6928 #endif
6944 }
6958 ip++;
6976 gboolean use_op_switch;
6984 UNVERIFIED;
6997 }
7000 /*
7001 * Link the current bb with the targets as well, so handle_stack_args
7002 * will set their in_stack correctly.
7003 */
7011 }
7025 #ifdef TARGET_ARM
7026 /* ARM implements SWITCH statements differently */
7027 /* FIXME: Make it use the generic implementation */
7030 #endif
7047 else
7050 #if SIZEOF_REGISTER == 8
7051 /* The upper word might not be zero, and we add it to a 64 bit address later */
7053 #endif
7063 }
7065 /* FIXME: Use load_memindex */
7069 }
7073 }
7098 }
7124 #if HAVE_WRITE_BARRIERS
7125 if (*ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0))) {
7126 /* insert call to write barrier */
7129 }
7130 #endif
7147 /* Use the immediate opcodes if possible */
7156 }
7157 }
7162 ip++;
7187 /* FIXME: Pass opcode to is_inst_imm */
7189 /* Use the immediate opcodes if possible */
7190 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)) {
7197 #if SIZEOF_REGISTER == 8
7199 #else
7202 #endif
7203 }
7204 else
7208 /* Might be followed by an instruction added by ADD_WIDEN_OP */
7211 }
7212 }
7216 ip++;
7233 /* Special case this earlier so we have long constants in the IR */
7238 #if SIZEOF_REGISTER == 8
7241 else
7243 #else
7247 else
7249 #endif
7251 }
7254 }
7255 ip++;
7269 }
7270 ip++;
7282 }
7283 ip++;
7301 ip++;
7311 ip++;
7333 }
7348 /* Optimize the common ldobj+stloc combination */
7363 }
7373 }
7375 /* Optimize the ldobj+stobj combination */
7376 /* The reference case ends up being a load+store anyway */
7377 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7380 sp --;
7387 }
7396 }
7406 }
7418 }
7429 /*
7430 * Avoid relocations in AOT and save some space by using a
7431 * version of helper_ldstr specialized to mscorlib.
7432 */
7436 /* Avoid creating the string object */
7440 }
7441 }
7442 else
7447 }
7454 }
7455 }
7456 }
7458 sp++;
7464 MonoInst this_ins;
7485 INLINE_FAILURE;
7486 CHECK_CFG_EXCEPTION;
7489 }
7499 }
7509 }
7510 }
7511 }
7516 /*
7517 * Generate smaller code for the common newobj <exception> instruction in
7518 * argument checking code.
7519 */
7546 }
7551 }
7553 /* move the args to allow room for 'this' in the first position */
7557 }
7559 /* check_call_signature () requires sp[0] to be set */
7563 UNVERIFIED;
7575 }
7577 /* Avoid varargs in the common case */
7582 else
7587 /* we simply pass a null pointer */
7589 /* now call the string ctor */
7601 /*
7602 * The code generated by mini_emit_virtual_call () expects
7603 * iargs [0] to be a boxed instance, but luckily the vcall
7604 * will be transformed into a normal call there.
7605 */
7612 else
7623 /*
7624 * TypeInitializationExceptions thrown from the mono_runtime_class_init
7625 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
7626 * As a workaround, we call class cctors before allocating objects.
7627 */
7628 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
7629 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
7631 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
7633 }
7637 }
7643 /* Now call the actual ctor */
7644 /* Avoid virtual calls to ctors if possible */
7654 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
7660 INLINE_FAILURE;
7662 }
7673 INLINE_FAILURE;
7676 }
7677 }
7680 /* Valuetype */
7684 }
7685 else
7691 }
7700 UNVERIFIED;
7708 /* obj */
7711 /* klass */
7738 }
7741 CHECK_CFG_EXCEPTION;
7745 }
7755 UNVERIFIED;
7763 /* obj */
7766 /* klass */
7770 sp++;
7792 }
7795 CHECK_CFG_EXCEPTION;
7799 }
7801 }
7816 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
7820 /* obj */
7822 /* klass */
7849 CHECK_CFG_EXCEPTION;
7853 }
7855 }
7862 }
7864 /* UNBOX */
7870 /* LDOBJ */
7876 }
7897 }
7900 UNVERIFIED;
7902 UNVERIFIED;
7903 /* frequent check in generic code: box (struct), brtrue */
7905 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
7906 /*printf ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
7911 ip++;
7913 ip++;
7916 ip++;
7919 }
7924 /*
7925 * This leads to some inconsistency, since the two bblocks are
7926 * not really connected, but it is needed for handling stack
7927 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
7928 * FIXME: This should only be needed if sp != stack_start, but that
7929 * doesn't work for some reason (test failure in mcs/tests on x86).
7930 */
7936 }
7940 }
7948 else
7954 }
7956 CHECK_CFG_EXCEPTION;
7960 }
7984 }
7988 }
7994 guint foffset;
8002 }
8004 UNVERIFIED;
8006 UNVERIFIED;
8012 }
8015 }
8019 FIELD_ACCESS_FAILURE;
8022 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
8023 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
8024 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8025 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8026 */
8031 UNVERIFIED;
8032 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8054 }
8060 #if HAVE_WRITE_BARRIERS
8061 if (mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
8062 /* insert call to write barrier */
8071 }
8072 #endif
8075 }
8079 }
8081 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8082 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
8088 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
8103 }
8108 /* Have to compute the address of the variable */
8113 else
8118 }
8133 }
8134 }
8138 }
8144 gboolean is_special_static;
8152 }
8153 else
8159 FIELD_ACCESS_FAILURE;
8161 /* if the class is Critical then transparent code cannot access it's fields */
8165 /*
8166 * We can only support shared generic static
8167 * field access on architectures where the
8168 * trampoline code has been extended to handle
8169 * the generic class init.
8170 */
8171 #ifndef MONO_ARCH_VTABLE_REG
8173 #endif
8180 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8181 * to be called here.
8182 */
8186 }
8194 /* Generate IR to compute the field address */
8208 }
8213 /*
8214 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8215 method->klass->name_space, method->klass->name, method->name,
8216 depth, field->offset);
8217 */
8226 // FIXME: This doesn't work since it tries to pass the argument
8227 // in the normal way, instead of using MONO_ARCH_VTABLE_REG
8228 /*
8229 * The vtable pointer is always passed in a register regardless of
8230 * the calling convention, so assign it manually, and make a call
8231 * using a signature without parameters.
8232 */
8233 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable);
8234 #ifdef MONO_ARCH_VTABLE_REG
8237 #else
8238 NOT_IMPLEMENTED;
8239 #endif
8240 }
8242 /*
8243 * The pointer we're computing here is
8244 *
8245 * super_info.static_data + field->offset
8246 */
8255 }
8268 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8269 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8271 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8276 /* This makes so that inline cannot trigger */
8277 /* .cctors: too many apps depend on them */
8278 /* running with a specific order... */
8280 INLINE_FAILURE;
8285 }
8286 }
8287 }
8292 else
8295 /*
8296 * insert call to mono_threads_get_static_data (GPOINTER_TO_UINT (addr))
8297 * This could be later optimized to do just a couple of
8298 * memory dereferences with constant offsets.
8299 */
8303 }
8304 }
8306 /* Generate IR to do the actual load/store operation */
8315 sp--;
8326 }
8333 }
8334 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8340 sp++;
8344 sp++;
8349 sp++;
8353 sp++;
8358 sp++;
8362 sp++;
8364 #ifndef HAVE_MOVING_COLLECTOR
8376 sp++;
8378 #endif
8382 sp++;
8390 }
8391 }
8402 }
8403 }
8407 }
8415 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
8422 /*
8423 * Array opcodes
8424 */
8429 guint32 field_token;
8450 }
8455 /* FIXME: Decompose later to help abcrem */
8457 /* vtable */
8461 /* array len */
8467 /* Decompose now to avoid problems with references to the domainvar */
8476 /* Decompose later since it is needed by abcrem */
8491 /* Needed so mono_emit_load_get_addr () gets called */
8493 }
8494 }
8501 /*
8502 * we inline/optimize the initialization sequence if possible.
8503 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
8504 * for small sizes open code the memcpy
8505 * ensure the rva field is big enough
8506 */
8507 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))) {
8512 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
8514 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
8517 }
8521 }
8524 }
8529 UNVERIFIED;
8539 ip ++;
8547 UNVERIFIED;
8553 /* we need to make sure that this array is exactly the type it needs
8554 * to be for correctness. the wrappers are lax with their usage
8555 * so we need to ignore them here
8556 */
8561 }
8591 }
8592 else
8596 UNVERIFIED;
8603 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8610 }
8614 else
8617 }
8640 }
8641 else
8645 UNVERIFIED;
8647 /* storing a NULL doesn't need any of the complex checks in stelemref */
8654 UNVERIFIED;
8656 UNVERIFIED;
8667 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8674 }
8675 }
8679 else
8683 }
8698 }
8716 // FIXME:
8719 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
8729 // FIXME:
8734 }
8735 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
8740 }
8755 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
8763 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
8764 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8765 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8771 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
8772 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8773 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8775 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
8776 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
8777 }
8778 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
8786 }
8788 gpointer handle;
8802 }
8805 }
8812 /* This case handles ldtoken
8813 of an open type, like for
8814 typeof(Gen<>). */
8817 /* If we get a MONO_TYPE_CLASS
8818 then we need to provide the
8819 open type, not an
8820 instantiation of it. */
8823 else
8829 else
8831 }
8841 else
8855 }
8876 /* Special case for static synchronized wrappers */
8877 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
8879 /* FIXME: n is not a normal token */
8882 }
8885 }
8888 }
8901 MONO_RGCTX_INFO_TYPE);
8910 }
8915 }
8919 }
8920 }
8925 }
8931 ip++;
8944 ip++;
8947 /*
8948 * Control will leave the method so empty the stack, otherwise
8949 * the next basic block will start with a nonempty stack.
8950 */
8952 sp--;
8953 }
8965 }
8967 /* empty the stack */
8969 sp--;
8970 }
8972 /*
8973 * If this leave statement is in a catch block, check for a
8974 * pending exception, and rethrow it if necessary.
8975 */
8979 /*
8980 * Use <= in the final comparison to handle clauses with multiple
8981 * leave statements, like in bug #78024.
8982 * The ordering of the exception clauses guarantees that we find the
8983 * innermost clause.
8984 */
8985 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)) {
8989 /*
8990 MonoInst *load;
8992 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
8993 */
8999 /*
9000 * Currently, we allways rethrow the abort exception, despite the
9001 * fact that this is not correct. See thread6.cs for an example.
9002 * But propagating the abort exception is more important than
9003 * getting the sematics right.
9004 */
9011 }
9012 }
9023 }
9025 }
9036 else
9040 }
9042 /*
9043 * Mono specific opcodes
9044 */
9052 gpointer func;
9071 }
9073 gpointer ptr;
9080 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9090 /* Will be transformed into an AOTCONST later */
9095 }
9096 }
9097 /* FIXME: Generalize this */
9103 }
9108 /* Can't embed random pointers into AOT code */
9111 }
9114 gpointer ptr;
9128 }
9132 }
9139 // FIXME:
9145 }
9162 }
9175 /*
9176 * Similar to LDOBJ, but instead load the unmanaged
9177 * representation of the vtype to the stack.
9178 */
9187 {
9202 }
9205 /*
9206 * Same as RET, but return the native representation of a vtype
9207 * to the caller.
9208 */
9224 }
9228 UNVERIFIED;
9237 }
9248 else
9254 }
9257 #ifdef MONO_ARCH_HAVE_LMF_OPS
9261 #endif
9291 /* It would be easier to call a trampoline, but that would put an
9292 * extra frame on the stack, confusing exception handling. So
9293 * implement it inline using an opcode for now.
9294 */
9297 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9298 /* prevent it from being register allocated */
9300 }
9302 /* Has to use a call inst since it local regalloc expects it */
9310 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
9312 #endif
9318 }
9322 }
9324 }
9330 /* somewhat similar to LDTOKEN */
9333 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
9344 }
9352 /*
9353 * The following transforms:
9354 * CEE_CEQ into OP_CEQ
9355 * CEE_CGT into OP_CGT
9356 * CEE_CGT_UN into OP_CGT_UN
9357 * CEE_CLT into OP_CLT
9358 * CEE_CLT_UN into OP_CLT_UN
9359 */
9368 if ((sp [0]->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
9372 else
9380 /*
9381 * The backends expect the fceq opcodes to do the
9382 * comparison too.
9383 */
9387 }
9392 }
9396 gboolean needs_static_rgctx_invoke;
9415 METHOD_ACCESS_FAILURE;
9419 INLINE_FAILURE;
9420 CHECK_CFG_EXCEPTION;
9423 }
9425 /*
9426 * Optimize the common case of ldftn+delegate creation
9427 */
9428 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE) && !defined(HAVE_WRITE_BARRIERS)
9429 /* FIXME: SGEN support */
9430 /* FIXME: handle shared static generic methods */
9431 /* FIXME: handle this in shared code */
9432 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)) {
9433 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
9444 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9446 sp --;
9448 CHECK_CFG_EXCEPTION;
9450 sp ++;
9452 }
9453 }
9454 #endif
9460 }
9467 }
9484 INLINE_FAILURE;
9485 CHECK_CFG_EXCEPTION;
9488 }
9500 }
9505 }
9532 UNVERIFIED;
9556 }
9562 }
9570 UNVERIFIED;
9579 UNVERIFIED;
9581 /*
9582 * Inlining this into a loop in a parent could lead to
9583 * stack overflows which is different behavior than the
9584 * non-inlined case, thus disable inlining in this case.
9585 */
9608 UNVERIFIED;
9620 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
9624 }
9625 }
9628 UNVERIFIED;
9631 }
9634 /* FIXME: record alignment? we can assume 1 for now */
9645 /* Can't inline tail calls at this time */
9658 else
9668 else
9679 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
9681 } 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)) {
9682 /* emit_memset only works when val == 0 */
9694 }
9695 }
9699 }
9706 /* we ignore the no-nullcheck for now since we
9707 * really do it explicitly only when doing callvirt->call
9708 */
9717 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
9720 }
9721 }
9736 }
9738 guint32 align;
9752 }
9757 }
9764 // FIXME:
9767 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9769 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
9773 }
9784 UNVERIFIED;
9788 UNVERIFIED;
9789 }
9791 }
9794 UNVERIFIED;
9798 UNVERIFIED;
9799 }
9800 }
9802 UNVERIFIED;
9815 }
9819 }
9822 }
9824 #ifdef TARGET_POWERPC
9826 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
9828 #endif
9863 }
9864 }
9865 }
9867 /* Add a sequence point for method entry/exit events */
9873 }
9885 }
9886 }
9894 /* Method is too large */
9900 }
9907 exception_exit:
9913 inline_failure:
9918 load_error:
9924 unverified:
9929 }
9931 static int
9933 {
9947 }
9950 }
9954 int
9956 {
10018 #if defined(TARGET_X86) || defined (TARGET_AMD64)
10023 #endif
10024 #if defined(TARGET_AMD64)
10027 #endif
10038 }
10041 }
10043 static int
10045 {
10071 }
10074 }
10076 static int
10078 {
10097 }
10100 }
10102 int
10104 {
10105 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10106 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10118 #if SIZEOF_REGISTER == 8
10121 #endif
10122 }
10123 #endif
10126 }
10130 {
10131 #if defined(TARGET_X86)
10163 }
10164 #endif
10166 #if defined(TARGET_AMD64)
10167 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10218 }
10219 #endif
10222 }
10226 {
10227 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10235 }
10236 #endif
10239 }
10243 {
10244 #ifdef TARGET_X86
10245 /* FIXME: This has sign extension issues */
10246 /*
10247 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10248 return OP_X86_COMPARE_MEMBASE8_IMM;
10249 */
10251 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10263 }
10264 #endif
10266 #ifdef TARGET_AMD64
10267 /* FIXME: This has sign extension issues */
10268 /*
10269 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10270 return OP_X86_COMPARE_MEMBASE8_IMM;
10271 */
10278 /* FIXME: This only works for 32 bit immediates
10279 case OP_COMPARE_IMM:
10280 case OP_LCOMPARE_IMM:
10281 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10282 return OP_AMD64_COMPARE_MEMBASE_IMM;
10283 */
10297 }
10298 #endif
10301 }
10305 {
10306 #ifdef TARGET_X86
10307 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10324 }
10325 #endif
10327 #ifdef TARGET_AMD64
10368 }
10369 #endif
10372 }
10374 int
10376 {
10378 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
10382 #endif
10383 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
10388 #endif
10392 }
10393 }
10395 #ifndef DISABLE_JIT
10397 /**
10398 * mono_handle_global_vregs:
10399 *
10400 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
10401 * for them.
10402 */
10403 void
10405 {
10412 #ifdef MONO_ARCH_SIMD_INTRINSICS
10415 #endif
10417 /* Find local vregs used in more than one bb */
10429 gint32 prev_bb;
10459 }
10461 #if SIZEOF_REGISTER == 4
10462 /* In the LLVM case, the long opcodes are not decomposed */
10464 /*
10465 * Since some instructions reference the original long vreg,
10466 * and some reference the two component vregs, it is quite hard
10467 * to determine when it needs to be global. So be conservative.
10468 */
10470 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10474 }
10476 /*
10477 * Make the component vregs volatile since the optimizations can
10478 * get confused otherwise.
10479 */
10482 }
10483 #endif
10489 /* 0 is a valid block num */
10492 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
10504 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
10511 }
10512 }
10514 /* Flag as having been used in more than one bb */
10516 }
10517 }
10518 }
10519 }
10521 /* If a variable is used in only one bblock, convert it into a local vreg */
10532 #if SIZEOF_REGISTER == 8
10534 #endif
10535 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
10536 /* Enabling this screws up the fp stack on x86 */
10538 #endif
10539 /* Arguments are implicitly global */
10540 /* Putting R4 vars into registers doesn't work currently */
10541 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) {
10542 /*
10543 * Make that the variable's liveness interval doesn't contain a call, since
10544 * that would cause the lvreg to be spilled, making the whole optimization
10545 * useless.
10546 */
10547 /* This is too slow for JIT compilation */
10548 #if 0
10568 }
10569 }
10574 ins_index ++;
10575 }
10579 }
10580 #endif
10586 }
10588 }
10589 }
10591 /*
10592 * Compress the varinfo and vars tables so the liveness computation is faster and
10593 * takes up less space.
10594 */
10606 #if SIZEOF_REGISTER == 4
10608 /* Modify the two component vars too */
10615 }
10616 #endif
10617 }
10618 pos ++;
10619 }
10620 }
10624 }
10626 /**
10627 * mono_spill_global_vars:
10628 *
10629 * Generate spill code for variables which are not allocated to registers,
10630 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
10631 * code is generated which could be optimized by the local optimization passes.
10632 */
10633 void
10635 {
10651 /* FIXME: Move this function to mini.c */
10655 #ifdef MONO_ARCH_SIMD_INTRINSICS
10657 #endif
10659 #if SIZEOF_REGISTER == 4
10660 /* Create MonoInsts for longs */
10666 #ifdef MONO_ARCH_SOFT_FLOAT
10668 #endif
10686 }
10689 }
10690 }
10691 }
10692 #endif
10694 /* FIXME: widening and truncation */
10696 /*
10697 * As an optimization, when a variable allocated to the stack is first loaded into
10698 * an lvreg, we will remember the lvreg and use it the next time instead of loading
10699 * the variable again.
10700 */
10706 /*
10707 * These arrays contain the first and last instructions accessing a given
10708 * variable.
10709 * Since we emit bblocks in the same order we process them here, and we
10710 * don't split live ranges, these will precisely describe the live range of
10711 * the variable, i.e. the instruction range where a valid value can be found
10712 * in the variables location.
10713 */
10714 /* FIXME: Only do this if debugging info is requested */
10720 /* Add spill loads/stores */
10727 /* Clear vreg_to_lvreg array */
10745 /*
10746 * We handle LDADDR here as well, since it can only be decomposed
10747 * when variable addresses are known.
10748 */
10753 /* Happens on SPARC/S390 where vtypes are passed by reference */
10758 }
10764 NOT_IMPLEMENTED;
10771 }
10775 }
10780 }
10782 /*
10783 * Store opcodes have destbasereg in the dreg, but in reality, it is an
10784 * src register.
10785 * FIXME:
10786 */
10800 else
10810 }
10812 /***************/
10813 /* DREG */
10814 /***************/
10816 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
10830 } 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)) {
10831 /*
10832 * Instead of emitting a load+store, use a _membase opcode.
10833 */
10843 }
10846 guint32 lvreg;
10852 /* Invalidate any previous lvreg for this vreg */
10857 #ifdef MONO_ARCH_SOFT_FLOAT
10861 }
10862 #endif
10867 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
10869 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
10872 }
10876 /* Try to fuse the store into the instruction itself */
10877 /* FIXME: Add more instructions */
10878 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
10884 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
10902 // FIXME: The backends expect the base reg to be in inst_basereg
10909 /* printf ("INS: "); mono_print_ins (ins); */
10910 /* Create a store instruction */
10911 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
10913 /* Insert it after the instruction */
10918 /*
10919 * We can't assign ins->dreg to var->dreg here, since the
10920 * sregs could use it. So set a flag, and do it after
10921 * the sregs.
10922 */
10923 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)))
10925 }
10926 }
10927 }
10932 }
10933 }
10935 /************/
10936 /* SREGS */
10937 /************/
10948 guint32 load_opcode;
10952 //mono_inst_set_src_registers (ins, sregs);
10956 }
10967 /* The variable is already loaded to an lvreg */
10971 //mono_inst_set_src_registers (ins, sregs);
10973 }
10975 /* Try to fuse the load into the instruction */
10979 //mono_inst_set_src_registers (ins, sregs);
10984 //mono_inst_set_src_registers (ins, sregs);
10991 //printf ("%d ", srcindex); mono_print_ins (ins);
10995 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) {
10997 /*
10998 * sreg refers to the value loaded by the load
10999 * emitted below, but we need to use ins->dreg
11000 * since it refers to the store emitted earlier.
11001 */
11003 }
11008 }
11009 }
11012 //mono_inst_set_src_registers (ins, sregs);
11015 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
11017 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
11020 }
11022 #if SIZEOF_REGISTER == 4
11024 #endif
11028 }
11029 }
11034 }
11035 }
11036 }
11045 }
11051 }
11054 /* Clear vreg_to_lvreg array */
11061 }
11065 }
11066 }
11068 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11069 /*
11070 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11071 * by storing the current native offset into MonoMethodVar->live_range_start/end.
11072 */
11082 }
11088 }
11089 }
11090 #endif
11096 }
11098 /**
11099 * FIXME:
11100 * - use 'iadd' instead of 'int_add'
11101 * - handling ovf opcodes: decompose in method_to_ir.
11102 * - unify iregs/fregs
11103 * -> partly done, the missing parts are:
11104 * - a more complete unification would involve unifying the hregs as well, so
11105 * code wouldn't need if (fp) all over the place. but that would mean the hregs
11106 * would no longer map to the machine hregs, so the code generators would need to
11107 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11108 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11109 * fp/non-fp branches speeds it up by about 15%.
11110 * - use sext/zext opcodes instead of shifts
11111 * - add OP_ICALL
11112 * - get rid of TEMPLOADs if possible and use vregs instead
11113 * - clean up usage of OP_P/OP_ opcodes
11114 * - cleanup usage of DUMMY_USE
11115 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11116 * stack
11117 * - set the stack type and allocate a dreg in the EMIT_NEW macros
11118 * - get rid of all the <foo>2 stuff when the new JIT is ready.
11119 * - make sure handle_stack_args () is called before the branch is emitted
11120 * - when the new IR is done, get rid of all unused stuff
11121 * - COMPARE/BEQ as separate instructions or unify them ?
11122 * - keeping them separate allows specialized compare instructions like
11123 * compare_imm, compare_membase
11124 * - most back ends unify fp compare+branch, fp compare+ceq
11125 * - integrate mono_save_args into inline_method
11126 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11127 * - handle long shift opts on 32 bit platforms somehow: they require
11128 * 3 sregs (2 for arg1 and 1 for arg2)
11129 * - make byref a 'normal' type.
11130 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11131 * variable if needed.
11132 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11133 * like inline_method.
11134 * - remove inlining restrictions
11135 * - fix LNEG and enable cfold of INEG
11136 * - generalize x86 optimizations like ldelema as a peephole optimization
11137 * - add store_mem_imm for amd64
11138 * - optimize the loading of the interruption flag in the managed->native wrappers
11139 * - avoid special handling of OP_NOP in passes
11140 * - move code inserting instructions into one function/macro.
11141 * - try a coalescing phase after liveness analysis
11142 * - add float -> vreg conversion + local optimizations on !x86
11143 * - figure out how to handle decomposed branches during optimizations, ie.
11144 * compare+branch, op_jump_table+op_br etc.
11145 * - promote RuntimeXHandles to vregs
11146 * - vtype cleanups:
11147 * - add a NEW_VARLOADA_VREG macro
11148 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11149 * accessing vtype fields.
11150 * - get rid of I8CONST on 64 bit platforms
11151 * - dealing with the increase in code size due to branches created during opcode
11152 * decomposition:
11153 * - use extended basic blocks
11154 * - all parts of the JIT
11155 * - handle_global_vregs () && local regalloc
11156 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11157 * - sources of increase in code size:
11158 * - vtypes
11159 * - long compares
11160 * - isinst and castclass
11161 * - lvregs not allocated to global registers even if used multiple times
11162 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11163 * meaningful.
11164 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11165 * - add all micro optimizations from the old JIT
11166 * - put tree optimizations into the deadce pass
11167 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11168 * specific function.
11169 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11170 * fcompare + branchCC.
11171 * - create a helper function for allocating a stack slot, taking into account
11172 * MONO_CFG_HAS_SPILLUP.
11173 * - merge r68207.
11174 * - merge the ia64 switch changes.
11175 * - optimize mono_regstate2_alloc_int/float.
11176 * - fix the pessimistic handling of variables accessed in exception handler blocks.
11177 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11178 * parts of the tree could be separated by other instructions, killing the tree
11179 * arguments, or stores killing loads etc. Also, should we fold loads into other
11180 * instructions if the result of the load is used multiple times ?
11181 * - make the REM_IMM optimization in mini-x86.c arch-independent.
11182 * - LAST MERGE: 108395.
11183 * - when returning vtypes in registers, generate IR and append it to the end of the
11184 * last bb instead of doing it in the epilog.
11185 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
11186 */
11188 /*
11190 NOTES
11191 -----
11193 - When to decompose opcodes:
11194 - earlier: this makes some optimizations hard to implement, since the low level IR
11195 no longer contains the neccessary information. But it is easier to do.
11196 - later: harder to implement, enables more optimizations.
11197 - Branches inside bblocks:
11198 - created when decomposing complex opcodes.
11199 - branches to another bblock: harmless, but not tracked by the branch
11200 optimizations, so need to branch to a label at the start of the bblock.
11201 - branches to inside the same bblock: very problematic, trips up the local
11202 reg allocator. Can be fixed by spitting the current bblock, but that is a
11203 complex operation, since some local vregs can become global vregs etc.
11204 - Local/global vregs:
11205 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
11206 local register allocator.
11207 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
11208 structure, created by mono_create_var (). Assigned to hregs or the stack by
11209 the global register allocator.
11210 - When to do optimizations like alu->alu_imm:
11211 - earlier -> saves work later on since the IR will be smaller/simpler
11212 - later -> can work on more instructions
11213 - Handling of valuetypes:
11214 - When a vtype is pushed on the stack, a new temporary is created, an
11215 instruction computing its address (LDADDR) is emitted and pushed on
11216 the stack. Need to optimize cases when the vtype is used immediately as in
11217 argument passing, stloc etc.
11218 - Instead of the to_end stuff in the old JIT, simply call the function handling
11219 the values on the stack before emitting the last instruction of the bb.
11220 */