| blob | aebed70ac477982b1093636008e309275271ccdf |
1 /*
2 * method-to-ir.c: Convert CIL to the JIT internal representation
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002 Ximian, Inc.
9 */
11 #include <config.h>
12 #include <signal.h>
14 #ifdef HAVE_UNISTD_H
15 #include <unistd.h>
16 #endif
18 #include <math.h>
19 #include <string.h>
20 #include <ctype.h>
22 #ifdef HAVE_SYS_TIME_H
23 #include <sys/time.h>
24 #endif
26 #ifdef HAVE_ALLOCA_H
27 #include <alloca.h>
28 #endif
30 #include <mono/utils/memcheck.h>
32 #include <mono/metadata/assembly.h>
33 #include <mono/metadata/loader.h>
34 #include <mono/metadata/tabledefs.h>
35 #include <mono/metadata/class.h>
36 #include <mono/metadata/object.h>
37 #include <mono/metadata/exception.h>
38 #include <mono/metadata/opcodes.h>
39 #include <mono/metadata/mono-endian.h>
40 #include <mono/metadata/tokentype.h>
41 #include <mono/metadata/tabledefs.h>
42 #include <mono/metadata/marshal.h>
43 #include <mono/metadata/debug-helpers.h>
44 #include <mono/metadata/mono-debug.h>
45 #include <mono/metadata/gc-internal.h>
46 #include <mono/metadata/security-manager.h>
47 #include <mono/metadata/threads-types.h>
48 #include <mono/metadata/security-core-clr.h>
49 #include <mono/metadata/monitor.h>
50 #include <mono/metadata/profiler-private.h>
51 #include <mono/metadata/profiler.h>
52 #include <mono/utils/mono-compiler.h>
53 #include <mono/metadata/mono-basic-block.h>
64 #define BRANCH_COST 100
65 #define INLINE_LENGTH_LIMIT 20
66 #define INLINE_FAILURE do {\
67 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
68 goto inline_failure;\
69 } while (0)
70 #define CHECK_CFG_EXCEPTION do {\
71 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
72 goto exception_exit;\
73 } while (0)
74 #define METHOD_ACCESS_FAILURE do { \
75 char *method_fname = mono_method_full_name (method, TRUE); \
76 char *cil_method_fname = mono_method_full_name (cil_method, TRUE); \
77 cfg->exception_type = MONO_EXCEPTION_METHOD_ACCESS; \
78 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname); \
79 g_free (method_fname); \
80 g_free (cil_method_fname); \
81 goto exception_exit; \
82 } while (0)
83 #define FIELD_ACCESS_FAILURE do { \
84 char *method_fname = mono_method_full_name (method, TRUE); \
85 char *field_fname = mono_field_full_name (field); \
86 cfg->exception_type = MONO_EXCEPTION_FIELD_ACCESS; \
87 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname); \
88 g_free (method_fname); \
89 g_free (field_fname); \
90 goto exception_exit; \
91 } while (0)
92 #define GENERIC_SHARING_FAILURE(opcode) do { \
93 if (cfg->generic_sharing_context) { \
94 if (cfg->verbose_level > 2) \
95 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((opcode)), __LINE__); \
96 cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED; \
97 goto exception_exit; \
98 } \
99 } while (0)
101 /* Determine whenever 'ins' represents a load of the 'this' argument */
102 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
110 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
111 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
114 /* helper methods signature */
122 /*
123 * Instruction metadata
124 */
125 #ifdef MINI_OP
126 #undef MINI_OP
127 #endif
128 #ifdef MINI_OP3
129 #undef MINI_OP3
130 #endif
132 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
138 #if SIZEOF_REGISTER == 8
139 #define LREG IREG
140 #else
142 #endif
143 /* keep in sync with the enum in mini.h */
144 const char
145 ins_info[] = {
147 };
148 #undef MINI_OP
149 #undef MINI_OP3
151 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
152 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
153 /*
154 * This should contain the index of the last sreg + 1. This is not the same
155 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
156 */
159 };
160 #undef MINI_OP
161 #undef MINI_OP3
163 #define MONO_INIT_VARINFO(vi,id) do { \
164 (vi)->range.first_use.pos.bid = 0xffff; \
165 (vi)->reg = -1; \
166 (vi)->idx = (id); \
167 } while (0)
169 void
171 {
175 }
177 guint32
179 {
181 }
183 guint32
185 {
187 }
189 guint32
191 {
193 }
195 guint32
197 {
199 }
201 guint
203 {
207 handle_enum:
233 #if SIZEOF_REGISTER == 8
235 #else
237 #endif
246 }
261 }
263 }
265 void
267 {
280 }
282 /*
283 * Can't put this at the beginning, since other files reference stuff from this
284 * file.
285 */
286 #ifndef DISABLE_JIT
288 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
290 #define GET_BBLOCK(cfg,tblock,ip) do { \
291 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
292 if (!(tblock)) { \
293 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
294 NEW_BBLOCK (cfg, (tblock)); \
295 (tblock)->cil_code = (ip); \
296 ADD_BBLOCK (cfg, (tblock)); \
297 } \
298 } while (0)
300 #if defined(TARGET_X86) || defined(TARGET_AMD64)
301 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
302 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
303 (dest)->dreg = alloc_preg ((cfg)); \
304 (dest)->sreg1 = (sr1); \
305 (dest)->sreg2 = (sr2); \
306 (dest)->inst_imm = (imm); \
307 (dest)->backend.shift_amount = (shift); \
308 MONO_ADD_INS ((cfg)->cbb, (dest)); \
309 } while (0)
310 #endif
312 #if SIZEOF_REGISTER == 8
313 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
315 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) { \
316 MonoInst *widen; \
317 int dr = alloc_preg (cfg); \
318 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
319 (ins)->sreg2 = widen->dreg; \
320 } \
321 } while (0)
322 #else
323 #define ADD_WIDEN_OP(ins, arg1, arg2)
324 #endif
326 #define ADD_BINOP(op) do { \
327 MONO_INST_NEW (cfg, ins, (op)); \
328 sp -= 2; \
329 ins->sreg1 = sp [0]->dreg; \
330 ins->sreg2 = sp [1]->dreg; \
331 type_from_op (ins, sp [0], sp [1]); \
332 CHECK_TYPE (ins); \
334 ADD_WIDEN_OP (ins, sp [0], sp [1]); \
335 ins->dreg = alloc_dreg ((cfg), (ins)->type); \
336 MONO_ADD_INS ((cfg)->cbb, (ins)); \
337 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
338 } while (0)
340 #define ADD_UNOP(op) do { \
341 MONO_INST_NEW (cfg, ins, (op)); \
342 sp--; \
343 ins->sreg1 = sp [0]->dreg; \
344 type_from_op (ins, sp [0], NULL); \
345 CHECK_TYPE (ins); \
346 (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
347 MONO_ADD_INS ((cfg)->cbb, (ins)); \
348 *sp++ = mono_decompose_opcode (cfg, ins); \
349 } while (0)
351 #define ADD_BINCOND(next_block) do { \
352 MonoInst *cmp; \
353 sp -= 2; \
354 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
355 cmp->sreg1 = sp [0]->dreg; \
356 cmp->sreg2 = sp [1]->dreg; \
357 type_from_op (cmp, sp [0], sp [1]); \
358 CHECK_TYPE (cmp); \
359 type_from_op (ins, sp [0], sp [1]); \
360 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
361 GET_BBLOCK (cfg, tblock, target); \
362 link_bblock (cfg, bblock, tblock); \
363 ins->inst_true_bb = tblock; \
364 if ((next_block)) { \
365 link_bblock (cfg, bblock, (next_block)); \
366 ins->inst_false_bb = (next_block); \
367 start_new_bblock = 1; \
368 } else { \
369 GET_BBLOCK (cfg, tblock, ip); \
370 link_bblock (cfg, bblock, tblock); \
371 ins->inst_false_bb = tblock; \
372 start_new_bblock = 2; \
373 } \
374 if (sp != stack_start) { \
375 handle_stack_args (cfg, stack_start, sp - stack_start); \
376 CHECK_UNVERIFIABLE (cfg); \
377 } \
378 MONO_ADD_INS (bblock, cmp); \
379 MONO_ADD_INS (bblock, ins); \
380 } while (0)
382 /* *
383 * link_bblock: Links two basic blocks
384 *
385 * links two basic blocks in the control flow graph, the 'from'
386 * argument is the starting block and the 'to' argument is the block
387 * the control flow ends to after 'from'.
388 */
389 static void
391 {
395 #if 0
398 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
399 else
404 else
406 }
407 #endif
414 }
415 }
420 }
424 }
431 }
432 }
437 }
441 }
442 }
444 void
446 {
448 }
450 /**
451 * mono_find_block_region:
452 *
453 * We mark each basic block with a region ID. We use that to avoid BB
454 * optimizations when blocks are in different regions.
455 *
456 * Returns:
457 * A region token that encodes where this region is, and information
458 * about the clause owner for this block.
459 *
460 * The region encodes the try/catch/filter clause that owns this block
461 * as well as the type. -1 is a special value that represents a block
462 * that is in none of try/catch/filter.
463 */
464 static int
466 {
473 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
482 else
484 }
488 }
491 }
495 {
507 }
508 }
510 }
512 static void
514 {
522 /* prevent it from being register allocated */
526 }
528 MonoInst *
530 {
532 }
536 {
544 /* prevent it from being register allocated */
550 }
552 /*
553 * Returns the type used in the eval stack when @type is loaded.
554 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
555 */
556 void
558 {
565 }
567 handle_enum:
611 }
621 /* FIXME: all the arguments must be references for now,
622 * later look inside cfg and see if the arg num is
623 * really a reference
624 */
630 }
631 }
633 /*
634 * The following tables are used to quickly validate the IL code in type_from_op ().
635 */
636 static const char
646 };
648 static const char
649 neg_table [] = {
651 };
653 /* reduce the size of this table */
654 static const char
664 };
666 static const char
668 /* Inv i L p F & O vt */
677 };
679 /* reduce the size of this table */
680 static const char
690 };
692 /*
693 * Tables to map from the non-specific opcode to the matching
694 * type-specific opcode.
695 */
696 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
697 static const guint16
700 };
702 /* handles from CEE_NEG to CEE_CONV_U8 */
703 static const guint16
706 };
708 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
709 static const guint16
711 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
712 };
714 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
715 static const guint16
717 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
718 };
720 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
721 static const guint16
723 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
724 };
726 /* handles from CEE_BEQ to CEE_BLT_UN */
727 static const guint16
729 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
730 };
732 /* handles from CEE_CEQ to CEE_CLT_UN */
733 static const guint16
735 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
736 };
738 /*
739 * Sets ins->type (the type on the eval stack) according to the
740 * type of the opcode and the arguments to it.
741 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
742 *
743 * FIXME: this function sets ins->type unconditionally in some cases, but
744 * it should set it to invalid for some types (a conv.x on an object)
745 */
746 static void
750 /* binops */
756 /* FIXME: check unverifiable args for STACK_MP */
778 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
782 else
787 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
813 /* unops */
821 else
842 }
875 #if SIZEOF_REGISTER == 8
877 #else
879 #endif
887 }
955 }
959 }
961 static const char
962 ldind_type [] = {
963 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
964 };
966 #if 0
968 static const char
971 };
973 static int
985 }
986 args++;
987 }
1008 }
1021 }
1022 /*if (!param_table [args [i].type] [sig->params [i]->type])
1023 return 0;*/
1024 }
1026 }
1027 #endif
1029 /*
1030 * When we need a pointer to the current domain many times in a method, we
1031 * call mono_domain_get() once and we store the result in a local variable.
1032 * This function returns the variable that represents the MonoDomain*.
1033 */
1036 {
1040 }
1042 /*
1043 * The got_var contains the address of the Global Offset Table when AOT
1044 * compiling.
1045 */
1046 MonoInst *
1048 {
1049 #ifdef MONO_ARCH_NEED_GOT_VAR
1054 }
1056 #else
1058 #endif
1059 }
1063 {
1068 /* force the var to be stack allocated */
1070 }
1073 }
1088 }
1090 }
1094 {
1129 else
1134 }
1137 }
1141 {
1175 }
1177 }
1179 /*
1180 * We try to share variables when possible
1181 */
1184 {
1188 /* inlining can result in deeper stacks */
1208 }
1210 }
1212 static void
1214 {
1215 /*
1216 * Don't use this if a generic_context is set, since that means AOT can't
1217 * look up the method using just the image+token.
1218 * table == 0 means this is a reference made from a wrapper.
1219 */
1221 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1225 }
1226 }
1228 /*
1229 * This function is called to handle items that are left on the evaluation stack
1230 * at basic block boundaries. What happens is that we save the values to local variables
1231 * and we reload them later when first entering the target basic block (with the
1232 * handle_loaded_temps () function).
1233 * A single joint point will use the same variables (stored in the array bb->out_stack or
1234 * bb->in_stack, if the basic block is before or after the joint point).
1235 *
1236 * This function needs to be called _before_ emitting the last instruction of
1237 * the bb (i.e. before emitting a branch).
1238 * If the stack merge fails at a join point, cfg->unverifiable is set.
1239 */
1240 static void
1242 {
1247 gboolean found;
1255 //printf ("bblock %d has out:", bb->block_num);
1259 /* exception handlers are linked, but they should not be considered for stack args */
1262 //printf (" %d", outb->block_num);
1267 }
1268 }
1269 //printf ("\n");
1273 /*
1274 * try to reuse temps already allocated for this purpouse, if they occupy the same
1275 * stack slot and if they are of the same type.
1276 * This won't cause conflicts since if 'local' is used to
1277 * store one of the values in the in_stack of a bblock, then
1278 * the same variable will be used for the same outgoing stack
1279 * slot as well.
1280 * This doesn't work when inlining methods, since the bblocks
1281 * in the inlined methods do not inherit their in_stack from
1282 * the bblock they are inlined to. See bug #58863 for an
1283 * example.
1284 */
1287 else
1289 }
1290 }
1291 }
1295 /* exception handlers are linked, but they should not be considered for stack args */
1302 }
1304 }
1307 }
1317 }
1319 /*
1320 * It is possible that the out bblocks already have in_stack assigned, and
1321 * the in_stacks differ. In this case, we will store to all the different
1322 * in_stacks.
1323 */
1328 /* Find a bblock which has a different in_stack */
1332 /* exception handlers are linked, but they should not be considered for stack args */
1334 bindex++;
1336 }
1344 }
1348 }
1349 bindex ++;
1350 }
1351 }
1352 }
1354 /* Emit code which loads interface_offsets [klass->interface_id]
1355 * The array is stored in memory before vtable.
1356 */
1357 static void
1358 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1359 {
1367 }
1369 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1370 }
1371 }
1373 static void
1374 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1375 {
1377 #ifdef COMPRESSED_INTERFACE_BITMAP
1385 else
1389 #else
1404 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1410 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1411 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1412 }
1413 #endif
1414 }
1416 /*
1417 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1418 * stored in "klass_reg" implements the interface "klass".
1419 */
1420 static void
1421 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1422 {
1423 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1424 }
1426 /*
1427 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1428 * stored in "vtable_reg" implements the interface "klass".
1429 */
1430 static void
1431 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1432 {
1433 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1434 }
1436 /*
1437 * Emit code which checks whenever the interface id of @klass is smaller than
1438 * than the value given by max_iid_reg.
1439 */
1440 static void
1443 {
1448 }
1449 else
1453 else
1455 }
1457 /* Same as above, but obtains max_iid from a vtable */
1458 static void
1461 {
1464 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1466 }
1468 /* Same as above, but obtains max_iid from a klass */
1469 static void
1472 {
1475 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1477 }
1479 static void
1480 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1481 {
1487 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1490 }
1491 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1501 }
1503 }
1505 static void
1506 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1507 {
1509 }
1511 static void
1512 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1513 {
1521 else
1523 }
1525 /*
1526 * Variant of the above that takes a register to the class, not the vtable.
1527 */
1528 static void
1529 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1530 {
1538 else
1540 }
1543 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1544 {
1553 }
1555 }
1559 {
1561 }
1564 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1565 {
1572 }
1574 }
1576 static void
1577 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1579 static void
1580 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1581 {
1587 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1590 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1591 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1595 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1598 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1605 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1607 }
1610 /* Check that the object is a vector too */
1615 }
1622 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1625 }
1626 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1629 }
1630 }
1632 static void
1633 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1634 {
1636 }
1638 static void
1640 {
1659 #if SIZEOF_REGISTER == 8
1663 #endif
1664 }
1665 }
1671 else
1675 /* This could be optimized further if neccesary */
1680 }
1682 }
1684 #if !NO_UNALIGNED_ACCESS
1690 }
1695 }
1696 }
1697 #endif
1703 }
1708 }
1713 }
1714 }
1718 void
1719 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1720 {
1726 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1730 /* This could be optimized further if neccesary */
1738 }
1739 }
1741 #if !NO_UNALIGNED_ACCESS
1750 }
1751 }
1752 #endif
1761 }
1769 }
1777 }
1778 }
1780 #ifndef DISABLE_JIT
1782 static int
1783 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1784 {
1788 handle_enum:
1832 }
1834 }
1836 /*
1837 * target_type_is_incompatible:
1838 * @cfg: MonoCompile context
1839 *
1840 * Check that the item @arg on the evaluation stack can be stored
1841 * in the target type (can be a local, or field, etc).
1842 * The cfg arg can be used to check if we need verification or just
1843 * validity checks.
1844 *
1845 * Returns: non-0 value if arg can't be stored on a target.
1846 */
1847 static int
1849 {
1854 /* FIXME: check that the pointed to types match */
1860 }
1878 /* STACK_MP is needed when setting pinned locals */
1895 /* FIXME: check type compatibility */
1932 /* FIXME: check type compatibility */
1934 }
1937 /* FIXME: all the arguments must be references for now,
1938 * later look inside cfg and see if the arg num is
1939 * really a reference
1940 */
1947 }
1949 }
1951 /*
1952 * Prepare arguments for passing to a function call.
1953 * Return a non-zero value if the arguments can't be passed to the given
1954 * signature.
1955 * The type checks are not yet complete and some conversions may need
1956 * casts on 32 or 64 bit architectures.
1957 *
1958 * FIXME: implement this using target_type_is_incompatible ()
1959 */
1960 static int
1962 {
1969 args++;
1970 }
1976 }
1979 handle_enum:
1999 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2024 }
2039 }
2040 }
2042 }
2044 static int
2046 {
2060 }
2063 }
2065 static int
2067 {
2081 }
2084 }
2086 #ifdef MONO_ARCH_HAVE_IMT
2087 static void
2089 {
2090 #ifdef MONO_ARCH_IMT_REG
2103 }
2106 #else
2108 #endif
2109 }
2110 #endif
2114 {
2122 }
2127 {
2129 #ifdef MONO_ARCH_SOFT_FLOAT
2131 #endif
2135 else
2136 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2146 //g_assert_not_reached ();
2147 }
2154 /*
2155 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2156 * address of return value to increase optimization opportunities.
2157 * Before vtype decomposition, the dreg of the call ins itself represents the
2158 * fact the call modifies the return value. After decomposition, the call will
2159 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2160 * will be transformed into an LDADDR.
2161 */
2165 /* We reference the call too since call->dreg could change during optimization */
2175 #ifdef MONO_ARCH_SOFT_FLOAT
2177 /*
2178 * If the call has a float argument, we would need to do an r8->r4 conversion using
2179 * an icall, but that cannot be done during the call sequence since it would clobber
2180 * the call registers + the stack. So we do it before emitting the call.
2181 */
2188 else
2199 /* The result will be in an int vreg */
2201 }
2202 }
2203 }
2204 #endif
2206 #ifdef ENABLE_LLVM
2209 else
2211 #else
2213 #endif
2219 }
2223 {
2231 }
2234 mono_emit_rgctx_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2235 {
2236 #ifdef MONO_ARCH_RGCTX_REG
2243 }
2249 }
2251 #else
2254 #endif
2255 }
2258 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2265 {
2266 gboolean might_be_remote;
2273 /* Create the real signature */
2274 /* FIXME: Cache these */
2279 }
2291 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2294 }
2300 else
2310 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2311 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2314 /* Make a call to delegate->invoke_impl */
2321 }
2322 #endif
2329 /*
2330 * the method is not virtual, we just need to ensure this is not null
2331 * and then we can call the method directly.
2332 */
2334 /*
2335 * The check above ensures method is not gshared, this is needed since
2336 * gshared methods can't have wrappers.
2337 */
2339 }
2349 }
2352 /*
2353 * the method is virtual, but we can statically dispatch since either
2354 * it's class or the method itself are sealed.
2355 * But first we need to ensure it's not a null reference.
2356 */
2363 }
2368 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2371 #ifdef MONO_ARCH_HAVE_IMT
2377 }
2378 #endif
2383 }
2388 #ifdef MONO_ARCH_HAVE_IMT
2392 }
2393 #endif
2394 }
2398 }
2403 }
2406 mono_emit_rgctx_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2408 {
2409 #ifdef MONO_ARCH_RGCTX_REG
2411 #endif
2416 #ifdef MONO_ARCH_RGCTX_REG
2419 #else
2420 NOT_IMPLEMENTED;
2421 #endif
2422 }
2427 #ifdef MONO_ARCH_RGCTX_REG
2431 #else
2432 NOT_IMPLEMENTED;
2433 #endif
2434 }
2437 }
2439 MonoInst*
2441 {
2442 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL);
2443 }
2445 MonoInst*
2448 {
2459 }
2461 MonoInst*
2463 {
2469 }
2471 /*
2472 * mono_emit_abs_call:
2473 *
2474 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2475 */
2479 {
2483 /*
2484 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2485 * handle it.
2486 */
2493 }
2497 {
2502 /*
2503 * Native code might return non register sized integers
2504 * without initializing the upper bits.
2505 */
2521 }
2530 }
2531 }
2532 }
2535 }
2539 {
2545 }
2547 }
2549 /*
2550 * Emit code to copy a valuetype of type @klass whose address is stored in
2551 * @src->dreg to memory whose address is stored at @dest->dreg.
2552 */
2553 void
2554 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2555 {
2562 /*
2563 * This check breaks with spilled vars... need to handle it during verification anyway.
2564 * g_assert (klass && klass == src->klass && klass == dest->klass);
2565 */
2569 else
2572 #if HAVE_WRITE_BARRIERS
2573 /* if native is true there should be no references in the struct */
2575 /* Avoid barriers when storing to the stack */
2593 }
2594 }
2596 /* FIXME: this does the memcpy as well (or
2597 should), so we don't need the memcpy
2598 afterwards */
2600 }
2601 }
2602 #endif
2605 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2614 }
2615 }
2619 {
2625 }
2627 }
2629 void
2631 {
2634 guint32 align;
2637 /* FIXME: Optimize this for the case when dest is an LDADDR */
2644 }
2651 }
2652 }
2656 {
2689 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2691 }
2700 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2702 }
2703 }
2706 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2707 {
2717 }
2721 {
2722 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2723 }
2728 {
2729 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);
2733 }
2735 /*
2736 * emit_get_rgctx_method:
2737 *
2738 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2739 * normal constants, else emit a load from the rgctx.
2740 */
2744 {
2757 }
2759 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);
2763 }
2764 }
2769 {
2770 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);
2774 }
2776 /*
2777 * On return the caller must check @klass for load errors.
2778 */
2779 static void
2781 {
2798 }
2800 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
2801 #ifdef MONO_ARCH_VTABLE_REG
2804 #else
2805 NOT_IMPLEMENTED;
2806 #endif
2807 }
2809 /*
2810 * On return the caller must check @array_class for load errors
2811 */
2812 static void
2814 {
2832 }
2853 }
2854 }
2857 }
2859 static void
2861 {
2871 }
2877 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
2879 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
2880 }
2881 }
2883 static void
2885 {
2886 /* Reset the variables holding the cast details */
2891 /* It is enough to reset the from field */
2892 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
2893 }
2894 }
2896 /**
2897 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
2898 * generic code is generated.
2899 */
2902 {
2908 /* FIXME: What if the class is shared? We might not
2909 have to get the address of the method from the
2910 RGCTX. */
2912 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
2919 }
2920 }
2924 {
2933 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2934 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
2936 /* FIXME: generics */
2939 // Check rank == 0
2944 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
2949 /* This assertion is from the unboxcast insn */
2961 }
2963 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_PTR), obj_reg, sizeof (MonoObject));
2969 }
2971 /*
2972 * Returns NULL and set the cfg exception on error.
2973 */
2976 {
2985 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
2986 /* This happens often in argument checking code, eg. throw new FooException... */
2987 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
2993 gboolean pass_lw;
2999 }
3001 #ifndef MONO_CROSS_COMPILE
3003 #endif
3008 }
3015 }
3018 }
3019 }
3022 }
3026 gboolean for_box)
3027 {
3032 /*
3033 FIXME: we cannot get managed_alloc here because we can't get
3034 the class's vtable (because it's not a closed class)
3036 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3037 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3038 */
3048 }
3052 }
3055 }
3057 /*
3058 * Returns NULL and set the cfg exception on error.
3059 */
3062 {
3068 }
3074 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3077 }
3080 handle_box_from_inst (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used, MonoInst *data_inst)
3081 {
3086 /* FIXME: What if the class is shared? We might not
3087 have to get the method address from the RGCTX. */
3089 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3096 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3099 }
3100 }
3102 // FIXME: This doesn't work yet (class libs tests fail?)
3103 #define is_complex_isinst(klass) (TRUE || (klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || klass->marshalbyref || (klass->flags & TYPE_ATTRIBUTE_SEALED) || mono_class_has_variant_generic_params (klass) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
3105 /*
3106 * Returns NULL and set the cfg exception on error.
3107 */
3110 {
3123 /* Complex case, handle by an icall */
3125 /* obj */
3128 /* klass */
3133 /* Simple case, handled by the code below */
3134 }
3135 }
3152 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3153 /* the remoting code is broken, access the class for now */
3154 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3160 }
3165 }
3170 }
3171 }
3178 }
3180 /*
3181 * Returns NULL and set the cfg exception on error.
3182 */
3185 {
3199 /* Complex case, handle by an icall */
3201 /* obj */
3204 /* klass */
3209 /* Simple case, the code below can handle it */
3210 }
3211 }
3217 /* Do the assignment at the beginning, so the other assignment can be if converted */
3229 /* the is_null_bb target simply copies the input register to the output */
3239 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3243 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3247 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3251 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3261 /* Check that the object is a vector too */
3266 }
3268 /* the is_null_bb target simply copies the input register to the output */
3270 }
3274 /* the is_null_bb target simply copies the input register to the output */
3277 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3279 /* the remoting code is broken, access the class for now */
3280 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3286 }
3291 }
3296 /* the is_null_bb target simply copies the input register to the output */
3298 }
3299 }
3300 }
3312 }
3316 {
3317 /* This opcode takes as input an object reference and a class, and returns:
3318 0) if the object is an instance of the class,
3319 1) if the object is not instance of the class,
3320 2) if the object is a proxy whose type cannot be determined */
3347 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3350 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3358 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3360 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3361 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3364 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3374 }
3392 /* FIXME: */
3398 }
3402 {
3403 /* This opcode takes as input an object reference and a class, and returns:
3404 0) if the object is an instance of the class,
3405 1) if the object is a proxy whose type cannot be determined
3406 an InvalidCastException exception is thrown otherwhise*/
3434 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3446 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3449 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3450 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3453 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3469 }
3477 /* FIXME: */
3483 }
3485 /*
3486 * Returns NULL and set the cfg exception on error.
3487 */
3489 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3490 {
3500 /* Inline the contents of mono_delegate_ctor */
3502 /* Set target field */
3503 /* Optimize away setting of NULL target */
3505 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3507 /* Set method field */
3509 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3511 /*
3512 * To avoid looking up the compiled code belonging to the target method
3513 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3514 * store it, and we fill it after the method has been compiled.
3515 */
3520 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3530 }
3534 }
3535 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3536 }
3538 /* Set invoke_impl field */
3544 }
3545 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3547 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3550 }
3554 {
3557 /* Need to register the icall so it gets an icall wrapper */
3562 /* mono_array_new_va () needs a vararg calling convention */
3565 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3567 }
3569 static void
3571 {
3580 /* Add it to the start of the first bblock */
3584 }
3585 else
3590 /*
3591 * Add a dummy use to keep the got_var alive, since real uses might
3592 * only be generated by the back ends.
3593 * Add it to end_bblock, so the variable's lifetime covers the whole
3594 * method.
3595 * It would be better to make the usage of the got var explicit in all
3596 * cases when the backend needs it (i.e. calls, throw etc.), so this
3597 * wouldn't be needed.
3598 */
3601 }
3606 static gboolean
3608 {
3609 MonoMethodHeaderSummary header;
3611 #ifdef MONO_ARCH_SOFT_FLOAT
3614 #endif
3622 #ifdef MONO_ARCH_HAVE_LMF_OPS
3627 #endif
3633 /*runtime, icall and pinvoke are checked by summary call*/
3640 /* also consider num_locals? */
3641 /* Do the size check early to avoid creating vtables */
3645 else
3648 }
3652 /*
3653 * if we can initialize the class of the method right away, we do,
3654 * otherwise we don't allow inlining if the class needs initialization,
3655 * since it would mean inserting a call to mono_runtime_class_init()
3656 * inside the inlined code
3657 */
3661 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3663 /* No vtable created yet */
3668 /* This makes so that inline cannot trigger */
3669 /* .cctors: too many apps depend on them */
3670 /* running with a specific order... */
3674 }
3677 /* No vtable created yet */
3684 }
3686 /*
3687 * If we're compiling for shared code
3688 * the cctor will need to be run at aot method load time, for example,
3689 * or at the end of the compilation of the inlining method.
3690 */
3691 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3693 }
3695 /*
3696 * CAS - do not inline methods with declarative security
3697 * Note: this has to be before any possible return TRUE;
3698 */
3702 #ifdef MONO_ARCH_SOFT_FLOAT
3703 /* FIXME: */
3709 #endif
3712 }
3714 static gboolean
3716 {
3727 /* The initialization is already done before the method is called */
3731 }
3734 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
3735 {
3737 guint32 size;
3747 #if SIZEOF_REGISTER == 8
3748 /* The array reg is 64 bits but the index reg is only 32 */
3750 /* Not needed */
3755 }
3756 #else
3762 }
3763 #endif
3768 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3772 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
3776 }
3777 #endif
3788 }
3790 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3792 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
3793 {
3807 guint32 size;
3815 /* range checking */
3846 }
3847 #endif
3850 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3851 {
3862 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3863 /* emit_ldelema_2 depends on OP_LMUL */
3866 }
3867 #endif
3874 }
3876 static MonoBreakPolicy
3878 {
3880 }
3884 /**
3885 * mono_set_break_policy:
3886 * policy_callback: the new callback function
3887 *
3888 * Allow embedders to decide wherther to actually obey breakpoint instructions
3889 * (both break IL instructions and Debugger.Break () method calls), for example
3890 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
3891 * untrusted or semi-trusted code.
3892 *
3893 * @policy_callback will be called every time a break point instruction needs to
3894 * be inserted with the method argument being the method that calls Debugger.Break()
3895 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
3896 * if it wants the breakpoint to not be effective in the given method.
3897 * #MONO_BREAK_POLICY_ALWAYS is the default.
3898 */
3899 void
3901 {
3904 else
3906 }
3908 static gboolean
3920 }
3921 }
3923 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
3925 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
3926 {
3930 /* the bounds check is already done by the callers */
3938 }
3940 }
3943 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
3944 {
3959 #if SIZEOF_REGISTER == 8
3960 /* The array reg is 64 bits but the index reg is only 32 */
3962 #else
3964 #endif
3967 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3968 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
3970 /* Avoid a warning */
3974 #else
3979 #endif
3984 /* Decompose later to allow more optimizations */
3995 /* The corlib functions check for oob already. */
3998 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4007 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4008 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4012 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
4022 #endif
4071 }
4073 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4078 /*
4079 * Pass the argument normally, the LLVM backend will handle the
4080 * calling convention problems.
4081 */
4082 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4088 }
4095 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4101 }
4104 }
4105 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4108 /* Avoid infinite recursion */
4121 #endif
4127 #if SIZEOF_REGISTER == 8
4129 /* 64 bit reads are already atomic */
4135 }
4136 #endif
4138 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4145 #if SIZEOF_REGISTER == 8
4148 #endif
4162 }
4169 #if SIZEOF_REGISTER == 8
4172 #endif
4186 }
4192 #if SIZEOF_REGISTER == 8
4195 #endif
4205 }
4206 }
4209 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4211 guint32 opcode;
4216 #if SIZEOF_REGISTER == 8
4220 #else
4223 #endif
4224 else
4247 }
4249 #if HAVE_WRITE_BARRIERS
4255 }
4256 #endif
4257 }
4260 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4287 /* g_assert_not_reached (); */
4288 }
4289 #if HAVE_WRITE_BARRIERS
4295 }
4296 #endif
4297 }
4307 else
4311 }
4314 #ifdef TARGET_WIN32
4316 #else
4318 #endif
4320 }
4322 /*
4323 * There is general branches code for Min/Max, but it does not work for
4324 * all inputs:
4325 * http://everything2.com/?node_id=1051618
4326 */
4327 }
4329 #ifdef MONO_ARCH_SIMD_INTRINSICS
4334 }
4335 #endif
4338 }
4340 /*
4341 * This entry point could be used later for arbitrary method
4342 * redirection.
4343 */
4347 {
4349 /* managed string allocation support */
4350 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS)) {
4356 #ifndef MONO_CROSS_COMPILE
4358 #endif
4364 }
4365 }
4367 }
4369 static void
4371 {
4376 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4378 /*
4379 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4380 * would be different than the MonoInst's used to represent arguments, and
4381 * the ldelema implementation can't deal with that.
4382 * Solution: When ldelema is used on an inline argument, create a var for
4383 * it, emit ldelema on that var, and emit the saving code below in
4384 * inline_method () if needed.
4385 */
4388 /* This uses cfg->args [i] which is set by the preceeding line */
4391 sp++;
4392 }
4393 }
4395 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4396 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4398 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4399 static gboolean
4401 {
4410 else
4412 }
4420 //return (strncmp_result <= 0);
4424 }
4425 }
4426 #endif
4428 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4429 static gboolean
4431 {
4441 }
4442 }
4450 //return (strncmp_result <= 0);
4454 }
4455 }
4456 #endif
4458 static int
4459 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4461 {
4469 guint prev_real_offset;
4474 guint32 prev_cil_offset_to_bb_len;
4481 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4484 #endif
4485 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4488 #endif
4491 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4496 }
4498 /* allocate local variables */
4506 }
4508 /* allocate space to store the return value */
4511 }
4519 /* allocate start and end blocks */
4520 /* This is needed so if the inline is aborted, we can clean up */
4544 costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
4564 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4568 /* always add some code to avoid block split failures */
4575 /*
4576 * Get rid of the begin and end bblocks if possible to aid local
4577 * optimizations.
4578 */
4581 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4588 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4591 }
4594 }
4597 /*
4598 * If the inlined method contains only a throw, then the ret var is not
4599 * set, so set it to a dummy value.
4600 */
4628 }
4629 }
4633 }
4642 /* This gets rid of the newly added bblocks */
4644 }
4647 }
4649 /*
4650 * Some of these comments may well be out-of-date.
4651 * Design decisions: we do a single pass over the IL code (and we do bblock
4652 * splitting/merging in the few cases when it's required: a back jump to an IL
4653 * address that was not already seen as bblock starting point).
4654 * Code is validated as we go (full verification is still better left to metadata/verify.c).
4655 * Complex operations are decomposed in simpler ones right away. We need to let the
4656 * arch-specific code peek and poke inside this process somehow (except when the
4657 * optimizations can take advantage of the full semantic info of coarse opcodes).
4658 * All the opcodes of the form opcode.s are 'normalized' to opcode.
4659 * MonoInst->opcode initially is the IL opcode or some simplification of that
4660 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4661 * opcode with value bigger than OP_LAST.
4662 * At this point the IR can be handed over to an interpreter, a dumb code generator
4663 * or to the optimizing code generator that will translate it to SSA form.
4664 *
4665 * Profiling directed optimizations.
4666 * We may compile by default with few or no optimizations and instrument the code
4667 * or the user may indicate what methods to optimize the most either in a config file
4668 * or through repeated runs where the compiler applies offline the optimizations to
4669 * each method and then decides if it was worth it.
4670 */
4672 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4673 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4674 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
4675 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4676 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4677 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
4678 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4679 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
4681 /* offset from br.s -> br like opcodes */
4682 #define BIG_BRANCH_OFFSET 13
4684 static gboolean
4686 {
4690 }
4692 static int
4693 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
4694 {
4698 guint cli_addr;
4706 UNVERIFIED;
4710 ip++;
4745 guint32 j;
4755 }
4757 }
4764 }
4769 /* Find the start of the bblock containing the throw */
4773 bb_start --;
4774 }
4777 }
4778 }
4780 unverified:
4783 }
4786 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4787 {
4796 }
4799 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4800 {
4803 if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
4807 }
4811 {
4816 else
4821 }
4823 /*
4824 * Returns TRUE if the JIT should abort inlining because "callee"
4825 * is influenced by security attributes.
4826 */
4827 static
4829 {
4830 guint32 result;
4834 }
4841 /* Generate code to throw a SecurityException before the actual call/link */
4849 /* don't hide previous results */
4853 }
4856 }
4860 {
4866 }
4869 }
4871 static void
4873 {
4879 }
4881 /*
4882 * Return the original method is a wrapper is specified. We can only access
4883 * the custom attributes from the original method.
4884 */
4887 {
4891 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
4895 /* in other cases we need to find the original method */
4897 }
4899 static void
4900 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
4902 {
4903 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4904 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
4907 }
4909 static void
4910 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
4912 {
4913 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4914 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
4917 }
4919 /*
4920 * Check that the IL instructions at ip are the array initialization
4921 * sequence and return the pointer to the data and the size.
4922 */
4924 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
4925 {
4926 /*
4927 * newarr[System.Int32]
4928 * dup
4929 * ldtoken field valuetype ...
4930 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
4931 */
4936 guint32 rva;
4941 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
4952 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
4959 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
4960 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
4970 #ifdef ARM_FPU_FPA
4972 #endif
4976 #endif
4979 }
4984 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
4989 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
4990 /* for aot code we do the lookup on load */
4994 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
4997 }
4999 }
5001 }
5003 static void
5005 {
5012 else
5015 cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5019 }
5021 static void
5023 {
5027 }
5029 static gboolean
5031 {
5036 else
5039 }
5041 static void
5043 {
5048 /* Optimize reg-reg moves away */
5049 /*
5050 * Can't optimize other opcodes, since sp[0] might point to
5051 * the last ins of a decomposed opcode.
5052 */
5056 }
5057 }
5059 /*
5060 * ldloca inhibits many optimizations so try to get rid of it in common
5061 * cases.
5062 */
5065 {
5075 }
5077 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5080 /* From the INITOBJ case */
5092 }
5096 }
5097 load_error:
5099 }
5101 static gboolean
5103 {
5108 }
5110 }
5112 /*
5113 * mono_method_to_ir:
5114 *
5115 * Translate the .net IL into linear IR.
5116 */
5117 int
5118 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5121 {
5122 MonoError error;
5142 guint num_args;
5145 MonoDeclSecurityActions actions;
5151 /* serialization and xdomain stuff may need access to private fields and methods */
5161 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5179 /*
5180 * Methods without init_locals set could cause asserts in various passes
5181 * (#497220).
5182 */
5189 }
5191 /* SkipVerification is not allowed if core-clr is enabled */
5195 }
5215 }
5223 }
5225 cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5246 /* ENTRY BLOCK */
5252 /* EXIT BLOCK */
5264 }
5265 /* handle exception clauses */
5286 /* todo: is a fault block unsafe to optimize? */
5289 }
5292 /*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);
5293 while (p < end) {
5294 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5295 }*/
5296 /* catch and filter blocks get the exception object on the stack */
5301 /* mostly like handle_stack_args (), but just sets the input args */
5302 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5307 /*
5308 * Add a dummy use for the exvar so its liveness info will be
5309 * correct.
5310 */
5320 /* The filter block shares the exvar with the handler block */
5324 }
5325 }
5331 /*
5332 * In shared generic code with catch
5333 * clauses containing type variables
5334 * the exception handling code has to
5335 * be able to get to the rgctx.
5336 * Therefore we have to make sure that
5337 * the vtable/mrgctx argument (for
5338 * static or generic methods) or the
5339 * "this" argument (for non-static
5340 * methods) are live.
5341 */
5350 }
5351 }
5352 }
5358 }
5360 /* FIRST CODE BLOCK */
5373 }
5374 }
5380 /* at this point having security doesn't mean we have any code to generate */
5382 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5383 * And we do not want to enter the next section (with allocation) if we
5384 * have nothing to generate */
5386 }
5388 /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
5395 /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
5398 }
5406 }
5409 }
5411 /* not a P/Invoke after all */
5413 }
5414 }
5416 if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
5417 /* we use a separate basic block for the initialization code */
5430 }
5432 /* at this point we know, if security is TRUE, that some code needs to be generated */
5439 /* Add code for SecurityAction.Demand */
5442 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5444 }
5446 /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
5447 /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
5450 /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5452 }
5454 /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
5457 /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
5459 }
5460 }
5462 /* we must Demand SecurityPermission.Unmanaged before p/invoking */
5465 }
5468 /* check if this is native code, e.g. an icall or a p/invoke */
5475 /* if this ia a native call then it can only be JITted from platform code */
5481 }
5482 }
5483 }
5484 }
5485 }
5488 UNVERIFIED;
5492 UNVERIFIED;
5493 }
5500 UNVERIFIED;
5501 }
5504 /* We force the vtable variable here for all shared methods
5505 for the possibility that they might show up in a stack
5506 trace where their exact instantiation is needed. */
5513 /* FIXME: Is there a better way to do this?
5514 We need the variable live for the duration
5515 of the whole method. */
5517 }
5518 }
5520 /* add a check for this != NULL to inlined methods */
5527 }
5534 UNVERIFIED;
5535 }
5537 }
5539 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
5540 stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
5548 else
5560 }
5570 }
5581 }
5590 }
5593 }
5594 }
5612 }
5616 }
5617 }
5618 /*
5619 * Sequence points are points where the debugger can place a breakpoint.
5620 * Currently, we generate these automatically at points where the IL
5621 * stack is empty.
5622 */
5626 }
5634 /* TODO: Use an increment here */
5635 #if defined(TARGET_X86)
5640 #else
5643 #endif
5644 }
5647 printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
5653 else
5655 ip++;
5661 else
5663 ip++;
5674 ip++;
5685 ip++;
5697 UNVERIFIED;
5702 }
5729 UNVERIFIED;
5752 }
5758 }
5765 UNVERIFIED;
5828 #ifdef TARGET_POWERPC
5829 /* FIXME: Clean this up */
5832 #endif
5834 /* FIXME: we should really allocate this only late in the compilation process */
5854 }
5860 }
5865 #ifdef TARGET_POWERPC
5866 /* FIXME: Clean this up */
5869 #endif
5871 /* FIXME: we should really allocate this only late in the compilation process */
5891 }
5897 }
5902 sp--;
5917 }
5920 ip++;
5923 #ifdef TARGET_X86
5925 /* we need to pop the value from the x86 FP stack */
5927 #endif
5932 INLINE_FAILURE;
5936 UNVERIFIED;
5938 /* FIXME: check the signature matches */
5948 CHECK_CFG_EXCEPTION;
5950 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
5951 {
5955 /* Handle tail calls similarly to calls */
5969 }
5970 #else
5972 /* Prevent arguments from being optimized away */
5979 #endif
5984 }
6011 else
6019 /*
6020 * This is a call through a function pointer using a pinvoke
6021 * signature. Have to create a wrapper and call that instead.
6022 * FIXME: This is very slow, need to create a wrapper at JIT time
6023 * instead based on the signature.
6024 */
6029 }
6037 if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6038 /*
6039 * This is needed since get_method_constrained can't find
6040 * the method in klass representing a type var.
6041 * The type var is guaranteed to be a reference type in this
6042 * case.
6043 */
6048 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6049 }
6053 }
6060 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6061 }
6064 METHOD_ACCESS_FAILURE;
6065 }
6071 /* MS.NET seems to silently convert this to a callvirt */
6074 {
6075 /*
6076 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
6077 * converts to a callvirt.
6078 *
6079 * tests/bug-515884.il is an example of this behavior
6080 */
6081 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
6083 if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
6085 }
6109 }
6110 }
6118 INLINE_FAILURE;
6119 CHECK_CFG_EXCEPTION;
6120 }
6124 }
6127 UNVERIFIED;
6134 //g_assert (!virtual || fsig->hasthis);
6139 /*
6140 * We have the `constrained.' prefix opcode.
6141 */
6143 /*
6144 * The type parameter is instantiated as a valuetype,
6145 * but that type doesn't override the method we're
6146 * calling, so we need to box `this'.
6147 */
6151 CHECK_CFG_EXCEPTION;
6155 /*
6156 * The type parameter is instantiated as a reference
6157 * type. We have a managed pointer on the stack, so
6158 * we need to dereference it here.
6159 */
6166 }
6169 UNVERIFIED;
6171 /*
6172 * If the callee is a shared method, then its static cctor
6173 * might not get called after the call was patched.
6174 */
6175 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)) {
6178 }
6186 /*
6187 * Pass vtable iff target method might
6188 * be shared, which means that sharing
6189 * is enabled for its class and its
6190 * context is sharable (and it's not a
6191 * generic method).
6192 */
6196 }
6208 }
6216 /* Generic method interface
6217 calls are resolved via a
6218 helper function and don't
6219 need an imt. */
6222 }
6224 /*
6225 * If a shared method calls another
6226 * shared method then the caller must
6227 * have a generic sharing context
6228 * because the magic trampoline
6229 * requires it. FIXME: We shouldn't
6230 * have to force the vtable/mrgctx
6231 * variable here. Instead there
6232 * should be a flag in the cfg to
6233 * request a generic sharing context.
6234 */
6238 }
6248 }
6249 }
6255 /*
6256 * emit_get_rgctx_method () calls mono_class_vtable () so check
6257 * for type load errors before.
6258 */
6261 }
6270 }
6271 }
6279 }
6284 /* Calling virtual generic methods */
6295 /* Prevent inlining of methods that contain indirect calls */
6296 INLINE_FAILURE;
6298 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK
6299 /* The llvm vcall trampolines doesn't support generic virtual calls yet */
6308 #endif
6309 {
6314 /* FIXME: This should be a managed pointer */
6327 }
6332 CHECK_CFG_EXCEPTION;
6337 }
6339 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6340 supported_tail_call = cmethod && MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
6341 #else
6342 supported_tail_call = cmethod && mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6343 #endif
6345 /* Tail prefix */
6346 /* FIXME: runtime generic context pointer for jumps? */
6347 /* FIXME: handle this for generic sharing eventually */
6348 if ((ins_flag & MONO_INST_TAILCALL) && !cfg->generic_sharing_context && !vtable_arg && cmethod && (*ip == CEE_CALL) && supported_tail_call) {
6351 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6352 INLINE_FAILURE;
6354 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6355 /* Handle tail calls similarly to calls */
6357 #else
6363 /*
6364 * We implement tail calls by storing the actual arguments into the
6365 * argument variables, then emitting a CEE_JMP.
6366 */
6368 /* Prevent argument from being register allocated */
6371 }
6372 #endif
6381 CHECK_CFG_EXCEPTION;
6383 /* skip CEE_RET as well */
6387 }
6389 /* Conversion to a JIT intrinsic */
6390 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6394 sp++;
6395 }
6397 CHECK_CFG_EXCEPTION;
6402 }
6404 /* Inlining */
6406 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
6414 /* Prevent inlining of methods that call wrappers */
6415 INLINE_FAILURE;
6418 }
6420 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, allways))) {
6426 /* *sp is already set by inline_method */
6427 sp++;
6432 }
6433 }
6437 /* Tail recursion elimination */
6438 if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
6442 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6443 INLINE_FAILURE;
6445 /* keep it simple */
6449 }
6461 /* skip the CEE_RET, too */
6464 else
6469 }
6470 }
6472 /* Generic sharing */
6473 /* FIXME: only do this for generic methods if
6474 they are not shared! */
6480 INLINE_FAILURE;
6485 /*
6486 * We are compiling a call to a
6487 * generic method from shared code,
6488 * which means that we have to look up
6489 * the method in the rgctx and do an
6490 * indirect call.
6491 */
6492 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
6493 }
6495 /* Indirect calls */
6503 else
6504 /* FIXME: what the hell is this??? */
6508 /* Prevent inlining of methods with indirect calls */
6509 INLINE_FAILURE;
6512 #ifdef MONO_ARCH_RGCTX_REG
6522 #else
6523 NOT_IMPLEMENTED;
6524 #endif
6527 /*
6528 * Instead of emitting an indirect call, emit a direct call
6529 * with the contents of the aotconst as the patch info.
6530 */
6531 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
6533 } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
6534 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
6538 }
6539 }
6543 CHECK_CFG_EXCEPTION;
6548 }
6550 /* Array methods */
6562 }
6565 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, sp [fsig->param_count]->dreg);
6582 }
6584 CHECK_CFG_EXCEPTION;
6589 }
6596 CHECK_CFG_EXCEPTION;
6601 }
6603 /* Common call */
6604 INLINE_FAILURE;
6609 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, imt_arg);
6611 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, NULL);
6612 }
6617 CHECK_CFG_EXCEPTION;
6622 }
6625 /* return from inlined method */
6626 /*
6627 * If in_count == 0, that means the ret is unreachable due to
6628 * being preceeded by a throw. In that case, inline_method () will
6629 * handle setting the return value
6630 * (test case: test_0_inline_throw ()).
6631 */
6636 //g_assert (returnvar != -1);
6639 }
6645 /*
6646 * Place a seq point here too even through the IL stack is not
6647 * empty, so a step over on
6648 * call <FOO>
6649 * ret
6650 * will work correctly.
6651 */
6654 }
6671 }
6673 #ifdef MONO_ARCH_SOFT_FLOAT
6683 }
6684 #else
6686 #endif
6687 }
6688 }
6689 }
6691 UNVERIFIED;
6693 ip++;
6702 ip++;
6712 }
6730 ip++;
6732 ip++;
6742 ip++;
6753 }
6772 UNVERIFIED;
6773 ip ++;
6777 sp--;
6787 }
6794 #if SIZEOF_REGISTER == 4
6796 /* Convert it to OP_LCOMPARE */
6804 }
6805 #endif
6821 }
6835 ip++;
6853 gboolean use_op_switch;
6861 UNVERIFIED;
6874 }
6877 /*
6878 * Link the current bb with the targets as well, so handle_stack_args
6879 * will set their in_stack correctly.
6880 */
6888 }
6902 #ifdef TARGET_ARM
6903 /* ARM implements SWITCH statements differently */
6904 /* FIXME: Make it use the generic implementation */
6907 #endif
6924 else
6927 #if SIZEOF_REGISTER == 8
6928 /* The upper word might not be zero, and we add it to a 64 bit address later */
6930 #endif
6940 }
6942 /* FIXME: Use load_memindex */
6946 }
6950 }
6975 }
7001 #if HAVE_WRITE_BARRIERS
7002 if (*ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0))) {
7004 /* insert call to write barrier */
7008 }
7009 #endif
7026 /* Use the immediate opcodes if possible */
7035 }
7036 }
7041 ip++;
7066 /* FIXME: Pass opcode to is_inst_imm */
7068 /* Use the immediate opcodes if possible */
7069 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)) {
7076 #if SIZEOF_REGISTER == 8
7078 #else
7081 #endif
7082 }
7083 else
7087 /* Might be followed by an instruction added by ADD_WIDEN_OP */
7090 }
7091 }
7095 ip++;
7112 /* Special case this earlier so we have long constants in the IR */
7117 #if SIZEOF_REGISTER == 8
7120 else
7122 #else
7126 else
7128 #endif
7130 }
7133 }
7134 ip++;
7148 }
7149 ip++;
7161 }
7162 ip++;
7180 CHECK_CFG_EXCEPTION;
7181 ip++;
7191 ip++;
7213 }
7228 /* Optimize the common ldobj+stloc combination */
7243 }
7253 }
7255 /* Optimize the ldobj+stobj combination */
7256 /* The reference case ends up being a load+store anyway */
7257 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7260 sp --;
7267 }
7276 }
7286 }
7298 }
7309 /*
7310 * Avoid relocations in AOT and save some space by using a
7311 * version of helper_ldstr specialized to mscorlib.
7312 */
7316 /* Avoid creating the string object */
7320 }
7321 }
7322 else
7327 }
7334 }
7335 }
7336 }
7338 sp++;
7344 MonoInst this_ins;
7367 INLINE_FAILURE;
7368 CHECK_CFG_EXCEPTION;
7371 }
7390 }
7391 }
7392 }
7397 /*
7398 * Generate smaller code for the common newobj <exception> instruction in
7399 * argument checking code.
7400 */
7427 }
7432 }
7434 /* move the args to allow room for 'this' in the first position */
7438 }
7440 /* check_call_signature () requires sp[0] to be set */
7444 UNVERIFIED;
7454 /* Avoid varargs in the common case */
7461 else
7466 /* we simply pass a null pointer */
7468 /* now call the string ctor */
7480 /*
7481 * The code generated by mini_emit_virtual_call () expects
7482 * iargs [0] to be a boxed instance, but luckily the vcall
7483 * will be transformed into a normal call there.
7484 */
7491 else
7502 /*
7503 * TypeInitializationExceptions thrown from the mono_runtime_class_init
7504 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
7505 * As a workaround, we call class cctors before allocating objects.
7506 */
7507 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
7508 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
7510 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
7512 }
7516 }
7522 /* Now call the actual ctor */
7523 /* Avoid virtual calls to ctors if possible */
7533 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
7539 INLINE_FAILURE;
7541 }
7552 INLINE_FAILURE;
7555 }
7556 }
7559 /* Valuetype */
7563 }
7564 else
7570 }
7579 UNVERIFIED;
7587 /* obj */
7590 /* klass */
7597 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7616 }
7619 CHECK_CFG_EXCEPTION;
7623 }
7633 UNVERIFIED;
7641 /* obj */
7644 /* klass */
7648 sp++;
7651 } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7670 }
7673 CHECK_CFG_EXCEPTION;
7677 }
7679 }
7694 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
7698 /* obj */
7700 /* klass */
7727 CHECK_CFG_EXCEPTION;
7731 }
7733 }
7740 }
7742 /* UNBOX */
7748 /* LDOBJ */
7754 }
7775 }
7778 UNVERIFIED;
7780 UNVERIFIED;
7781 /* frequent check in generic code: box (struct), brtrue */
7783 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
7784 /*printf ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
7789 ip++;
7791 ip++;
7794 ip++;
7797 }
7802 /*
7803 * This leads to some inconsistency, since the two bblocks are
7804 * not really connected, but it is needed for handling stack
7805 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
7806 * FIXME: This should only be needed if sp != stack_start, but that
7807 * doesn't work for some reason (test failure in mcs/tests on x86).
7808 */
7814 }
7818 }
7826 else
7832 }
7834 CHECK_CFG_EXCEPTION;
7838 }
7862 }
7866 }
7872 guint foffset;
7880 }
7882 UNVERIFIED;
7884 UNVERIFIED;
7890 }
7893 }
7897 FIELD_ACCESS_FAILURE;
7900 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
7901 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
7902 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
7903 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
7904 */
7909 UNVERIFIED;
7910 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
7932 }
7940 #if HAVE_WRITE_BARRIERS
7941 if (mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
7942 /* insert call to write barrier */
7953 }
7954 #endif
7957 }
7961 }
7963 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
7964 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
7970 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
7985 }
7990 /* Have to compute the address of the variable */
7995 else
8000 }
8018 }
8019 }
8023 }
8029 gboolean is_special_static;
8037 }
8038 else
8044 FIELD_ACCESS_FAILURE;
8046 /* if the class is Critical then transparent code cannot access it's fields */
8050 /*
8051 * We can only support shared generic static
8052 * field access on architectures where the
8053 * trampoline code has been extended to handle
8054 * the generic class init.
8055 */
8056 #ifndef MONO_ARCH_VTABLE_REG
8058 #endif
8065 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8066 * to be called here.
8067 */
8071 }
8079 /* Generate IR to compute the field address */
8080 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
8081 /*
8082 * Fast access to TLS data
8083 * Inline version of get_thread_static_data () in
8084 * threads.c.
8085 */
8086 guint32 offset;
8090 // offset &= 0x7fffffff;
8091 // idx = (offset >> 24) - 1;
8092 // return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
8097 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
8102 /* For TLS variables, this will return the TLS offset */
8125 }
8138 }
8143 /*
8144 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8145 method->klass->name_space, method->klass->name, method->name,
8146 depth, field->offset);
8147 */
8156 // FIXME: This doesn't work since it tries to pass the argument
8157 // in the normal way, instead of using MONO_ARCH_VTABLE_REG
8158 /*
8159 * The vtable pointer is always passed in a register regardless of
8160 * the calling convention, so assign it manually, and make a call
8161 * using a signature without parameters.
8162 */
8163 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable);
8164 #ifdef MONO_ARCH_VTABLE_REG
8167 #else
8168 NOT_IMPLEMENTED;
8169 #endif
8170 }
8172 /*
8173 * The pointer we're computing here is
8174 *
8175 * super_info.static_data + field->offset
8176 */
8185 }
8198 if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8199 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8201 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8206 /* This makes so that inline cannot trigger */
8207 /* .cctors: too many apps depend on them */
8208 /* running with a specific order... */
8210 INLINE_FAILURE;
8215 }
8216 }
8217 }
8222 else
8228 }
8229 }
8231 /* Generate IR to do the actual load/store operation */
8240 sp--;
8251 }
8258 }
8259 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8265 sp++;
8269 sp++;
8274 sp++;
8278 sp++;
8283 sp++;
8287 sp++;
8289 #ifndef HAVE_MOVING_COLLECTOR
8301 sp++;
8303 #endif
8307 sp++;
8315 }
8316 }
8327 }
8328 }
8332 }
8340 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
8347 /*
8348 * Array opcodes
8349 */
8354 guint32 field_token;
8375 }
8380 /* FIXME: we cannot get a managed
8381 allocator because we can't get the
8382 open generic class's vtable. We
8383 have the same problem in
8384 handle_alloc_from_inst(). This
8385 needs to be solved so that we can
8386 have managed allocs of shared
8387 generic classes. */
8388 /*
8389 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
8390 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
8391 */
8394 /* FIXME: Decompose later to help abcrem */
8396 /* vtable */
8399 /* array len */
8404 else
8408 /* Decompose now to avoid problems with references to the domainvar */
8417 /* Decompose later since it is needed by abcrem */
8432 /* Needed so mono_emit_load_get_addr () gets called */
8434 }
8435 }
8442 /*
8443 * we inline/optimize the initialization sequence if possible.
8444 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
8445 * for small sizes open code the memcpy
8446 * ensure the rva field is big enough
8447 */
8448 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))) {
8453 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
8455 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
8458 }
8462 }
8465 }
8470 UNVERIFIED;
8480 ip ++;
8488 UNVERIFIED;
8494 /* we need to make sure that this array is exactly the type it needs
8495 * to be for correctness. the wrappers are lax with their usage
8496 * so we need to ignore them here
8497 */
8502 }
8532 }
8533 else
8537 UNVERIFIED;
8544 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8551 }
8555 else
8558 }
8581 }
8582 else
8586 UNVERIFIED;
8588 /* storing a NULL doesn't need any of the complex checks in stelemref */
8595 UNVERIFIED;
8597 UNVERIFIED;
8608 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8615 }
8616 }
8620 else
8624 }
8639 }
8657 // FIXME:
8660 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
8670 // FIXME:
8675 }
8676 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
8681 }
8696 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
8704 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
8705 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8706 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8712 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
8713 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8714 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8716 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
8717 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
8718 }
8719 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
8727 }
8729 gpointer handle;
8743 }
8746 }
8753 /* This case handles ldtoken
8754 of an open type, like for
8755 typeof(Gen<>). */
8758 /* If we get a MONO_TYPE_CLASS
8759 then we need to provide the
8760 open type, not an
8761 instantiation of it. */
8764 else
8770 else
8772 }
8782 else
8796 }
8817 /* Special case for static synchronized wrappers */
8818 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
8820 /* FIXME: n is not a normal token */
8823 }
8826 }
8829 }
8842 MONO_RGCTX_INFO_TYPE);
8851 }
8856 }
8860 }
8861 }
8866 }
8872 ip++;
8885 ip++;
8888 /*
8889 * Control will leave the method so empty the stack, otherwise
8890 * the next basic block will start with a nonempty stack.
8891 */
8893 sp--;
8894 }
8906 }
8908 /* empty the stack */
8910 sp--;
8911 }
8913 /*
8914 * If this leave statement is in a catch block, check for a
8915 * pending exception, and rethrow it if necessary.
8916 * We avoid doing this in runtime invoke wrappers, since those are called
8917 * by native code which excepts the wrapper to catch all exceptions.
8918 */
8922 /*
8923 * Use <= in the final comparison to handle clauses with multiple
8924 * leave statements, like in bug #78024.
8925 * The ordering of the exception clauses guarantees that we find the
8926 * innermost clause.
8927 */
8928 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((*ip == CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
8932 /*
8933 MonoInst *load;
8935 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
8936 */
8942 /*
8943 * Currently, we allways rethrow the abort exception, despite the
8944 * fact that this is not correct. See thread6.cs for an example.
8945 * But propagating the abort exception is more important than
8946 * getting the sematics right.
8947 */
8954 }
8955 }
8974 /*
8975 * Link the finally bblock with the target, since it will
8976 * conceptually branch there.
8977 * FIXME: Have to link the bblock containing the endfinally.
8978 */
8981 }
8982 }
8984 }
8995 else
8999 }
9001 /*
9002 * Mono specific opcodes
9003 */
9011 gpointer func;
9030 }
9032 gpointer ptr;
9039 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9049 /* Will be transformed into an AOTCONST later */
9054 }
9055 }
9056 /* FIXME: Generalize this */
9062 }
9067 /* Can't embed random pointers into AOT code */
9070 }
9073 gpointer ptr;
9087 }
9091 }
9098 // FIXME:
9104 }
9121 }
9134 /*
9135 * Similar to LDOBJ, but instead load the unmanaged
9136 * representation of the vtype to the stack.
9137 */
9146 {
9161 }
9164 /*
9165 * Same as RET, but return the native representation of a vtype
9166 * to the caller.
9167 */
9183 }
9187 UNVERIFIED;
9196 }
9207 else
9213 }
9216 #ifdef MONO_ARCH_HAVE_LMF_OPS
9220 #endif
9250 /* It would be easier to call a trampoline, but that would put an
9251 * extra frame on the stack, confusing exception handling. So
9252 * implement it inline using an opcode for now.
9253 */
9256 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9257 /* prevent it from being register allocated */
9259 }
9261 /* Has to use a call inst since it local regalloc expects it */
9269 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
9271 #endif
9277 }
9281 }
9283 }
9289 /* somewhat similar to LDTOKEN */
9292 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
9303 }
9311 /*
9312 * The following transforms:
9313 * CEE_CEQ into OP_CEQ
9314 * CEE_CGT into OP_CGT
9315 * CEE_CGT_UN into OP_CGT_UN
9316 * CEE_CLT into OP_CLT
9317 * CEE_CLT_UN into OP_CLT_UN
9318 */
9327 if ((sp [0]->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
9331 else
9339 /*
9340 * The backends expect the fceq opcodes to do the
9341 * comparison too.
9342 */
9346 }
9351 }
9355 gboolean needs_static_rgctx_invoke;
9374 METHOD_ACCESS_FAILURE;
9378 INLINE_FAILURE;
9379 CHECK_CFG_EXCEPTION;
9382 }
9384 /*
9385 * Optimize the common case of ldftn+delegate creation
9386 */
9387 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
9388 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
9400 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE) && !defined(HAVE_WRITE_BARRIERS)
9401 /* FIXME: SGEN support */
9407 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9409 sp --;
9411 CHECK_CFG_EXCEPTION;
9413 sp ++;
9415 }
9416 #endif
9417 }
9418 }
9427 }
9444 INLINE_FAILURE;
9445 CHECK_CFG_EXCEPTION;
9448 }
9458 else
9464 }
9491 UNVERIFIED;
9515 }
9521 }
9529 UNVERIFIED;
9538 UNVERIFIED;
9540 /*
9541 * Inlining this into a loop in a parent could lead to
9542 * stack overflows which is different behavior than the
9543 * non-inlined case, thus disable inlining in this case.
9544 */
9567 UNVERIFIED;
9579 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
9583 }
9584 }
9587 UNVERIFIED;
9590 }
9593 /* FIXME: record alignment? we can assume 1 for now */
9604 /* Can't inline tail calls at this time */
9617 else
9627 else
9638 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
9640 } 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)) {
9641 /* emit_memset only works when val == 0 */
9653 }
9654 }
9658 }
9665 /* we ignore the no-nullcheck for now since we
9666 * really do it explicitly only when doing callvirt->call
9667 */
9676 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
9679 }
9680 }
9695 }
9697 guint32 align;
9703 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic) {
9711 }
9716 }
9723 // FIXME:
9726 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9728 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
9732 }
9743 UNVERIFIED;
9747 UNVERIFIED;
9748 }
9750 }
9753 UNVERIFIED;
9757 UNVERIFIED;
9758 }
9759 }
9761 UNVERIFIED;
9774 }
9778 }
9781 }
9783 #ifdef TARGET_POWERPC
9785 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
9787 #endif
9822 }
9823 }
9824 }
9827 /* Emit initialization for ref vars */
9828 // FIXME: Avoid duplication initialization for IL locals.
9834 }
9835 }
9837 /* Add a sequence point for method entry/exit events */
9843 }
9855 }
9856 }
9864 /* Method is too large */
9872 }
9881 exception_exit:
9885 inline_failure:
9888 load_error:
9892 unverified:
9896 cleanup:
9902 }
9904 static int
9906 {
9920 }
9923 }
9927 int
9929 {
9991 #if defined(TARGET_X86) || defined (TARGET_AMD64)
9996 #endif
9997 #if defined(TARGET_AMD64)
10000 #endif
10011 }
10014 }
10016 static int
10018 {
10044 }
10047 }
10049 static int
10051 {
10070 }
10073 }
10075 int
10077 {
10078 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10079 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10091 #if SIZEOF_REGISTER == 8
10094 #endif
10095 }
10096 #endif
10099 }
10103 {
10104 #if defined(TARGET_X86)
10136 }
10137 #endif
10139 #if defined(TARGET_AMD64)
10140 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10191 }
10192 #endif
10195 }
10199 {
10200 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10208 }
10209 #endif
10212 }
10216 {
10217 #ifdef TARGET_X86
10218 /* FIXME: This has sign extension issues */
10219 /*
10220 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10221 return OP_X86_COMPARE_MEMBASE8_IMM;
10222 */
10224 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10236 }
10237 #endif
10239 #ifdef TARGET_AMD64
10240 /* FIXME: This has sign extension issues */
10241 /*
10242 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10243 return OP_X86_COMPARE_MEMBASE8_IMM;
10244 */
10251 /* FIXME: This only works for 32 bit immediates
10252 case OP_COMPARE_IMM:
10253 case OP_LCOMPARE_IMM:
10254 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10255 return OP_AMD64_COMPARE_MEMBASE_IMM;
10256 */
10270 }
10271 #endif
10274 }
10278 {
10279 #ifdef TARGET_X86
10280 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10297 }
10298 #endif
10300 #ifdef TARGET_AMD64
10341 }
10342 #endif
10345 }
10347 int
10349 {
10351 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
10355 #endif
10356 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
10361 #endif
10365 }
10366 }
10368 #ifndef DISABLE_JIT
10370 /**
10371 * mono_handle_global_vregs:
10372 *
10373 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
10374 * for them.
10375 */
10376 void
10378 {
10385 #ifdef MONO_ARCH_SIMD_INTRINSICS
10388 #endif
10390 /* Find local vregs used in more than one bb */
10402 gint32 prev_bb;
10432 }
10434 #if SIZEOF_REGISTER == 4
10435 /* In the LLVM case, the long opcodes are not decomposed */
10437 /*
10438 * Since some instructions reference the original long vreg,
10439 * and some reference the two component vregs, it is quite hard
10440 * to determine when it needs to be global. So be conservative.
10441 */
10443 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10447 }
10449 /*
10450 * Make the component vregs volatile since the optimizations can
10451 * get confused otherwise.
10452 */
10455 }
10456 #endif
10462 /* 0 is a valid block num */
10465 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
10477 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10480 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
10487 }
10488 }
10490 /* Flag as having been used in more than one bb */
10492 }
10493 }
10494 }
10495 }
10497 /* If a variable is used in only one bblock, convert it into a local vreg */
10508 #if SIZEOF_REGISTER == 8
10510 #endif
10511 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
10512 /* Enabling this screws up the fp stack on x86 */
10514 #endif
10515 /* Arguments are implicitly global */
10516 /* Putting R4 vars into registers doesn't work currently */
10517 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) {
10518 /*
10519 * Make that the variable's liveness interval doesn't contain a call, since
10520 * that would cause the lvreg to be spilled, making the whole optimization
10521 * useless.
10522 */
10523 /* This is too slow for JIT compilation */
10524 #if 0
10544 }
10545 }
10550 ins_index ++;
10551 }
10555 }
10556 #endif
10562 }
10564 }
10565 }
10567 /*
10568 * Compress the varinfo and vars tables so the liveness computation is faster and
10569 * takes up less space.
10570 */
10582 #if SIZEOF_REGISTER == 4
10584 /* Modify the two component vars too */
10591 }
10592 #endif
10593 }
10594 pos ++;
10595 }
10596 }
10600 }
10602 /**
10603 * mono_spill_global_vars:
10604 *
10605 * Generate spill code for variables which are not allocated to registers,
10606 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
10607 * code is generated which could be optimized by the local optimization passes.
10608 */
10609 void
10611 {
10627 /* FIXME: Move this function to mini.c */
10631 #ifdef MONO_ARCH_SIMD_INTRINSICS
10633 #endif
10635 #if SIZEOF_REGISTER == 4
10636 /* Create MonoInsts for longs */
10663 }
10666 }
10667 }
10668 }
10669 #endif
10671 /* FIXME: widening and truncation */
10673 /*
10674 * As an optimization, when a variable allocated to the stack is first loaded into
10675 * an lvreg, we will remember the lvreg and use it the next time instead of loading
10676 * the variable again.
10677 */
10683 /*
10684 * These arrays contain the first and last instructions accessing a given
10685 * variable.
10686 * Since we emit bblocks in the same order we process them here, and we
10687 * don't split live ranges, these will precisely describe the live range of
10688 * the variable, i.e. the instruction range where a valid value can be found
10689 * in the variables location.
10690 * The live range is computed using the liveness info computed by the liveness pass.
10691 * We can't use vmv->range, since that is an abstract live range, and we need
10692 * one which is instruction precise.
10693 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
10694 */
10695 /* FIXME: Only do this if debugging info is requested */
10701 /* Add spill loads/stores */
10708 /* Clear vreg_to_lvreg array */
10726 /*
10727 * We handle LDADDR here as well, since it can only be decomposed
10728 * when variable addresses are known.
10729 */
10734 /* Happens on SPARC/S390 where vtypes are passed by reference */
10739 }
10745 NOT_IMPLEMENTED;
10752 }
10756 }
10761 }
10763 /*
10764 * Store opcodes have destbasereg in the dreg, but in reality, it is an
10765 * src register.
10766 * FIXME:
10767 */
10781 else
10791 }
10793 /***************/
10794 /* DREG */
10795 /***************/
10797 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
10811 } 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)) {
10812 /*
10813 * Instead of emitting a load+store, use a _membase opcode.
10814 */
10824 }
10827 guint32 lvreg;
10833 /* Invalidate any previous lvreg for this vreg */
10841 }
10846 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
10848 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
10851 }
10855 /* Try to fuse the store into the instruction itself */
10856 /* FIXME: Add more instructions */
10857 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
10863 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
10881 // FIXME: The backends expect the base reg to be in inst_basereg
10888 /* printf ("INS: "); mono_print_ins (ins); */
10889 /* Create a store instruction */
10890 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
10892 /* Insert it after the instruction */
10897 /*
10898 * We can't assign ins->dreg to var->dreg here, since the
10899 * sregs could use it. So set a flag, and do it after
10900 * the sregs.
10901 */
10902 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)))
10904 }
10905 }
10906 }
10911 }
10912 }
10914 /************/
10915 /* SREGS */
10916 /************/
10927 guint32 load_opcode;
10931 //mono_inst_set_src_registers (ins, sregs);
10935 }
10946 /* The variable is already loaded to an lvreg */
10950 //mono_inst_set_src_registers (ins, sregs);
10952 }
10954 /* Try to fuse the load into the instruction */
10958 //mono_inst_set_src_registers (ins, sregs);
10963 //mono_inst_set_src_registers (ins, sregs);
10970 //printf ("%d ", srcindex); mono_print_ins (ins);
10974 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) {
10976 /*
10977 * sreg refers to the value loaded by the load
10978 * emitted below, but we need to use ins->dreg
10979 * since it refers to the store emitted earlier.
10980 */
10982 }
10987 }
10988 }
10991 //mono_inst_set_src_registers (ins, sregs);
10994 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
10996 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
10999 }
11001 #if SIZEOF_REGISTER == 4
11003 #endif
11007 }
11008 }
11013 }
11014 }
11015 }
11024 }
11030 }
11033 /* Clear vreg_to_lvreg array */
11040 }
11044 }
11046 /* Extend the live range based on the liveness info */
11052 /* The liveness info is incomplete */
11056 /* Live from at least the first ins of this bb */
11059 }
11062 /* Live at least until the last ins of this bb */
11065 }
11066 }
11067 }
11068 }
11070 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11071 /*
11072 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11073 * by storing the current native offset into MonoMethodVar->live_range_start/end.
11074 */
11085 }
11092 else
11094 }
11095 }
11096 }
11097 #endif
11103 }
11105 /**
11106 * FIXME:
11107 * - use 'iadd' instead of 'int_add'
11108 * - handling ovf opcodes: decompose in method_to_ir.
11109 * - unify iregs/fregs
11110 * -> partly done, the missing parts are:
11111 * - a more complete unification would involve unifying the hregs as well, so
11112 * code wouldn't need if (fp) all over the place. but that would mean the hregs
11113 * would no longer map to the machine hregs, so the code generators would need to
11114 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11115 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11116 * fp/non-fp branches speeds it up by about 15%.
11117 * - use sext/zext opcodes instead of shifts
11118 * - add OP_ICALL
11119 * - get rid of TEMPLOADs if possible and use vregs instead
11120 * - clean up usage of OP_P/OP_ opcodes
11121 * - cleanup usage of DUMMY_USE
11122 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11123 * stack
11124 * - set the stack type and allocate a dreg in the EMIT_NEW macros
11125 * - get rid of all the <foo>2 stuff when the new JIT is ready.
11126 * - make sure handle_stack_args () is called before the branch is emitted
11127 * - when the new IR is done, get rid of all unused stuff
11128 * - COMPARE/BEQ as separate instructions or unify them ?
11129 * - keeping them separate allows specialized compare instructions like
11130 * compare_imm, compare_membase
11131 * - most back ends unify fp compare+branch, fp compare+ceq
11132 * - integrate mono_save_args into inline_method
11133 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11134 * - handle long shift opts on 32 bit platforms somehow: they require
11135 * 3 sregs (2 for arg1 and 1 for arg2)
11136 * - make byref a 'normal' type.
11137 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11138 * variable if needed.
11139 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11140 * like inline_method.
11141 * - remove inlining restrictions
11142 * - fix LNEG and enable cfold of INEG
11143 * - generalize x86 optimizations like ldelema as a peephole optimization
11144 * - add store_mem_imm for amd64
11145 * - optimize the loading of the interruption flag in the managed->native wrappers
11146 * - avoid special handling of OP_NOP in passes
11147 * - move code inserting instructions into one function/macro.
11148 * - try a coalescing phase after liveness analysis
11149 * - add float -> vreg conversion + local optimizations on !x86
11150 * - figure out how to handle decomposed branches during optimizations, ie.
11151 * compare+branch, op_jump_table+op_br etc.
11152 * - promote RuntimeXHandles to vregs
11153 * - vtype cleanups:
11154 * - add a NEW_VARLOADA_VREG macro
11155 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11156 * accessing vtype fields.
11157 * - get rid of I8CONST on 64 bit platforms
11158 * - dealing with the increase in code size due to branches created during opcode
11159 * decomposition:
11160 * - use extended basic blocks
11161 * - all parts of the JIT
11162 * - handle_global_vregs () && local regalloc
11163 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11164 * - sources of increase in code size:
11165 * - vtypes
11166 * - long compares
11167 * - isinst and castclass
11168 * - lvregs not allocated to global registers even if used multiple times
11169 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11170 * meaningful.
11171 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11172 * - add all micro optimizations from the old JIT
11173 * - put tree optimizations into the deadce pass
11174 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11175 * specific function.
11176 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11177 * fcompare + branchCC.
11178 * - create a helper function for allocating a stack slot, taking into account
11179 * MONO_CFG_HAS_SPILLUP.
11180 * - merge r68207.
11181 * - merge the ia64 switch changes.
11182 * - optimize mono_regstate2_alloc_int/float.
11183 * - fix the pessimistic handling of variables accessed in exception handler blocks.
11184 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11185 * parts of the tree could be separated by other instructions, killing the tree
11186 * arguments, or stores killing loads etc. Also, should we fold loads into other
11187 * instructions if the result of the load is used multiple times ?
11188 * - make the REM_IMM optimization in mini-x86.c arch-independent.
11189 * - LAST MERGE: 108395.
11190 * - when returning vtypes in registers, generate IR and append it to the end of the
11191 * last bb instead of doing it in the epilog.
11192 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
11193 */
11195 /*
11197 NOTES
11198 -----
11200 - When to decompose opcodes:
11201 - earlier: this makes some optimizations hard to implement, since the low level IR
11202 no longer contains the neccessary information. But it is easier to do.
11203 - later: harder to implement, enables more optimizations.
11204 - Branches inside bblocks:
11205 - created when decomposing complex opcodes.
11206 - branches to another bblock: harmless, but not tracked by the branch
11207 optimizations, so need to branch to a label at the start of the bblock.
11208 - branches to inside the same bblock: very problematic, trips up the local
11209 reg allocator. Can be fixed by spitting the current bblock, but that is a
11210 complex operation, since some local vregs can become global vregs etc.
11211 - Local/global vregs:
11212 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
11213 local register allocator.
11214 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
11215 structure, created by mono_create_var (). Assigned to hregs or the stack by
11216 the global register allocator.
11217 - When to do optimizations like alu->alu_imm:
11218 - earlier -> saves work later on since the IR will be smaller/simpler
11219 - later -> can work on more instructions
11220 - Handling of valuetypes:
11221 - When a vtype is pushed on the stack, a new temporary is created, an
11222 instruction computing its address (LDADDR) is emitted and pushed on
11223 the stack. Need to optimize cases when the vtype is used immediately as in
11224 argument passing, stloc etc.
11225 - Instead of the to_end stuff in the old JIT, simply call the function handling
11226 the values on the stack before emitting the last instruction of the bb.
11227 */