| blob | 28261c5338f544b708c125f36eebe65ff23b8d17 |
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 * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
10 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
11 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
12 */
14 #include <config.h>
16 #ifndef DISABLE_JIT
18 #include <signal.h>
20 #ifdef HAVE_UNISTD_H
21 #include <unistd.h>
22 #endif
24 #include <math.h>
25 #include <string.h>
26 #include <ctype.h>
28 #ifdef HAVE_SYS_TIME_H
29 #include <sys/time.h>
30 #endif
32 #ifdef HAVE_ALLOCA_H
33 #include <alloca.h>
34 #endif
36 #include <mono/utils/memcheck.h>
38 #include <mono/metadata/abi-details.h>
39 #include <mono/metadata/assembly.h>
40 #include <mono/metadata/attrdefs.h>
41 #include <mono/metadata/loader.h>
42 #include <mono/metadata/tabledefs.h>
43 #include <mono/metadata/class.h>
44 #include <mono/metadata/object.h>
45 #include <mono/metadata/exception.h>
46 #include <mono/metadata/opcodes.h>
47 #include <mono/metadata/mono-endian.h>
48 #include <mono/metadata/tokentype.h>
49 #include <mono/metadata/tabledefs.h>
50 #include <mono/metadata/marshal.h>
51 #include <mono/metadata/debug-helpers.h>
52 #include <mono/metadata/mono-debug.h>
53 #include <mono/metadata/mono-debug-debugger.h>
54 #include <mono/metadata/gc-internals.h>
55 #include <mono/metadata/security-manager.h>
56 #include <mono/metadata/threads-types.h>
57 #include <mono/metadata/security-core-clr.h>
58 #include <mono/metadata/profiler-private.h>
59 #include <mono/metadata/profiler.h>
60 #include <mono/metadata/monitor.h>
61 #include <mono/metadata/debug-mono-symfile.h>
62 #include <mono/utils/mono-compiler.h>
63 #include <mono/utils/mono-memory-model.h>
64 #include <mono/utils/mono-error-internals.h>
65 #include <mono/metadata/mono-basic-block.h>
66 #include <mono/metadata/reflection-internals.h>
67 #include <mono/utils/mono-threads-coop.h>
80 #define BRANCH_COST 10
81 #define INLINE_LENGTH_LIMIT 20
83 /* These have 'cfg' as an implicit argument */
84 #define INLINE_FAILURE(msg) do { \
85 if ((cfg->method != cfg->current_method) && (cfg->current_method->wrapper_type == MONO_WRAPPER_NONE)) { \
86 inline_failure (cfg, msg); \
87 goto exception_exit; \
88 } \
89 } while (0)
90 #define CHECK_CFG_EXCEPTION do {\
91 if (cfg->exception_type != MONO_EXCEPTION_NONE) \
92 goto exception_exit; \
93 } while (0)
94 #define FIELD_ACCESS_FAILURE(method, field) do { \
95 field_access_failure ((cfg), (method), (field)); \
96 goto exception_exit; \
97 } while (0)
98 #define GENERIC_SHARING_FAILURE(opcode) do { \
99 if (cfg->gshared) { \
100 gshared_failure (cfg, opcode, __FILE__, __LINE__); \
101 goto exception_exit; \
102 } \
103 } while (0)
104 #define GSHAREDVT_FAILURE(opcode) do { \
105 if (cfg->gsharedvt) { \
106 gsharedvt_failure (cfg, opcode, __FILE__, __LINE__); \
107 goto exception_exit; \
108 } \
109 } while (0)
110 #define OUT_OF_MEMORY_FAILURE do { \
111 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
113 goto exception_exit; \
114 } while (0)
115 #define DISABLE_AOT(cfg) do { \
116 if ((cfg)->verbose_level >= 2) \
118 (cfg)->disable_aot = TRUE; \
119 } while (0)
120 #define LOAD_ERROR do { \
121 break_on_unverified (); \
122 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD); \
123 goto exception_exit; \
124 } while (0)
126 #define TYPE_LOAD_ERROR(klass) do { \
127 cfg->exception_ptr = klass; \
128 LOAD_ERROR; \
129 } while (0)
131 #define CHECK_CFG_ERROR do {\
132 if (!mono_error_ok (&cfg->error)) { \
133 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
134 goto mono_error_exit; \
135 } \
136 } while (0)
138 /* Determine whenever 'ins' represents a load of the 'this' argument */
139 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
147 MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
149 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
152 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp);
154 /* helper methods signatures */
159 /* type loading helpers */
160 static GENERATE_GET_CLASS_WITH_CACHE (runtime_helpers, System.Runtime.CompilerServices, RuntimeHelpers)
161 static GENERATE_TRY_GET_CLASS_WITH_CACHE (debuggable_attribute, System.Diagnostics, DebuggableAttribute)
163 /*
164 * Instruction metadata
165 */
166 #ifdef MINI_OP
167 #undef MINI_OP
168 #endif
169 #ifdef MINI_OP3
170 #undef MINI_OP3
171 #endif
173 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
179 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == SIZEOF_VOID_P
180 #define LREG IREG
181 #else
183 #endif
184 /* keep in sync with the enum in mini.h */
185 const char
186 ins_info[] = {
188 };
189 #undef MINI_OP
190 #undef MINI_OP3
192 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
193 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
194 /*
195 * This should contain the index of the last sreg + 1. This is not the same
196 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
197 */
200 };
201 #undef MINI_OP
202 #undef MINI_OP3
204 #define MONO_INIT_VARINFO(vi,id) do { \
205 (vi)->range.first_use.pos.bid = 0xffff; \
206 (vi)->reg = -1; \
207 (vi)->idx = (id); \
208 } while (0)
210 guint32
212 {
214 }
216 guint32
218 {
220 }
222 guint32
224 {
226 }
228 guint32
230 {
232 }
234 guint32
236 {
238 }
240 /*
241 * mono_alloc_ireg_ref:
242 *
243 * Allocate an IREG, and mark it as holding a GC ref.
244 */
245 guint32
247 {
249 }
251 /*
252 * mono_alloc_ireg_mp:
253 *
254 * Allocate an IREG, and mark it as holding a managed pointer.
255 */
256 guint32
258 {
260 }
262 /*
263 * mono_alloc_ireg_copy:
264 *
265 * Allocate an IREG with the same GC type as VREG.
266 */
267 guint32
269 {
274 else
276 }
278 guint
280 {
285 handle_enum:
309 #if SIZEOF_REGISTER == 8
311 #else
313 #endif
322 }
336 else
340 }
342 }
344 void
346 {
359 }
361 void
363 {
367 }
371 {
374 }
378 {
382 mono_error_set_generic_error (&cfg->error, "System", "FieldAccessException", "Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);
385 }
389 {
393 }
397 {
399 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), line);
401 }
405 {
406 cfg->exception_message = g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), file, line);
410 }
412 /*
413 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
414 * foo<T> (int i) { ldarg.0; box T; }
415 */
416 #define UNVERIFIED do { \
417 if (cfg->gsharedvt) { \
418 if (cfg->verbose_level > 2) \
420 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
421 goto exception_exit; \
422 } \
423 break_on_unverified (); \
424 goto unverified; \
425 } while (0)
427 #define GET_BBLOCK(cfg,tblock,ip) do { \
428 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
429 if (!(tblock)) { \
430 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
431 NEW_BBLOCK (cfg, (tblock)); \
432 (tblock)->cil_code = (ip); \
433 ADD_BBLOCK (cfg, (tblock)); \
434 } \
435 } while (0)
437 #if defined(TARGET_X86) || defined(TARGET_AMD64)
438 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
439 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
440 (dest)->dreg = alloc_ireg_mp ((cfg)); \
441 (dest)->sreg1 = (sr1); \
442 (dest)->sreg2 = (sr2); \
443 (dest)->inst_imm = (imm); \
444 (dest)->backend.shift_amount = (shift); \
445 MONO_ADD_INS ((cfg)->cbb, (dest)); \
446 } while (0)
447 #endif
449 /* Emit conversions so both operands of a binary opcode are of the same type */
450 static void
452 {
461 /* Mixing r4/r8 is allowed by the spec */
469 }
477 }
478 }
480 #if SIZEOF_REGISTER == 8
481 /* FIXME: Need to add many more cases */
488 }
489 #endif
490 }
492 #define ADD_BINOP(op) do { \
493 MONO_INST_NEW (cfg, ins, (op)); \
494 sp -= 2; \
495 ins->sreg1 = sp [0]->dreg; \
496 ins->sreg2 = sp [1]->dreg; \
497 type_from_op (cfg, ins, sp [0], sp [1]); \
498 CHECK_TYPE (ins); \
500 add_widen_op (cfg, ins, &sp [0], &sp [1]); \
501 ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
502 MONO_ADD_INS ((cfg)->cbb, (ins)); \
503 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
504 } while (0)
506 #define ADD_UNOP(op) do { \
507 MONO_INST_NEW (cfg, ins, (op)); \
508 sp--; \
509 ins->sreg1 = sp [0]->dreg; \
510 type_from_op (cfg, ins, sp [0], NULL); \
511 CHECK_TYPE (ins); \
512 (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
513 MONO_ADD_INS ((cfg)->cbb, (ins)); \
514 *sp++ = mono_decompose_opcode (cfg, ins); \
515 } while (0)
517 #define ADD_BINCOND(next_block) do { \
518 MonoInst *cmp; \
519 sp -= 2; \
520 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
521 cmp->sreg1 = sp [0]->dreg; \
522 cmp->sreg2 = sp [1]->dreg; \
523 type_from_op (cfg, cmp, sp [0], sp [1]); \
524 CHECK_TYPE (cmp); \
525 add_widen_op (cfg, cmp, &sp [0], &sp [1]); \
526 type_from_op (cfg, ins, sp [0], sp [1]); \
527 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
528 GET_BBLOCK (cfg, tblock, target); \
529 link_bblock (cfg, cfg->cbb, tblock); \
530 ins->inst_true_bb = tblock; \
531 if ((next_block)) { \
532 link_bblock (cfg, cfg->cbb, (next_block)); \
533 ins->inst_false_bb = (next_block); \
534 start_new_bblock = 1; \
535 } else { \
536 GET_BBLOCK (cfg, tblock, ip); \
537 link_bblock (cfg, cfg->cbb, tblock); \
538 ins->inst_false_bb = tblock; \
539 start_new_bblock = 2; \
540 } \
541 if (sp != stack_start) { \
542 handle_stack_args (cfg, stack_start, sp - stack_start); \
543 CHECK_UNVERIFIABLE (cfg); \
544 } \
545 MONO_ADD_INS (cfg->cbb, cmp); \
546 MONO_ADD_INS (cfg->cbb, ins); \
547 } while (0)
549 /* *
550 * link_bblock: Links two basic blocks
551 *
552 * links two basic blocks in the control flow graph, the 'from'
553 * argument is the starting block and the 'to' argument is the block
554 * the control flow ends to after 'from'.
555 */
556 static void
558 {
562 #if 0
565 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
566 else
571 else
573 }
574 #endif
581 }
582 }
584 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
587 }
591 }
598 }
599 }
601 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
604 }
608 }
609 }
611 void
613 {
615 }
617 /**
618 * mono_find_block_region:
619 *
620 * We mark each basic block with a region ID. We use that to avoid BB
621 * optimizations when blocks are in different regions.
622 *
623 * Returns:
624 * A region token that encodes where this region is, and information
625 * about the clause owner for this block.
626 *
627 * The region encodes the try/catch/filter clause that owns this block
628 * as well as the type. -1 is a special value that represents a block
629 * that is in none of try/catch/filter.
630 */
631 static int
633 {
640 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
649 else
651 }
652 }
658 }
661 }
663 static gboolean
665 {
672 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FAULT)
677 }
679 }
683 {
695 }
696 }
698 }
700 static void
702 {
710 /* prevent it from being register allocated */
714 }
716 MonoInst *
718 {
720 }
724 {
732 /* prevent it from being register allocated */
738 }
740 /*
741 * Returns the type used in the eval stack when @type is loaded.
742 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
743 */
744 void
746 {
754 }
756 handle_enum:
800 }
816 }
820 }
821 }
823 /*
824 * The following tables are used to quickly validate the IL code in type_from_op ().
825 */
826 static const char
832 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R8},
836 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4}
837 };
839 static const char
840 neg_table [] = {
842 };
844 /* reduce the size of this table */
845 static const char
855 };
857 static const char
859 /* Inv i L p F & O vt r4 */
869 };
871 /* reduce the size of this table */
872 static const char
882 };
884 /*
885 * Tables to map from the non-specific opcode to the matching
886 * type-specific opcode.
887 */
888 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
889 static const guint16
891 0, OP_IADD-CEE_ADD, OP_LADD-CEE_ADD, OP_PADD-CEE_ADD, OP_FADD-CEE_ADD, OP_PADD-CEE_ADD, 0, 0, OP_RADD-CEE_ADD
892 };
894 /* handles from CEE_NEG to CEE_CONV_U8 */
895 static const guint16
897 0, OP_INEG-CEE_NEG, OP_LNEG-CEE_NEG, OP_PNEG-CEE_NEG, OP_FNEG-CEE_NEG, OP_PNEG-CEE_NEG, 0, 0, OP_RNEG-CEE_NEG
898 };
900 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
901 static const guint16
903 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, 0, OP_RCONV_TO_U2-CEE_CONV_U2
904 };
906 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
907 static const guint16
909 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, 0, 0, OP_RCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN
910 };
912 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
913 static const guint16
915 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, 0, 0, OP_RCONV_TO_OVF_I1-CEE_CONV_OVF_I1
916 };
918 /* handles from CEE_BEQ to CEE_BLT_UN */
919 static const guint16
921 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, 0, OP_FBEQ-CEE_BEQ
922 };
924 /* handles from CEE_CEQ to CEE_CLT_UN */
925 static const guint16
927 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, 0, OP_RCEQ-OP_CEQ
928 };
930 /*
931 * Sets ins->type (the type on the eval stack) according to the
932 * type of the opcode and the arguments to it.
933 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
934 *
935 * FIXME: this function sets ins->type unconditionally in some cases, but
936 * it should set it to invalid for some types (a conv.x on an object)
937 */
938 static void
940 {
942 /* binops */
948 /* FIXME: check unverifiable args for STACK_MP */
970 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
976 else
981 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
1007 /* unops */
1015 else
1036 }
1069 #if SIZEOF_VOID_P == 8
1071 #else
1073 #endif
1081 }
1154 }
1158 }
1160 static const char
1161 ldind_type [] = {
1162 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1163 };
1165 #if 0
1167 static const char
1170 };
1172 static int
1174 {
1185 }
1186 args++;
1187 }
1208 }
1221 }
1222 /*if (!param_table [args [i].type] [sig->params [i]->type])
1223 return 0;*/
1224 }
1226 }
1227 #endif
1229 /*
1230 * When we need a pointer to the current domain many times in a method, we
1231 * call mono_domain_get() once and we store the result in a local variable.
1232 * This function returns the variable that represents the MonoDomain*.
1233 */
1236 {
1240 }
1242 /*
1243 * The got_var contains the address of the Global Offset Table when AOT
1244 * compiling.
1245 */
1246 MonoInst *
1248 {
1253 }
1255 }
1259 {
1264 /* force the var to be stack allocated */
1266 }
1269 }
1285 }
1287 }
1291 {
1325 else
1330 }
1333 }
1337 {
1371 }
1373 }
1375 /*
1376 * We try to share variables when possible
1377 */
1380 {
1384 /* inlining can result in deeper stacks */
1404 }
1406 }
1408 static void
1410 {
1411 /*
1412 * Don't use this if a generic_context is set, since that means AOT can't
1413 * look up the method using just the image+token.
1414 * table == 0 means this is a reference made from a wrapper.
1415 */
1417 MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1421 }
1422 }
1424 /*
1425 * This function is called to handle items that are left on the evaluation stack
1426 * at basic block boundaries. What happens is that we save the values to local variables
1427 * and we reload them later when first entering the target basic block (with the
1428 * handle_loaded_temps () function).
1429 * A single joint point will use the same variables (stored in the array bb->out_stack or
1430 * bb->in_stack, if the basic block is before or after the joint point).
1431 *
1432 * This function needs to be called _before_ emitting the last instruction of
1433 * the bb (i.e. before emitting a branch).
1434 * If the stack merge fails at a join point, cfg->unverifiable is set.
1435 */
1436 static void
1438 {
1443 gboolean found;
1451 //printf ("bblock %d has out:", bb->block_num);
1455 /* exception handlers are linked, but they should not be considered for stack args */
1458 //printf (" %d", outb->block_num);
1463 }
1464 }
1465 //printf ("\n");
1469 /*
1470 * try to reuse temps already allocated for this purpouse, if they occupy the same
1471 * stack slot and if they are of the same type.
1472 * This won't cause conflicts since if 'local' is used to
1473 * store one of the values in the in_stack of a bblock, then
1474 * the same variable will be used for the same outgoing stack
1475 * slot as well.
1476 * This doesn't work when inlining methods, since the bblocks
1477 * in the inlined methods do not inherit their in_stack from
1478 * the bblock they are inlined to. See bug #58863 for an
1479 * example.
1480 */
1483 else
1485 }
1486 }
1487 }
1491 /* exception handlers are linked, but they should not be considered for stack args */
1498 }
1500 }
1503 }
1513 }
1515 /*
1516 * It is possible that the out bblocks already have in_stack assigned, and
1517 * the in_stacks differ. In this case, we will store to all the different
1518 * in_stacks.
1519 */
1524 /* Find a bblock which has a different in_stack */
1528 /* exception handlers are linked, but they should not be considered for stack args */
1530 bindex++;
1532 }
1540 }
1544 }
1545 bindex ++;
1546 }
1547 }
1548 }
1552 {
1558 MonoJumpInfo ji;
1559 gpointer target;
1560 MonoError error;
1568 }
1570 }
1572 static void
1573 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1574 {
1576 #ifdef COMPRESSED_INTERFACE_BITMAP
1585 #else
1600 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1606 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1607 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1608 }
1609 #endif
1610 }
1612 /*
1613 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1614 * stored in "klass_reg" implements the interface "klass".
1615 */
1616 static void
1617 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1618 {
1619 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1620 }
1622 /*
1623 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1624 * stored in "vtable_reg" implements the interface "klass".
1625 */
1626 static void
1627 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1628 {
1629 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1630 }
1632 /*
1633 * Emit code which checks whenever the interface id of @klass is smaller than
1634 * than the value given by max_iid_reg.
1635 */
1636 static void
1639 {
1644 }
1645 else
1649 else
1651 }
1653 /* Same as above, but obtains max_iid from a vtable */
1654 static void
1657 {
1660 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, max_interface_id));
1662 }
1664 /* Same as above, but obtains max_iid from a klass */
1665 static void
1668 {
1671 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id));
1673 }
1675 static void
1676 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1677 {
1685 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1688 }
1689 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1699 }
1701 }
1703 static void
1704 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1705 {
1707 }
1709 static void
1710 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1711 {
1719 else
1721 }
1723 /*
1724 * Variant of the above that takes a register to the class, not the vtable.
1725 */
1726 static void
1727 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1728 {
1736 else
1738 }
1741 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1742 {
1748 }
1750 }
1754 {
1756 }
1759 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1760 {
1767 }
1769 }
1771 static void
1772 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1774 static void
1775 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1776 {
1782 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank));
1785 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
1786 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
1789 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
1790 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1793 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1800 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1802 }
1805 /* Check that the object is a vector too */
1810 }
1819 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1822 }
1823 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1826 }
1827 }
1829 static void
1830 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1831 {
1833 }
1835 static void
1837 {
1856 #if SIZEOF_REGISTER == 8
1860 #endif
1861 }
1862 }
1868 else
1872 /* This could be optimized further if neccesary */
1877 }
1879 }
1886 }
1891 }
1892 }
1898 }
1903 }
1908 }
1909 }
1911 void
1912 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1913 {
1919 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1923 /* This could be optimized further if neccesary */
1931 }
1932 }
1942 }
1943 }
1952 }
1960 }
1968 }
1969 }
1971 static void
1973 {
1987 }
1988 }
1990 /*
1991 * emit_push_lmf:
1992 *
1993 * Emit IR to push the current LMF onto the LMF stack.
1994 */
1995 static void
1997 {
1998 /*
1999 * Emit IR to push the LMF:
2000 * lmf_addr = <lmf_addr from tls>
2001 * lmf->lmf_addr = lmf_addr
2002 * lmf->prev_lmf = *lmf_addr
2003 * *lmf_addr = lmf
2004 */
2012 /* Load current lmf */
2018 /* Save previous_lmf */
2019 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), lmf_ins->dreg);
2020 /* Set new LMF */
2023 /*
2024 * Store lmf_addr in a variable, so it can be allocated to a global register.
2025 */
2027 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2029 #ifdef HOST_WIN32
2036 EMIT_NEW_BIALU_IMM (cfg, lmf_ins, OP_PADD_IMM, lmf_reg, jit_tls_dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2039 }
2040 #else
2045 #ifdef TARGET_IOS
2048 /* Inline mono_get_lmf_addr () */
2049 /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
2051 /* Load mono_jit_tls_id */
2054 else
2056 /* call pthread_getspecific () */
2058 /* lmf_addr = &jit_tls->lmf */
2059 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, cfg->lmf_addr_var->dreg, jit_tls_ins->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2061 #else
2063 #endif
2064 }
2065 #endif
2072 /* Save previous_lmf */
2074 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
2075 /* Set new lmf */
2077 }
2078 }
2080 /*
2081 * emit_pop_lmf:
2082 *
2083 * Emit IR to pop the current LMF from the LMF stack.
2084 */
2085 static void
2087 {
2098 /* Load previous_lmf */
2100 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2101 /* Set new LMF */
2104 /*
2105 * Emit IR to pop the LMF:
2106 * *(lmf->lmf_addr) = lmf->prev_lmf
2107 */
2108 /* This could be called before emit_push_lmf () */
2110 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2114 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2116 }
2117 }
2119 static void
2121 {
2124 /*
2125 * Avoid instrumenting inlined methods since it can
2126 * distort profiling results.
2127 */
2134 }
2135 }
2137 static int
2139 {
2140 handle_enum:
2169 else
2186 /* gsharedvt */
2190 }
2192 }
2194 //XXX this ignores if t is byref
2195 #define MONO_TYPE_IS_PRIMITIVE_SCALAR(t) ((((((t)->type >= MONO_TYPE_BOOLEAN && (t)->type <= MONO_TYPE_U8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
2197 /*
2198 * target_type_is_incompatible:
2199 * @cfg: MonoCompile context
2200 *
2201 * Check that the item @arg on the evaluation stack can be stored
2202 * in the target type (can be a local, or field, etc).
2203 * The cfg arg can be used to check if we need verification or just
2204 * validity checks.
2205 *
2206 * Returns: non-0 value if arg can't be stored on a target.
2207 */
2208 static int
2210 {
2215 /* FIXME: check that the pointed to types match */
2217 /* This is needed to handle gshared types + ldaddr. We lower the types so we can handle enums and other typedef-like types. */
2218 MonoClass *target_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&mono_class_from_mono_type (target)->byval_arg));
2219 MonoClass *source_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg));
2221 /* if the target is native int& or same type */
2225 /* Both are primitive type byrefs and the source points to a larger type that the destination */
2226 if (MONO_TYPE_IS_PRIMITIVE_SCALAR (&target_class_lowered->byval_arg) && MONO_TYPE_IS_PRIMITIVE_SCALAR (&source_class_lowered->byval_arg) &&
2227 mono_class_instance_size (target_class_lowered) <= mono_class_instance_size (source_class_lowered))
2230 }
2234 }
2250 /* STACK_MP is needed when setting pinned locals */
2257 /*
2258 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
2259 * in native int. (#688008).
2260 */
2271 /* FIXME: check type compatibility */
2307 /* The second cases is needed when doing partial sharing */
2308 if (klass != arg->klass && target_class != arg->klass && target_class != mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg)))
2314 /* FIXME: check type compatibility */
2316 }
2326 }
2330 }
2332 }
2334 /*
2335 * Prepare arguments for passing to a function call.
2336 * Return a non-zero value if the arguments can't be passed to the given
2337 * signature.
2338 * The type checks are not yet complete and some conversions may need
2339 * casts on 32 or 64 bit architectures.
2340 *
2341 * FIXME: implement this using target_type_is_incompatible ()
2342 */
2343 static int
2345 {
2352 args++;
2353 }
2359 }
2361 handle_enum:
2379 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2407 }
2420 /* gsharedvt */
2427 }
2428 }
2430 }
2432 static int
2434 {
2450 }
2453 }
2455 static int
2457 {
2473 }
2476 }
2478 /* Either METHOD or IMT_ARG needs to be set */
2479 static void
2480 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2481 {
2491 }
2493 #ifdef ENABLE_LLVM
2495 #endif
2498 }
2506 }
2509 }
2513 {
2521 }
2523 static int
2525 {
2528 else
2530 }
2532 static int
2534 {
2537 else
2539 }
2541 /*
2542 * check_method_sharing:
2543 *
2544 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2545 */
2546 static void
2547 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2548 {
2559 /*
2560 * Pass vtable iff target method might
2561 * be shared, which means that sharing
2562 * is enabled for its class and its
2563 * context is sharable (and it's not a
2564 * generic method).
2565 */
2566 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2568 }
2579 }
2580 }
2586 }
2591 {
2594 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2596 #endif
2618 //g_assert_not_reached ();
2619 }
2626 /*
2627 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2628 * address of return value to increase optimization opportunities.
2629 * Before vtype decomposition, the dreg of the call ins itself represents the
2630 * fact the call modifies the return value. After decomposition, the call will
2631 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2632 * will be transformed into an LDADDR.
2633 */
2637 /* We reference the call too since call->dreg could change during optimization */
2647 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2649 /*
2650 * If the call has a float argument, we would need to do an r8->r4 conversion using
2651 * an icall, but that cannot be done during the call sequence since it would clobber
2652 * the call registers + the stack. So we do it before emitting the call.
2653 */
2660 else
2671 /* The result will be in an int vreg */
2673 }
2674 }
2675 }
2676 #endif
2680 #ifdef ENABLE_LLVM
2683 else
2685 #else
2687 #endif
2693 }
2695 static void
2697 {
2701 #ifdef ENABLE_LLVM
2703 #endif
2704 }
2707 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2708 {
2714 if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2719 }
2724 }
2728 cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2733 }
2735 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2753 /* Restore the stack so we don't crash when throwing the exception */
2760 }
2766 }
2769 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2772 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2774 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2777 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2779 {
2780 #ifndef DISABLE_REMOTING
2782 #endif
2789 gboolean need_unbox_trampoline;
2800 }
2803 /* Create the real signature */
2804 /* FIXME: Cache these */
2809 }
2813 #ifndef DISABLE_REMOTING
2823 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2826 }
2827 #endif
2832 need_unbox_trampoline = method->klass == mono_defaults.object_class || mono_class_is_interface (method->klass);
2834 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual_, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2836 #ifndef DISABLE_REMOTING
2839 else
2840 #endif
2852 if (!cfg->llvm_only && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2857 /* Make a call to delegate->invoke_impl */
2862 /* We must emit a dummy use here because the delegate trampoline will
2863 replace the 'this' argument with the delegate target making this activation
2864 no longer a root for the delegate.
2865 This is an issue for delegates that target collectible code such as dynamic
2866 methods of GC'able assemblies.
2868 For a test case look into #667921.
2870 FIXME: a dummy use is not the best way to do it as the local register allocator
2871 will put it on a caller save register and spil it around the call.
2872 Ideally, we would either put it on a callee save register or only do the store part.
2873 */
2877 }
2884 /*
2885 * the method is not virtual, we just need to ensure this is not null
2886 * and then we can call the method directly.
2887 */
2888 #ifndef DISABLE_REMOTING
2889 if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2890 /*
2891 * The check above ensures method is not gshared, this is needed since
2892 * gshared methods can't have wrappers.
2893 */
2895 }
2896 #endif
2903 /*
2904 * the method is virtual, but we can statically dispatch since either
2905 * it's class or the method itself are sealed.
2906 * But first we need to ensure it's not a null reference.
2907 */
2913 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2920 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2933 }
2934 }
2939 }
2940 }
2948 }
2950 MonoInst*
2951 mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this_ins)
2952 {
2953 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this_ins, NULL, NULL);
2954 }
2956 MonoInst*
2959 {
2970 }
2972 MonoInst*
2974 {
2980 }
2982 /*
2983 * mono_emit_abs_call:
2984 *
2985 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2986 */
2990 {
2994 /*
2995 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2996 * handle it.
2997 */
3004 }
3008 {
3009 // FIXME: memory allocation
3013 res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
3020 }
3022 /* Make an indirect call to FSIG passing an additional argument */
3024 emit_extra_arg_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **orig_args, int arg_reg, MonoInst *call_target)
3025 {
3031 /* Make a call with an rgctx/extra arg */
3034 else
3035 args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
3045 }
3047 /* Emit an indirect call to the function descriptor ADDR */
3049 emit_llvmonly_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, MonoInst *addr)
3050 {
3056 /*
3057 * addr points to a <addr, arg> pair, load both of them, and
3058 * make a call to addr, passing arg as an extra arg.
3059 */
3066 }
3068 static gboolean
3070 {
3071 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
3072 #ifdef TARGET_AMD64
3075 #endif
3079 }
3081 MonoInst*
3082 mono_emit_jit_icall_by_info (MonoCompile *cfg, int il_offset, MonoJitICallInfo *info, MonoInst **args)
3083 {
3084 /*
3085 * Call the jit icall without a wrapper if possible.
3086 * The wrapper is needed for the following reasons:
3087 * - to handle exceptions thrown using mono_raise_exceptions () from the
3088 * icall function. The EH code needs the lmf frame pushed by the
3089 * wrapper to be able to unwind back to managed code.
3090 * - to be able to do stack walks for asynchronously suspended
3091 * threads when debugging.
3092 */
3102 }
3104 /*
3105 * Inline the wrapper method, which is basically a call to the C icall, and
3106 * an exception check.
3107 */
3116 }
3117 }
3121 {
3126 /*
3127 * Native code might return non register sized integers
3128 * without initializing the upper bits.
3129 */
3145 }
3154 }
3155 }
3156 }
3159 }
3162 static void
3164 {
3167 args [0] = emit_get_rgctx_method (cfg, mono_method_check_context_used (method), method, MONO_RGCTX_INFO_METHOD);
3168 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cil_method), cil_method, MONO_RGCTX_INFO_METHOD);
3171 }
3175 {
3181 }
3183 }
3185 static void
3186 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
3187 {
3204 }
3205 }
3206 }
3208 static void
3210 {
3212 gpointer card_table_mask;
3225 if (cfg->backend->have_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3241 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3242 * IMM's larger than 32bits.
3243 */
3252 }
3255 }
3257 static gboolean
3258 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3259 {
3266 /*types with references can't have alignment smaller than sizeof(void*) */
3270 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3276 /* We don't unroll more than 5 stores to avoid code bloat. */
3278 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3286 }
3295 /*tmp = dreg*/
3315 /*tmp += sizeof (void*)*/
3319 }
3320 }
3322 /* Those cannot be references since size < sizeof (void*) */
3328 }
3335 }
3342 }
3345 }
3347 /*
3348 * Emit code to copy a valuetype of type @klass whose address is stored in
3349 * @src->dreg to memory whose address is stored at @dest->dreg.
3350 */
3351 void
3352 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3353 {
3365 /*
3366 * This check breaks with spilled vars... need to handle it during verification anyway.
3367 * g_assert (klass && klass == src->klass && klass == dest->klass);
3368 */
3374 }
3378 else
3381 /* if native is true there should be no references in the struct */
3383 /* Avoid barriers when storing to the stack */
3393 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3394 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3402 }
3406 else
3409 }
3410 }
3413 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3420 else
3426 else
3428 }
3429 }
3433 {
3439 }
3441 }
3443 void
3445 {
3448 guint32 align;
3454 /* FIXME: Optimize this for the case when dest is an LDADDR */
3460 bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3466 }
3474 }
3481 }
3482 }
3484 /*
3485 * emit_get_rgctx:
3486 *
3487 * Emit IR to return either the this pointer for instance method,
3488 * or the mrgctx for static methods.
3489 */
3492 {
3525 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3527 }
3535 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this_ins->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3537 }
3538 }
3541 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3542 {
3543 MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
3552 }
3556 {
3560 // FIXME: No fastpath since the slot is not a compile time constant
3565 else
3568 #if 0
3569 /*
3570 * FIXME: This can be called during decompose, which is a problem since it creates
3571 * new bblocks.
3572 * Also, the fastpath doesn't work since the slot number is dynamically allocated.
3573 */
3575 gboolean mrgctx;
3592 }
3602 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, rgctx_reg, rgctx->dreg, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
3603 // FIXME: Avoid this check by allocating the table when the vtable is created etc.
3608 }
3613 /* load ptr to next array */
3615 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
3616 else
3619 /* is the ptr null? */
3621 /* if yes, jump to actual trampoline */
3623 }
3625 /* fetch slot */
3628 /* is the slot null? */
3630 /* if yes, jump to actual trampoline */
3633 /* Fastpath */
3642 /* Slowpath */
3648 else
3659 #endif
3660 }
3662 /*
3663 * emit_rgctx_fetch:
3664 *
3665 * Emit IR to load the value of the rgctx entry ENTRY from the rgctx
3666 * given by RGCTX.
3667 */
3670 {
3673 else
3674 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3675 }
3680 {
3681 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);
3685 }
3690 {
3691 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_SIGNATURE, sig, rgctx_type);
3695 }
3700 {
3705 call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
3709 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_CALL, call_info, rgctx_type);
3713 }
3715 /*
3716 * emit_get_rgctx_virt_method:
3717 *
3718 * Return data for method VIRT_METHOD for a receiver of type KLASS.
3719 */
3723 {
3728 info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
3732 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_VIRT_METHOD, info, rgctx_type);
3736 }
3741 {
3745 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_METHOD, info, MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO);
3749 }
3751 /*
3752 * emit_get_rgctx_method:
3753 *
3754 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3755 * normal constants, else emit a load from the rgctx.
3756 */
3760 {
3773 }
3775 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);
3779 }
3780 }
3785 {
3786 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);
3790 }
3792 static int
3794 {
3804 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3806 }
3812 new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3814 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3817 }
3827 }
3829 /*
3830 * emit_get_gsharedvt_info:
3831 *
3832 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3833 */
3836 {
3841 /* Load info->entries [idx] */
3843 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3846 }
3849 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3850 {
3852 }
3854 /*
3855 * On return the caller must check @klass for load errors.
3856 */
3857 static void
3859 {
3874 }
3879 /*
3880 * Using an opcode instead of emitting IR here allows the hiding of the call inside the opcode,
3881 * so this doesn't have to clobber any regs and it doesn't break basic blocks.
3882 */
3899 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, bits_reg, vtable_arg->dreg, byte_offset);
3911 }
3912 }
3914 static void
3915 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3916 {
3924 }
3925 }
3927 static void
3929 {
3942 }
3948 }
3951 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3952 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3954 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3965 }
3966 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3970 }
3971 }
3973 static void
3975 {
3976 /* Reset the variables holding the cast details */
3981 /* It is enough to reset the from field */
3982 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3983 }
3984 }
3986 /*
3987 * On return the caller must check @array_class for load errors
3988 */
3989 static void
3991 {
3999 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4005 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4028 }
4029 }
4034 }
4036 /**
4037 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
4038 * generic code is generated.
4039 */
4042 {
4048 /* FIXME: What if the class is shared? We might not
4049 have to get the address of the method from the
4050 RGCTX. */
4052 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4054 cfg->signatures = g_slist_prepend_mempool (cfg->mempool, cfg->signatures, mono_method_signature (method));
4060 }
4073 }
4076 }
4077 }
4081 {
4090 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4091 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4093 /* FIXME: generics */
4096 // Check rank == 0
4100 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4101 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, element_class));
4106 /* This assertion is from the unboxcast insn */
4118 }
4120 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
4126 }
4130 {
4138 /* obj */
4141 /* klass */
4144 /* CASTCLASS */
4154 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4157 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
4160 /* Non-ref case */
4161 /* UNBOX */
4167 /* Ref case */
4170 /* Save the ref to a temporary */
4177 /* Nullable case */
4180 {
4181 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
4185 unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4192 else
4197 }
4201 /* End */
4204 /* LDOBJ */
4208 }
4210 /*
4211 * Returns NULL and set the cfg exception on error.
4212 */
4215 {
4221 MonoRgctxInfoType rgctx_info;
4225 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (klass, for_box, known_instance_size);
4229 else
4240 }
4249 }
4251 }
4254 }
4261 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !mono_class_is_ginst (klass)) {
4262 /* This happens often in argument checking code, eg. throw new FooException... */
4263 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
4269 gboolean pass_lw;
4275 }
4287 }
4294 }
4297 }
4298 }
4301 }
4303 /*
4304 * Returns NULL and set the cfg exception on error.
4305 */
4308 {
4317 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4320 /* FIXME: What if the class is shared? We might not
4321 have to get the method address from the RGCTX. */
4323 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4327 }
4340 }
4343 }
4344 }
4360 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4363 /* Non-ref case */
4367 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4375 /* Ref case */
4378 /* val is a vtype, so has to load the value manually */
4386 /* Nullable case */
4389 {
4391 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
4395 /*
4396 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
4397 * construct that method at JIT time, so have to do things by hand.
4398 */
4399 box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4406 else
4411 }
4423 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4425 }
4426 }
4428 static gboolean
4429 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4430 {
4436 container = mono_class_get_generic_container (mono_class_get_generic_class (klass)->container_class);
4443 }
4447 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4452 }
4454 }
4458 static gboolean
4460 {
4461 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
4465 /*
4466 * An icall is directly callable if it doesn't directly or indirectly call mono_raise_exception ().
4467 * Whitelist a few icalls for now.
4468 */
4478 }
4482 /* No locking needed */
4483 if (cmethod->klass->image == mono_defaults.corlib && g_hash_table_lookup (direct_icall_type_hash, cmethod->klass->name))
4486 }
4488 static gboolean
4490 {
4494 }
4496 }
4498 #define is_complex_isinst(klass) (mono_class_is_interface (klass) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
4502 {
4505 }
4509 {
4518 }
4520 static int
4522 {
4523 /* Each CASTCLASS_CACHE patch needs a unique index which identifies the call site */
4526 }
4531 {
4539 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4542 }
4546 {
4550 /* obj */
4553 /* klass */
4556 /* inline cache*/
4558 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4560 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
4562 }
4564 /*
4565 * Returns NULL and set the cfg exception on error.
4566 */
4569 {
4581 if (mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4586 /* obj */
4589 /* klass - it's the second element of the cache entry*/
4590 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4592 /* cache */
4596 }
4599 }
4609 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4614 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4616 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_SEALED)) {
4617 /* the remoting code is broken, access the class for now */
4618 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4624 }
4627 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4629 }
4632 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4634 }
4635 }
4642 }
4644 /*
4645 * Returns NULL and set the cfg exception on error.
4646 */
4649 {
4660 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4661 MonoInst *cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
4665 /* klass - it's the second element of the cache entry*/
4666 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4670 }
4673 }
4679 /* Do the assignment at the beginning, so the other assignment can be if converted */
4687 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4691 /* the is_null_bb target simply copies the input register to the output */
4701 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4704 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4705 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
4708 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
4709 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4713 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4723 /* Check that the object is a vector too */
4728 }
4730 /* the is_null_bb target simply copies the input register to the output */
4732 }
4735 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4736 /* the is_null_bb target simply copies the input register to the output */
4739 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_SEALED)) {
4741 /* the remoting code is broken, access the class for now */
4742 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4748 }
4751 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4753 }
4757 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4758 /* the is_null_bb target simply copies the input register to the output */
4760 }
4761 }
4762 }
4774 }
4778 {
4779 /* This opcode takes as input an object reference and a class, and returns:
4780 0) if the object is an instance of the class,
4781 1) if the object is not instance of the class,
4782 2) if the object is a proxy whose type cannot be determined */
4785 #ifndef DISABLE_REMOTING
4787 #else
4789 #endif
4793 #ifndef DISABLE_REMOTING
4795 #endif
4800 #ifndef DISABLE_REMOTING
4803 #endif
4809 #ifndef DISABLE_REMOTING
4811 #endif
4815 #ifndef DISABLE_REMOTING
4820 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4823 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4826 #else
4828 #endif
4830 #ifndef DISABLE_REMOTING
4835 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4837 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4838 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4841 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4851 #else
4853 #endif
4854 }
4861 #ifndef DISABLE_REMOTING
4866 #endif
4874 /* FIXME: */
4880 }
4884 {
4885 /* This opcode takes as input an object reference and a class, and returns:
4886 0) if the object is an instance of the class,
4887 1) if the object is a proxy whose type cannot be determined
4888 an InvalidCastException exception is thrown otherwhise*/
4891 #ifndef DISABLE_REMOTING
4893 #else
4895 #endif
4900 #ifndef DISABLE_REMOTING
4903 #endif
4913 #ifndef DISABLE_REMOTING
4924 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4930 #else
4934 #endif
4936 #ifndef DISABLE_REMOTING
4941 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4944 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4945 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4948 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4964 #else
4966 #endif
4967 }
4973 #ifndef DISABLE_REMOTING
4975 #endif
4977 /* FIXME: */
4983 }
4986 handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, MonoInst *enum_flag)
4987 {
4990 gboolean is_i4;
4995 #if SIZEOF_REGISTER == 8
4998 #endif
5004 }
5006 {
5024 }
5027 }
5028 }
5030 /*
5031 * Returns NULL and set the cfg exception on error.
5032 */
5034 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual_)
5035 {
5038 gpointer trampoline;
5047 if (!mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke), context_used ? NULL : method))
5049 }
5055 /* Inline the contents of mono_delegate_ctor */
5057 /* Set target field */
5058 /* Optimize away setting of NULL target */
5060 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
5063 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
5065 }
5066 }
5068 /* Set method field */
5070 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
5072 /*
5073 * To avoid looking up the compiled code belonging to the target method
5074 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
5075 * store it, and we fill it after the method has been compiled.
5076 */
5081 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
5087 code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
5091 }
5095 }
5096 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
5097 }
5110 }
5113 }
5118 del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
5125 trampoline = mono_create_delegate_virtual_trampoline (cfg->domain, klass, context_used ? NULL : method);
5126 else
5127 trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
5129 }
5131 /* Set invoke_impl field */
5133 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
5136 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
5137 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
5140 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
5141 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
5142 }
5146 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
5148 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
5151 }
5155 {
5158 /* Need to register the icall so it gets an icall wrapper */
5163 /* mono_array_new_va () needs a vararg calling convention */
5167 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
5169 }
5171 /*
5172 * handle_constrained_gsharedvt_call:
5173 *
5174 * Handle constrained calls where the receiver is a gsharedvt type.
5175 * Return the instruction representing the call. Set the cfg exception on failure.
5176 */
5178 handle_constrained_gsharedvt_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, MonoClass *constrained_class,
5180 {
5184 /*
5185 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
5186 * This is hard to do with the current call code, since we would have to emit a branch and two different calls. So instead, we
5187 * pack the arguments into an array, and do the rest of the work in in an icall.
5188 */
5189 if (((cmethod->klass == mono_defaults.object_class) || mono_class_is_interface (cmethod->klass) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
5190 (MONO_TYPE_IS_VOID (fsig->ret) || MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_IS_REFERENCE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret) || mini_is_gsharedvt_type (fsig->ret)) &&
5191 (fsig->param_count == 0 || (!fsig->hasthis && fsig->param_count == 1) || (fsig->param_count == 1 && (MONO_TYPE_IS_REFERENCE (fsig->params [0]) || fsig->params [0]->byref || mini_is_gsharedvt_type (fsig->params [0]))))) {
5194 /*
5195 * This case handles calls to
5196 * - object:ToString()/Equals()/GetHashCode(),
5197 * - System.IComparable<T>:CompareTo()
5198 * - System.IEquatable<T>:Equals ()
5199 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
5200 */
5204 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
5205 else
5207 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_class), constrained_class, MONO_RGCTX_INFO_KLASS);
5209 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
5211 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
5221 ins = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
5223 /* deref_arg = BOX_TYPE != MONO_GSHAREDVT_BOX_TYPE_VTYPE */
5232 }
5236 }
5245 /* Unbox */
5246 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
5248 /* Load value */
5251 /* ins represents the call result */
5252 }
5255 }
5261 exception_exit:
5263 }
5265 static void
5267 {
5277 /* Add it to the start of the first bblock */
5281 }
5282 else
5287 /*
5288 * Add a dummy use to keep the got_var alive, since real uses might
5289 * only be generated by the back ends.
5290 * Add it to end_bblock, so the variable's lifetime covers the whole
5291 * method.
5292 * It would be better to make the usage of the got var explicit in all
5293 * cases when the backend needs it (i.e. calls, throw etc.), so this
5294 * wouldn't be needed.
5295 */
5298 }
5303 static gboolean
5305 {
5306 MonoMethodHeaderSummary header;
5308 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5311 #endif
5324 /*runtime, icall and pinvoke are checked by summary call*/
5331 /* also consider num_locals? */
5332 /* Do the size check early to avoid creating vtables */
5336 else
5339 }
5340 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
5343 /*
5344 * if we can initialize the class of the method right away, we do,
5345 * otherwise we don't allow inlining if the class needs initialization,
5346 * since it would mean inserting a call to mono_runtime_class_init()
5347 * inside the inlined code
5348 */
5350 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
5356 MonoError error;
5360 }
5361 }
5364 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
5366 /* No vtable created yet */
5371 /* This makes so that inline cannot trigger */
5372 /* .cctors: too many apps depend on them */
5373 /* running with a specific order... */
5376 MonoError error;
5380 }
5381 }
5384 /* No vtable created yet */
5391 }
5393 /*
5394 * If we're compiling for shared code
5395 * the cctor will need to be run at aot method load time, for example,
5396 * or at the end of the compilation of the inlining method.
5397 */
5398 if (mono_class_needs_cctor_run (method->klass, NULL) && !((mono_class_get_flags (method->klass) & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
5400 }
5402 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5404 /* FIXME: */
5410 }
5411 #endif
5417 }
5419 static gboolean
5420 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
5421 {
5426 }
5431 }
5437 /* The initialization is already done before the method is called */
5441 }
5444 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
5445 {
5447 guint32 size;
5456 }
5462 #if SIZEOF_REGISTER == 8
5463 /* The array reg is 64 bits but the index reg is only 32 */
5465 /* Not needed */
5470 }
5471 #else
5477 }
5478 #endif
5483 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5487 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
5492 }
5493 #endif
5500 /* gsharedvt */
5508 }
5510 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5516 }
5519 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
5520 {
5534 guint32 size;
5542 #if SIZEOF_REGISTER == 8
5543 /* The array reg is 64 bits but the index reg is only 32 */
5545 /* Not needed */
5553 }
5554 #else
5555 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
5557 #endif
5559 /* range checking */
5583 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5590 }
5593 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
5594 {
5606 /* emit_ldelema_2 depends on OP_LMUL */
5607 if (!cfg->backend->emulate_mul_div && rank == 2 && (cfg->opt & MONO_OPT_INTRINS) && !mini_is_gsharedvt_variable_klass (eclass)) {
5609 }
5613 else
5619 }
5621 static MonoBreakPolicy
5623 {
5625 }
5629 /**
5630 * mono_set_break_policy:
5631 * policy_callback: the new callback function
5632 *
5633 * Allow embedders to decide wherther to actually obey breakpoint instructions
5634 * (both break IL instructions and Debugger.Break () method calls), for example
5635 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
5636 * untrusted or semi-trusted code.
5637 *
5638 * @policy_callback will be called every time a break point instruction needs to
5639 * be inserted with the method argument being the method that calls Debugger.Break()
5640 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
5641 * if it wants the breakpoint to not be effective in the given method.
5642 * #MONO_BREAK_POLICY_ALWAYS is the default.
5643 */
5644 void
5646 {
5649 else
5651 }
5653 static gboolean
5666 }
5667 }
5669 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5671 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5672 {
5676 /* the bounds check is already done by the callers */
5686 }
5688 }
5691 static gboolean
5693 {
5695 }
5699 {
5726 // FIXME-VT: OP_ICONST optimization
5733 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
5746 }
5748 }
5749 }
5752 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5753 {
5758 else
5767 }
5768 }
5770 static gboolean
5772 {
5777 return_klass = mono_class_from_mono_type (mini_get_underlying_type (&return_klass->byval_arg));
5782 //Don't allow mixing reference types with value types
5787 }
5793 }
5795 //That are blitable
5799 /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5800 if ((MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5801 (!MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg))) {
5805 }
5807 if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5808 return_klass->byval_arg.type == MONO_TYPE_R4 || return_klass->byval_arg.type == MONO_TYPE_R8) {
5812 }
5817 //We can do it if sizes match
5822 }
5824 //No simple way to handle struct if sizes don't match
5829 }
5831 /*
5832 * Same reg size category.
5833 * A quick note on why we don't require widening here.
5834 * The intrinsic is "R Array.UnsafeMov<S,R> (S s)".
5835 *
5836 * Since the source value comes from a function argument, the JIT will already have
5837 * the value in a VREG and performed any widening needed before (say, when loading from a field).
5838 */
5843 }
5846 }
5850 {
5857 //Valuetypes that are semantically equivalent or numbers than can be widened to
5861 //Arrays of valuetypes that are semantically equivalent
5862 if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (cfg, param_klass->element_class, return_klass->element_class))
5866 }
5869 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5870 {
5871 #ifdef MONO_ARCH_SIMD_INTRINSICS
5878 }
5879 #endif
5882 }
5886 {
5893 }
5896 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5897 {
5901 /* The LLVM backend supports these intrinsics */
5911 }
5919 }
5941 }
5942 }
5951 }
5952 }
5955 }
5958 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5959 {
5967 }
5970 }
5973 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5974 {
5985 #if SIZEOF_REGISTER == 8
5989 /* The array reg is 64 bits but the index reg is only 32 */
5991 }
5992 #else
5994 #endif
5997 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5998 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
6002 #else
6008 #endif
6011 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6013 /* Decompose later to allow more optimizations */
6027 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
6028 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
6032 } else if (!cfg->backend->emulate_mul_div && strcmp (cmethod->name, "InternalGetHashCode") == 0 && fsig->param_count == 1 && !mono_gc_is_moving ()) {
6048 if (strcmp (cmethod->name, "GetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6050 else if (strcmp (cmethod->name, "SetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6053 #ifndef MONO_BIG_ARRAYS
6054 /*
6055 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
6056 * Array methods.
6057 */
6058 else if (((strcmp (cmethod->name, "GetLength") == 0 && fsig->param_count + fsig->hasthis == 2) ||
6073 /* Non-szarray case */
6077 else
6082 /* Szarray case */
6086 else
6094 }
6095 #endif
6110 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6133 }
6138 /*
6139 * To make async stack traces work, icalls which can block should have a wrapper.
6140 * For Monitor.Enter, emit two calls: a fastpath which doesn't have a wrapper, and a slowpath, which does.
6141 */
6146 ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4_fast : (gpointer)mono_monitor_enter_fast, args);
6149 ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4 : (gpointer)mono_monitor_enter, args);
6152 }
6182 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6209 #if SIZEOF_REGISTER == 8
6211 #else
6213 #endif
6225 }
6233 }
6250 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6266 }
6267 }
6273 #if SIZEOF_REGISTER == 8
6274 if (!cfg->llvm_only && strcmp (cmethod->name, "Read") == 0 && fsig->param_count == 1 && (fsig->params [0]->type == MONO_TYPE_I8)) {
6287 /* 64 bit reads are already atomic */
6298 }
6299 }
6300 #endif
6309 }
6310 #if SIZEOF_REGISTER == 8
6313 #endif
6329 }
6337 }
6338 #if SIZEOF_REGISTER == 8
6341 #endif
6357 }
6364 }
6365 #if SIZEOF_REGISTER == 8
6368 #endif
6379 }
6380 }
6385 gboolean is_float = fsig->params [0]->type == MONO_TYPE_R4 || fsig->params [0]->type == MONO_TYPE_R8;
6393 }
6394 #if SIZEOF_REGISTER == 8
6402 }
6403 #else
6407 }
6408 #endif
6409 else
6416 /* TODO: Decompose these opcodes instead of bailing here. */
6426 }
6443 #if SIZEOF_REGISTER == 8
6445 #else
6447 #endif
6457 }
6469 }
6473 }
6478 gboolean is_float = fsig->params [1]->type == MONO_TYPE_R4 || fsig->params [1]->type == MONO_TYPE_R8;
6486 }
6487 #if SIZEOF_REGISTER == 8
6495 }
6496 #else
6500 }
6501 #endif
6502 else
6509 /* TODO: Decompose these opcodes instead of bailing here. */
6526 }
6543 #if SIZEOF_REGISTER == 8
6545 #else
6547 #endif
6559 }
6571 }
6575 }
6583 /* int32 r = CAS (location, value, comparand); */
6592 /* bool result = r == comparand; */
6604 /* *success = result; */
6608 }
6622 gboolean is_ref;
6626 /* t is a byref type, so the reference check is more complicated */
6644 #if SIZEOF_REGISTER == 8
6649 #else
6654 #endif
6661 ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : (is_float ? mono_alloc_freg (cfg) : mono_alloc_ireg (cfg));
6682 #if SIZEOF_REGISTER == 8
6684 #else
6686 #endif
6698 }
6699 }
6700 }
6705 gboolean is_ref;
6725 #if SIZEOF_REGISTER == 8
6730 #else
6735 #endif
6749 }
6750 }
6763 }
6765 }
6770 #ifdef TARGET_WIN32
6772 #else
6774 #endif
6775 }
6780 /* No stack walks are currently available, so implement this as an intrinsic */
6786 }
6791 /* No stack walks are currently available, so implement this as an intrinsic */
6795 /* This returns the declaring generic method */
6804 }
6806 /*
6807 * There is general branchless code for Min/Max, but it does not work for
6808 * all inputs:
6809 * http://everything2.com/?node_id=1051618
6810 */
6819 ) {
6836 }
6845 // FIXME: Leaks
6849 }
6850 }
6852 #ifdef MONO_ARCH_SIMD_INTRINSICS
6857 }
6858 #endif
6868 }
6871 }
6873 /*
6874 * This entry point could be used later for arbitrary method
6875 * redirection.
6876 */
6880 {
6882 /* managed string allocation support */
6883 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
6889 #ifndef MONO_CROSS_COMPILE
6891 #endif
6897 }
6898 }
6900 }
6902 static void
6904 {
6909 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
6911 /*
6912 * FIXME: We should use *args++ = sp [0], but that would mean the arg
6913 * would be different than the MonoInst's used to represent arguments, and
6914 * the ldelema implementation can't deal with that.
6915 * Solution: When ldelema is used on an inline argument, create a var for
6916 * it, emit ldelema on that var, and emit the saving code below in
6917 * inline_method () if needed.
6918 */
6921 /* This uses cfg->args [i] which is set by the preceeding line */
6924 sp++;
6925 }
6926 }
6928 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
6929 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
6931 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
6932 static gboolean
6934 {
6943 else
6945 }
6953 //return (strncmp_result <= 0);
6957 }
6958 }
6959 #endif
6961 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
6962 static gboolean
6964 {
6974 }
6975 }
6983 //return (strncmp_result <= 0);
6987 }
6988 }
6989 #endif
6991 static void
6993 {
7027 }
7028 }
7030 static void
7032 {
7055 }
7056 }
7058 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
7059 static void
7061 {
7071 else
7073 }
7074 }
7076 /*
7077 * inline_method:
7078 *
7079 * Return the cost of inlining CMETHOD, or zero if it should not be inlined.
7080 */
7081 static int
7082 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
7084 {
7085 MonoError error;
7093 guint prev_real_offset;
7099 guint32 prev_cil_offset_to_bb_len;
7106 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
7109 #endif
7110 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
7113 #endif
7119 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7124 }
7126 /* allocate local variables */
7134 }
7136 }
7138 /*Must verify before creating locals as it can cause the JIT to assert.*/
7142 }
7144 /* allocate space to store the return value */
7147 }
7150 cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
7154 /* allocate start and end blocks */
7155 /* This is needed so if the inline is aborted, we can clean up */
7204 if ((costs >= 0 && costs < 60) || inline_always || (costs >= 0 && (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))) {
7206 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7210 /* always add some code to avoid block split failures */
7217 /*
7218 * Get rid of the begin and end bblocks if possible to aid local
7219 * optimizations.
7220 */
7223 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
7232 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
7235 }
7237 /* There could be a bblock after 'prev', and making 'prev' the current bb could cause problems */
7239 }
7241 /*
7242 * Its possible that the rvar is set in some prev bblock, but not in others.
7243 * (#1835).
7244 */
7255 }
7256 }
7257 }
7260 }
7263 /*
7264 * If the inlined method contains only a throw, then the ret var is not
7265 * set, so set it to a dummy value.
7266 */
7272 }
7280 /* This gets rid of the newly added bblocks */
7282 }
7285 }
7287 /*
7288 * Some of these comments may well be out-of-date.
7289 * Design decisions: we do a single pass over the IL code (and we do bblock
7290 * splitting/merging in the few cases when it's required: a back jump to an IL
7291 * address that was not already seen as bblock starting point).
7292 * Code is validated as we go (full verification is still better left to metadata/verify.c).
7293 * Complex operations are decomposed in simpler ones right away. We need to let the
7294 * arch-specific code peek and poke inside this process somehow (except when the
7295 * optimizations can take advantage of the full semantic info of coarse opcodes).
7296 * All the opcodes of the form opcode.s are 'normalized' to opcode.
7297 * MonoInst->opcode initially is the IL opcode or some simplification of that
7298 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
7299 * opcode with value bigger than OP_LAST.
7300 * At this point the IR can be handed over to an interpreter, a dumb code generator
7301 * or to the optimizing code generator that will translate it to SSA form.
7302 *
7303 * Profiling directed optimizations.
7304 * We may compile by default with few or no optimizations and instrument the code
7305 * or the user may indicate what methods to optimize the most either in a config file
7306 * or through repeated runs where the compiler applies offline the optimizations to
7307 * each method and then decides if it was worth it.
7308 */
7310 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
7311 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
7312 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
7313 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
7314 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
7315 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
7316 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
7317 #define CHECK_TYPELOAD(klass) if (!(klass) || mono_class_has_failure (klass)) TYPE_LOAD_ERROR ((klass))
7319 /* offset from br.s -> br like opcodes */
7320 #define BIG_BRANCH_OFFSET 13
7322 static gboolean
7324 {
7328 }
7330 static int
7331 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
7332 {
7336 guint cli_addr;
7344 UNVERIFIED;
7348 ip++;
7383 guint32 j;
7393 }
7395 }
7402 }
7407 /* Find the start of the bblock containing the throw */
7411 bb_start --;
7412 }
7415 }
7416 }
7418 unverified:
7419 exception_exit:
7422 }
7425 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error)
7426 {
7435 }
7438 }
7441 }
7444 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
7445 {
7446 MonoError error;
7447 MonoMethod *method = mini_get_method_allow_open (m, token, klass, context, cfg ? &cfg->error : &error);
7449 if (method && cfg && !cfg->gshared && mono_class_is_open_constructed_type (&method->klass->byval_arg)) {
7450 mono_error_set_bad_image (&cfg->error, cfg->method->klass->image, "Method with open type while not compiling gshared");
7452 }
7458 }
7462 {
7463 MonoError error;
7471 }
7473 klass = mono_class_get_and_inflate_typespec_checked (method->klass->image, token, context, &error);
7475 }
7479 }
7482 mini_get_signature (MonoMethod *method, guint32 token, MonoGenericContext *context, MonoError *error)
7483 {
7492 }
7495 }
7497 }
7501 {
7507 }
7510 }
7512 static void
7514 {
7520 }
7522 /*
7523 * Return the original method is a wrapper is specified. We can only access
7524 * the custom attributes from the original method.
7525 */
7528 {
7532 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
7536 /* in other cases we need to find the original method */
7538 }
7540 static void
7541 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field)
7542 {
7543 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7544 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
7547 }
7549 static void
7550 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
7551 {
7552 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7553 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
7556 }
7558 /*
7559 * Check that the IL instructions at ip are the array initialization
7560 * sequence and return the pointer to the data and the size.
7561 */
7563 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
7564 {
7565 /*
7566 * newarr[System.Int32]
7567 * dup
7568 * ldtoken field valuetype ...
7569 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
7570 */
7572 MonoError error;
7576 guint32 rva;
7581 MonoClassField *field = mono_field_from_token_checked (method->klass->image, field_token, &dummy_class, NULL, &error);
7587 }
7594 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
7601 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
7602 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
7615 #endif
7618 }
7623 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
7628 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
7629 /* for aot code we do the lookup on load */
7633 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
7636 }
7638 }
7640 }
7642 static void
7644 {
7645 MonoError error;
7651 method_code = g_strdup_printf ("could not parse method body due to %s", mono_error_get_message (&error));
7655 else
7657 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code));
7661 }
7663 static void
7665 {
7670 /* Optimize reg-reg moves away */
7671 /*
7672 * Can't optimize other opcodes, since sp[0] might point to
7673 * the last ins of a decomposed opcode.
7674 */
7678 }
7679 }
7681 /*
7682 * ldloca inhibits many optimizations so try to get rid of it in common
7683 * cases.
7684 */
7687 {
7698 }
7700 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
7701 /* From the INITOBJ case */
7708 }
7709 exception_exit:
7711 }
7714 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp)
7715 {
7722 guint32 slot;
7725 /*
7726 * In llvm-only mode, vtables contain function descriptors instead of
7727 * method addresses/trampolines.
7728 */
7733 else
7742 /*
7743 * The simplest case, a normal virtual call.
7744 */
7751 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7754 /* Load the vtable slot, which contains a function descriptor. */
7763 /* Slow path */
7764 // FIXME: Make the wrapper use the preserveall cconv
7765 // FIXME: Use one icall per slot for small slot numbers ?
7768 /* Make the icall return the vtable slot value to save some code space */
7773 /* Fastpath */
7775 /* Load the address + arg from the vtable slot */
7780 }
7783 /*
7784 * A simple interface call
7785 *
7786 * We make a call through an imt slot to obtain the function descriptor we need to call.
7787 * The imt slot contains a function descriptor for a runtime function + arg.
7788 */
7795 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7798 /*
7799 * The slot is already initialized when the vtable is created so there is no need
7800 * to check it here.
7801 */
7803 /* Load the imt slot, which contains a function descriptor. */
7806 /* Load the address + arg of the imt thunk from the imt slot */
7809 /*
7810 * IMT thunks in llvm-only mode are C functions which take an info argument
7811 * plus the imt method and return the ftndesc to call.
7812 */
7816 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_trampoline, icall_args, thunk_addr_ins, NULL, NULL);
7819 }
7822 /*
7823 * This is similar to the interface case, the vtable slot points to an imt thunk which is
7824 * dynamically extended as more instantiations are discovered.
7825 * This handles generic virtual methods both on classes and interfaces.
7826 */
7838 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7841 else
7844 /* Load the slot, which contains a function descriptor. */
7847 /* These slots are not initialized, so fall back to the slow path until they are initialized */
7848 /* That happens when mono_method_add_generic_virtual_invocation () creates an IMT thunk */
7852 /* Fastpath */
7853 /* Same as with iface calls */
7859 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_trampoline, icall_args, thunk_addr_ins, NULL, NULL);
7861 /*
7862 * Unlike normal iface calls, these imt thunks can return NULL, i.e. when they are passed an instantiation
7863 * they don't know about yet. Fall back to the slowpath in that case.
7864 */
7870 /* Slowpath */
7878 else
7883 /* Common case */
7886 }
7888 /*
7889 * Non-optimized cases
7890 */
7904 else
7907 /*
7908 * Pass the extra argument even if the callee doesn't receive it, most
7909 * calling conventions allow this.
7910 */
7912 }
7914 static gboolean
7916 {
7921 }
7923 }
7925 /*
7926 * is_jit_optimizer_disabled:
7927 *
7928 * Determine whenever M's assembly has a DebuggableAttribute with the
7929 * IsJITOptimizerDisabled flag set.
7930 */
7931 static gboolean
7933 {
7934 MonoError error;
7948 /* Linked away */
7953 }
7965 /* Decode the attribute. See reflection.c */
7970 // FIXME: Support named parameters
7972 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
7974 /* Two boolean arguments */
7975 p ++;
7977 }
7979 }
7986 }
7988 static gboolean
7989 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
7990 {
7991 gboolean supported_tail_call;
7994 supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
7997 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
7998 /* These can point to the current method's stack */
8000 }
8002 /* this might point to the current method's stack */
8013 /* Debugging support */
8014 #if 0
8018 }
8019 #endif
8022 }
8024 /*
8025 * handle_ctor_call:
8026 *
8027 * Handle calls made to ctors from NEWOBJ opcodes.
8028 */
8029 static void
8030 handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used,
8032 {
8052 }
8053 }
8054 }
8056 /* Avoid virtual calls to ctors if possible */
8060 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8062 CHECK_CFG_EXCEPTION;
8074 // FIXME-VT: Clean this up
8078 }
8082 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
8085 // FIXME: Avoid initializing vtable_arg
8089 }
8095 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
8099 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8106 }
8111 }
8112 exception_exit:
8114 }
8116 static void
8118 {
8132 }
8134 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8144 }
8145 #else
8147 #endif
8148 }
8149 }
8151 /*
8152 * mono_method_to_ir:
8153 *
8154 * Translate the .net IL into linear IR.
8155 *
8156 * @start_bblock: if not NULL, the starting basic block, used during inlining.
8157 * @end_bblock: if not NULL, the ending basic block, used during inlining.
8158 * @return_var: if not NULL, the place where the return value is stored, used during inlining.
8159 * @inline_args: if not NULL, contains the arguments to the inline call
8160 * @inline_offset: if not zero, the real offset from the inline call, or zero otherwise.
8161 * @is_virtual_call: whether this method is being called as a result of a call to callvirt
8162 *
8163 * This method is used to turn ECMA IL into Mono's internal Linear IR
8164 * reprensetation. It is used both for entire methods, as well as
8165 * inlining existing methods. In the former case, the @start_bblock,
8166 * @end_bblock, @return_var, @inline_args are all set to NULL, and the
8167 * inline_offset is set to zero.
8168 *
8169 * Returns: the inline cost, or -1 if there was an error processing this method.
8170 */
8171 int
8172 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
8175 {
8176 MonoError error;
8195 guint num_args;
8207 /* serialization and xdomain stuff may need access to private fields and methods */
8215 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
8228 }
8241 /* We could hit a seq point before attaching to the JIT (#8338) */
8243 }
8252 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8253 seq_point_set_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8258 }
8260 } else if (!method->wrapper_type && !method->dynamic && mono_debug_image_has_debug_info (method->klass->image)) {
8261 /* Methods without line number info like auto-generated property accessors */
8262 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8263 seq_point_set_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8265 }
8266 }
8268 /*
8269 * Methods without init_locals set could cause asserts in various passes
8270 * (#497220). To work around this, we emit dummy initialization opcodes
8271 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
8272 * on some platforms.
8273 */
8276 else
8283 }
8285 /* SkipVerification is not allowed if core-clr is enabled */
8289 }
8303 }
8311 }
8313 cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
8334 /* ENTRY BLOCK */
8340 /* EXIT BLOCK */
8353 }
8354 /* handle exception clauses */
8367 /*
8368 * Linking the try block with the EH block hinders inlining as we won't be able to
8369 * merge the bblocks from inlining and produce an artificial hole for no good reason.
8370 */
8383 if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FILTER) {
8384 /* finally clauses already have a seq point */
8385 /* seq points for filter clauses are emitted below */
8388 }
8390 /* todo: is a fault block unsafe to optimize? */
8393 }
8395 /*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);
8396 while (p < end) {
8397 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
8398 }*/
8399 /* catch and filter blocks get the exception object on the stack */
8403 /* mostly like handle_stack_args (), but just sets the input args */
8404 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
8411 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
8412 /* The EH code passes in the exception in a register to both JITted and LLVM compiled code */
8417 }
8418 #else
8421 /*
8422 * Add a dummy use for the exvar so its liveness info will be
8423 * correct.
8424 */
8426 #endif
8431 }
8439 /* The filter block shares the exvar with the handler block */
8443 }
8444 }
8450 /*
8451 * In shared generic code with catch
8452 * clauses containing type variables
8453 * the exception handling code has to
8454 * be able to get to the rgctx.
8455 * Therefore we have to make sure that
8456 * the vtable/mrgctx argument (for
8457 * static or generic methods) or the
8458 * "this" argument (for non-static
8459 * methods) are live.
8460 */
8469 }
8470 }
8471 }
8477 }
8479 /* FIRST CODE BLOCK */
8492 }
8493 }
8495 /* we use a separate basic block for the initialization code */
8512 info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
8515 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
8519 /* prevent it from being register allocated */
8520 //var->flags |= MONO_INST_VOLATILE;
8523 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
8526 /* Allocate locals */
8528 /* prevent it from being register allocated */
8529 //locals_var->flags |= MONO_INST_VOLATILE;
8533 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
8542 /*
8543 if (init_locals)
8544 ins->flags |= MONO_INST_INIT;
8545 */
8546 }
8549 /* check if this is native code, e.g. an icall or a p/invoke */
8556 /* if this ia a native call then it can only be JITted from platform code */
8562 }
8563 }
8564 }
8565 }
8566 }
8568 CHECK_CFG_EXCEPTION;
8571 UNVERIFIED;
8575 UNVERIFIED;
8576 }
8583 UNVERIFIED;
8584 }
8587 /* We force the vtable variable here for all shared methods
8588 for the possibility that they might show up in a stack
8589 trace where their exact instantiation is needed. */
8596 /* FIXME: Is there a better way to do this?
8597 We need the variable live for the duration
8598 of the whole method. */
8600 }
8601 }
8603 /* add a check for this != NULL to inlined methods */
8610 }
8615 CHECK_CFG_ERROR;
8617 }
8619 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
8620 stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
8627 else
8639 }
8648 }
8659 }
8667 }
8670 }
8671 }
8689 }
8693 }
8694 }
8695 /*
8696 * Sequence points are points where the debugger can place a breakpoint.
8697 * Currently, we generate these automatically at points where the IL
8698 * stack is empty.
8699 */
8700 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
8701 /*
8702 * Make methods interruptable at the beginning, and at the targets of
8703 * backward branches.
8704 * Also, do this at the start of every bblock in methods with clauses too,
8705 * to be able to handle instructions with inprecise control flow like
8706 * throw/endfinally.
8707 * Backward branches are handled at the end of method-to-ir ().
8708 */
8710 gboolean sym_seq_point = sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code);
8712 /* Avoid sequence points on empty IL like .volatile */
8713 // FIXME: Enable this
8714 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
8722 }
8730 /* TODO: Use an increment here */
8731 #if defined(TARGET_X86)
8736 #else
8739 #endif
8740 }
8743 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8748 /*
8749 * The C# compiler uses these nops to notify the JIT that it should
8750 * insert seq points.
8751 */
8754 }
8757 else
8759 ip++;
8767 }
8768 ip++;
8779 ip++;
8790 ip++;
8802 UNVERIFIED;
8807 }
8834 UNVERIFIED;
8857 }
8863 }
8870 UNVERIFIED;
8933 #ifdef TARGET_POWERPC
8934 /* FIXME: Clean this up */
8937 #endif
8939 /* FIXME: we should really allocate this only late in the compilation process */
8959 }
8965 }
8970 #ifdef TARGET_POWERPC
8971 /* FIXME: Clean this up */
8974 #endif
8976 /* FIXME: we should really allocate this only late in the compilation process */
8996 }
9002 }
9007 sp--;
9022 }
9025 ip++;
9028 #ifdef TARGET_X86
9030 /* we need to pop the value from the x86 FP stack */
9032 #endif
9044 UNVERIFIED;
9046 /* FIXME: check the signature matches */
9048 CHECK_CFG_ERROR;
9064 /*
9065 * The code in mono-basic-block.c treats the rest of the code as dead, but we
9066 * have to emit a normal return since llvm expects it.
9067 */
9077 /* Handle tail calls similarly to calls */
9097 /* Prevent arguments from being optimized away */
9104 }
9109 }
9119 //GSHAREDVT_FAILURE (*ip);
9125 CHECK_CFG_ERROR;
9130 /*
9131 * This is a call through a function pointer using a pinvoke
9132 * signature. Have to create a wrapper and call that instead.
9133 * FIXME: This is very slow, need to create a wrapper at JIT time
9134 * instead based on the signature.
9135 */
9140 }
9146 //g_assert (!virtual_ || fsig->hasthis);
9152 /*
9153 * Making generic calls out of gsharedvt methods.
9154 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9155 * patching gshared method addresses into a gsharedvt method.
9156 */
9158 /*
9159 * We pass the address to the gsharedvt trampoline in the rgctx reg
9160 */
9164 /* Not tested */
9168 // FIXME:
9175 }
9177 /* Prevent inlining of methods with indirect calls */
9180 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
9181 MonoJumpInfoType info_type;
9182 gpointer info_data;
9184 /*
9185 * Instead of emitting an indirect call, emit a direct call
9186 * with the contents of the aotconst as the patch info.
9187 */
9194 }
9197 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR_CALL, info_data, fsig, sp);
9204 }
9205 }
9208 calli_end:
9210 /* End of call, INS should contain the result of the call, if any */
9215 }
9217 CHECK_CFG_EXCEPTION;
9223 }
9255 CHECK_CFG_ERROR;
9260 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9265 }
9266 }
9274 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_class, generic_context, &cfg->error);
9275 CHECK_CFG_ERROR;
9276 }
9281 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9282 /*
9283 * This is needed since get_method_constrained can't find
9284 * the method in klass representing a type var.
9285 * The type var is guaranteed to be a reference type in this
9286 * case.
9287 */
9291 cmethod = mono_get_method_constrained_checked (image, token, constrained_class, generic_context, &cil_method, &cfg->error);
9292 CHECK_CFG_ERROR;
9293 }
9294 }
9295 }
9300 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), &cfg->error);
9301 CHECK_CFG_ERROR;
9302 }
9306 }
9312 /* MS.NET seems to silently convert this to a callvirt */
9315 {
9316 /*
9317 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
9318 * converts to a callvirt.
9319 *
9320 * tests/bug-515884.il is an example of this behavior
9321 */
9322 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
9324 if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
9326 }
9334 LOAD_ERROR;
9338 } else if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && icall_is_direct_callable (cfg, cmethod)) {
9345 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
9346 CHECK_CFG_ERROR;
9347 }
9352 /* See code below */
9353 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9358 /*
9359 * We want to extend the try block to cover the call, but we can't do it if the
9360 * call is made directly since its followed by an exception check.
9361 */
9363 }
9364 }
9371 /* Don't support calls made using type arguments for now */
9372 /*
9373 if (cfg->gsharedvt) {
9374 if (mini_is_gsharedvt_signature (fsig))
9375 GSHAREDVT_FAILURE (*ip);
9376 }
9377 */
9385 UNVERIFIED;
9392 //g_assert (!virtual_ || fsig->hasthis);
9396 /*
9397 * We have the `constrained.' prefix opcode.
9398 */
9401 if ((cmethod->klass != mono_defaults.object_class) && constrained_class->valuetype && cmethod->klass->valuetype) {
9402 /* The 'Own method' case below */
9403 } else if (cmethod->klass->image != mono_defaults.corlib && !mono_class_is_interface (cmethod->klass) && !cmethod->klass->valuetype) {
9404 /* 'The type parameter is instantiated as a reference type' case below. */
9406 ins = handle_constrained_gsharedvt_call (cfg, cmethod, fsig, sp, constrained_class, &emit_widen);
9407 CHECK_CFG_EXCEPTION;
9410 }
9411 }
9416 /*
9417 * The receiver is a valuetype, but the exact type is not known at compile time. This means the
9418 * called method is not known at compile time either. The called method could end up being
9419 * one of the methods on the parent classes (object/valuetype/enum), in which case we need
9420 * to box the receiver.
9421 * A simple solution would be to box always and make a normal virtual call, but that would
9422 * be bad performance wise.
9423 */
9425 /*
9426 * The parent classes implement no generic interfaces, so the called method will be a vtype method, so no boxing neccessary.
9427 */
9429 }
9431 if (!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9432 /* The called method is not virtual, i.e. Object:GetType (), the receiver is a vtype, has to box */
9435 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9436 CHECK_CFG_EXCEPTION;
9442 /*
9443 * Determine at runtime whenever the called method is defined on object/valuetype/enum, and emit a boxing call
9444 * if needed.
9445 * FIXME: It is possible to inline the called method in a lot of cases, i.e. for T_INT,
9446 * the no-box case goes to a method in Int32, while the box case goes to a method in Enum.
9447 */
9448 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9453 box_type = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_BOX_TYPE);
9454 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, box_type->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
9457 /* Non-ref case */
9462 /* Ref case */
9466 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9478 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9481 }
9482 } else if (constrained_class->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9483 /*
9484 * The type parameter is instantiated as a valuetype,
9485 * but that type doesn't override the method we're
9486 * calling, so we need to box `this'.
9487 */
9490 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9491 CHECK_CFG_EXCEPTION;
9495 /*
9496 * The type parameter is instantiated as a reference
9497 * type. We have a managed pointer on the stack, so
9498 * we need to dereference it here.
9499 */
9505 /* Own method */
9507 /* Interface method */
9521 /* Enum implements some interfaces, so treat this as the first case */
9524 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9525 CHECK_CFG_EXCEPTION;
9526 }
9527 }
9529 }
9531 }
9534 UNVERIFIED;
9536 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
9539 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
9543 }
9546 }
9548 /*
9549 * If the callee is a shared method, then its static cctor
9550 * might not get called after the call was patched.
9551 */
9552 if (cfg->gshared && cmethod->klass != method->klass && mono_class_is_ginst (cmethod->klass) && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
9555 }
9565 /* Generic method interface
9566 calls are resolved via a
9567 helper function and don't
9568 need an imt. */
9571 }
9573 /*
9574 * If a shared method calls another
9575 * shared method then the caller must
9576 * have a generic sharing context
9577 * because the magic trampoline
9578 * requires it. FIXME: We shouldn't
9579 * have to force the vtable/mrgctx
9580 * variable here. Instead there
9581 * should be a flag in the cfg to
9582 * request a generic sharing context.
9583 */
9587 }
9597 }
9598 }
9604 /*
9605 * emit_get_rgctx_method () calls mono_class_vtable () so check
9606 * for type load errors before.
9607 */
9610 }
9614 /* !marshalbyref is needed to properly handle generic methods + remoting */
9621 }
9622 }
9629 }
9634 /* Calling virtual generic methods */
9646 /* Prevent inlining of methods that contain indirect calls */
9652 if (cfg->backend->have_generalized_imt_trampoline && cfg->backend->gshared_supported && cmethod->wrapper_type == MONO_WRAPPER_NONE) {
9664 /* FIXME: This should be a managed pointer */
9677 }
9680 }
9682 /*
9683 * Implement a workaround for the inherent races involved in locking:
9684 * Monitor.Enter ()
9685 * try {
9686 * } finally {
9687 * Monitor.Exit ()
9688 * }
9689 * If a thread abort happens between the call to Monitor.Enter () and the start of the
9690 * try block, the Exit () won't be executed, see:
9691 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
9692 * To work around this, we extend such try blocks to include the last x bytes
9693 * of the Monitor.Enter () call.
9694 */
9695 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9699 /*
9700 * Only extend try blocks with a finally, to avoid catching exceptions thrown
9701 * from Monitor.Enter like ArgumentNullException.
9702 */
9704 /* Mark this bblock as needing to be extended */
9706 }
9707 }
9709 /* Conversion to a JIT intrinsic */
9710 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
9714 }
9716 }
9717 CHECK_CFG_ERROR;
9719 /* Inlining */
9721 (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
9728 /* Prevent inlining of methods that call wrappers */
9732 }
9739 /* *sp is already set by inline_method */
9740 sp++;
9742 }
9747 }
9748 }
9750 /* Tail recursion elimination */
9751 if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
9755 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9758 /* keep it simple */
9762 }
9768 }
9778 /* skip the CEE_RET, too */
9783 }
9784 }
9788 /*
9789 * Synchronized wrappers.
9790 * Its hard to determine where to replace a method with its synchronized
9791 * wrapper without causing an infinite recursion. The current solution is
9792 * to add the synchronized wrapper in the trampolines, and to
9793 * change the called method to a dummy wrapper, and resolve that wrapper
9794 * to the real method in mono_jit_compile_method ().
9795 */
9798 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
9800 }
9802 /*
9803 * Making generic calls out of gsharedvt methods.
9804 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9805 * patching gshared method addresses into a gsharedvt method.
9806 */
9807 if (cfg->gsharedvt && (mini_is_gsharedvt_signature (fsig) || cmethod->is_inflated || mono_class_is_ginst (cmethod->klass)) &&
9810 MonoRgctxInfoType info_type;
9813 //if (mono_class_is_interface (cmethod->klass))
9814 //GSHAREDVT_FAILURE (*ip);
9815 // disable for possible remoting calls
9816 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
9819 /* virtual generic call */
9821 /* Same as the virtual generic case above */
9824 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
9827 /* This can happen when we call a fully instantiated iface method */
9831 }
9832 }
9834 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
9839 else
9844 // FIXME: Avoid initializing vtable_arg
9848 }
9850 }
9852 /* Generic sharing */
9854 /*
9855 * Use this if the callee is gsharedvt sharable too, since
9856 * at runtime we might find an instantiation so the call cannot
9857 * be patched (the 'no_patch' code path in mini-trampolines.c).
9858 */
9869 /*
9870 * We are compiling a call to a
9871 * generic method from shared code,
9872 * which means that we have to look up
9873 * the method in the rgctx and do an
9874 * indirect call.
9875 */
9881 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GSHAREDVT_OUT_WRAPPER);
9882 else
9883 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9884 // FIXME: Avoid initializing imt_arg/vtable_arg
9887 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9889 }
9891 }
9893 /* Direct calls to icalls */
9898 /* Inline the wrapper */
9906 /* *sp is already set by inline_method */
9907 sp++;
9909 }
9914 }
9916 /* Array methods */
9930 }
9933 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
9952 }
9956 }
9962 /* Tail prefix / tail call optimization */
9964 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
9965 /* FIXME: runtime generic context pointer for jumps? */
9966 /* FIXME: handle this for generic sharing eventually */
9968 !vtable_arg && !cfg->gshared && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
9974 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9977 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
9980 /* Handle tail calls similarly to normal calls */
9990 /*
9991 * We implement tail calls by storing the actual arguments into the
9992 * argument variables, then emitting a CEE_JMP.
9993 */
9995 /* Prevent argument from being register allocated */
9998 }
10006 // FIXME: Eliminate unreachable epilogs
10008 /*
10009 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
10010 * only reachable from this call.
10011 */
10018 }
10019 }
10021 /*
10022 * Virtual calls in llvm-only mode.
10023 */
10027 }
10029 /* Common call */
10031 ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, virtual_ ? sp [0] : NULL,
10038 // FIXME: Eliminate unreachable epilogs
10040 /*
10041 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
10042 * only reachable from this call.
10043 */
10048 }
10050 call_end:
10052 /* End of call, INS should contain the result of the call, if any */
10058 else
10060 }
10065 /* See mono_emit_method_call_full () */
10067 }
10070 /*
10071 * Clang can convert these calls to tail calls which screw up the stack
10072 * walk. This happens even when the -fno-optimize-sibling-calls
10073 * option is passed to clang.
10074 * Work around this by emitting a dummy call.
10075 */
10077 }
10079 CHECK_CFG_EXCEPTION;
10085 }
10091 }
10094 /* return from inlined method */
10095 /*
10096 * If in_count == 0, that means the ret is unreachable due to
10097 * being preceeded by a throw. In that case, inline_method () will
10098 * handle setting the return value
10099 * (test case: test_0_inline_throw ()).
10100 */
10108 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10109 UNVERIFIED;
10111 //g_assert (returnvar != -1);
10114 }
10125 /*
10126 * Place a seq point here too even through the IL stack is not
10127 * empty, so a step over on
10128 * call <FOO>
10129 * ret
10130 * will work correctly.
10131 */
10134 }
10140 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10141 UNVERIFIED;
10144 }
10145 }
10147 UNVERIFIED;
10149 ip++;
10158 ip++;
10168 }
10186 ip++;
10188 ip++;
10198 ip++;
10209 }
10228 UNVERIFIED;
10229 ip ++;
10233 sp--;
10243 }
10250 #if SIZEOF_REGISTER == 4
10252 /* Convert it to OP_LCOMPARE */
10260 }
10261 #endif
10277 }
10291 ip++;
10309 gboolean use_op_switch;
10317 UNVERIFIED;
10332 }
10335 /*
10336 * Link the current bb with the targets as well, so handle_stack_args
10337 * will set their in_stack correctly.
10338 */
10347 /* Undo the links */
10351 }
10359 table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
10364 #ifdef TARGET_ARM
10365 /* ARM implements SWITCH statements differently */
10366 /* FIXME: Make it use the generic implementation */
10369 #endif
10386 else
10389 #if SIZEOF_REGISTER == 8
10390 /* The upper word might not be zero, and we add it to a 64 bit address later */
10392 #endif
10402 }
10404 /* FIXME: Use load_memindex */
10408 }
10412 }
10440 }
10450 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10452 }
10468 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10470 }
10478 if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !MONO_INS_IS_PCONST_NULL (sp [1]))
10496 /* Use the immediate opcodes if possible */
10505 }
10506 }
10511 ip++;
10536 /* FIXME: Pass opcode to is_inst_imm */
10538 /* Use the immediate opcodes if possible */
10539 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)) {
10544 #if SIZEOF_REGISTER == 8
10546 #else
10549 #endif
10550 }
10551 else
10555 /* Might be followed by an instruction added by add_widen_op */
10558 }
10559 }
10563 ip++;
10580 /* Special case this earlier so we have long constants in the IR */
10585 #if SIZEOF_REGISTER == 8
10588 else
10590 #else
10594 else
10596 #endif
10598 }
10601 }
10602 ip++;
10616 }
10617 ip++;
10629 }
10630 ip++;
10648 CHECK_CFG_EXCEPTION;
10649 ip++;
10659 ip++;
10685 }
10700 /* Optimize the common ldobj+stloc combination */
10715 }
10726 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10728 }
10731 }
10733 /* Optimize the ldobj+stobj combination */
10734 /* The reference case ends up being a load+store anyway */
10735 /* Skip this if the operation is volatile. */
10736 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass) && !(ins_flag & MONO_INST_VOLATILE)) {
10739 sp --;
10746 }
10753 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10755 }
10761 }
10771 }
10778 else
10787 }
10793 CHECK_CFG_ERROR;
10799 /*
10800 * Avoid relocations in AOT and save some space by using a
10801 * version of helper_ldstr specialized to mscorlib.
10802 */
10806 /* Avoid creating the string object */
10810 }
10811 }
10812 else
10817 }
10821 ins->inst_p0 = mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), &cfg->error);
10822 CHECK_CFG_ERROR;
10825 OUT_OF_MEMORY_FAILURE;
10829 }
10830 }
10831 }
10833 sp++;
10839 MonoInst this_ins;
10846 CHECK_CFG_ERROR;
10848 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
10849 CHECK_CFG_ERROR;
10861 if (cfg->gshared && cmethod && cmethod->klass != method->klass && mono_class_is_ginst (cmethod->klass) && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
10864 }
10866 /*
10867 if (cfg->gsharedvt) {
10868 if (mini_is_gsharedvt_variable_signature (sig))
10869 GSHAREDVT_FAILURE (*ip);
10870 }
10871 */
10876 /*
10877 * Generate smaller code for the common newobj <exception> instruction in
10878 * argument checking code.
10879 */
10904 }
10909 }
10911 /* move the args to allow room for 'this' in the first position */
10915 }
10917 /* check_call_signature () requires sp[0] to be set */
10921 UNVERIFIED;
10929 /* Avoid varargs in the common case */
10938 else
10943 /* we simply pass a null pointer */
10945 /* now call the string ctor */
10955 /*
10956 * The code generated by mini_emit_virtual_call () expects
10957 * iargs [0] to be a boxed instance, but luckily the vcall
10958 * will be transformed into a normal call there.
10959 */
10970 /*
10971 * TypeInitializationExceptions thrown from the mono_runtime_class_init
10972 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
10973 * As a workaround, we call class cctors before allocating objects.
10974 */
10975 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
10978 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
10980 }
10984 }
10990 /* Now call the actual ctor */
10992 CHECK_CFG_EXCEPTION;
10993 }
10996 /* Valuetype */
11002 }
11009 }
11019 UNVERIFIED;
11028 CHECK_CFG_EXCEPTION;
11034 }
11064 }
11069 /* LDOBJ */
11073 }
11078 }
11100 }
11103 UNVERIFIED;
11105 UNVERIFIED;
11106 /* frequent check in generic code: box (struct), brtrue */
11108 /*
11109 * Look for:
11110 *
11111 * <push int/long ptr>
11112 * <push int/long>
11113 * box MyFlags
11114 * constrained. MyFlags
11115 * callvirt instace bool class [mscorlib] System.Enum::HasFlag (class [mscorlib] System.Enum)
11116 *
11117 * If we find this sequence and the operand types on box and constrained
11118 * are equal, we can emit a specialized instruction sequence instead of
11119 * the very slow HasFlag () call.
11120 */
11122 /* Cheap checks first. */
11148 }
11149 }
11151 // FIXME: LLVM can't handle the inconsistent bb linking
11166 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11168 }
11174 ip++;
11176 ip++;
11181 ip++;
11187 }
11189 /*
11190 * We need to link both bblocks, since it is needed for handling stack
11191 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
11192 * Branching to only one of them would lead to inconsistencies, so
11193 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
11194 */
11205 }
11214 /* The JIT can't eliminate the iconst+compare */
11218 }
11222 }
11226 CHECK_CFG_EXCEPTION;
11230 }
11253 }
11257 }
11265 #ifndef DISABLE_REMOTING
11267 #endif
11268 guint foffset;
11269 gboolean is_instance;
11272 gboolean is_special_static;
11287 }
11289 UNVERIFIED;
11291 UNVERIFIED;
11295 sp--;
11297 }
11298 }
11305 }
11308 CHECK_CFG_ERROR;
11309 }
11314 /* if the class is Critical then transparent code cannot access it's fields */
11318 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
11319 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
11320 if (mono_security_core_clr_enabled ())
11321 ensure_method_is_allowed_to_access_field (cfg, method, field);
11322 */
11326 /*
11327 * LDFLD etc. is usable on static fields as well, so convert those cases to
11328 * the static case.
11329 */
11343 }
11345 }
11349 /* INSTANCE CASE */
11354 UNVERIFIED;
11355 #ifndef DISABLE_REMOTING
11356 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
11372 CHECK_CFG_EXCEPTION;
11380 }
11382 #endif
11383 {
11389 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11391 }
11399 /* The value is offset by 1 */
11404 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
11408 }
11412 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !MONO_INS_IS_PCONST_NULL (sp [1])) {
11417 /* insert call to write barrier */
11424 }
11425 }
11428 }
11432 }
11434 #ifndef DISABLE_REMOTING
11435 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
11436 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
11444 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
11448 CHECK_CFG_EXCEPTION;
11459 }
11461 #endif
11466 /* Have to compute the address of the variable */
11471 else
11476 }
11482 }
11490 /* The value is offset by 1 */
11495 }
11508 /* The value is offset by 1 */
11515 }
11520 }
11521 }
11527 }
11529 /* STATIC CASE */
11533 mono_error_set_field_load (&cfg->error, field->parent, field->name, "Using static instructions with literal field");
11534 CHECK_CFG_ERROR;
11535 }
11537 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
11538 * to be called here.
11539 */
11543 }
11553 else
11556 /* Generate IR to compute the field address */
11557 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
11558 /*
11559 * Fast access to TLS data
11560 * Inline version of get_thread_static_data () in
11561 * threads.c.
11562 */
11563 guint32 offset;
11570 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
11575 /* For TLS variables, this will return the TLS offset */
11598 }
11611 }
11616 /*
11617 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
11618 method->klass->name_space, method->klass->name, method->name,
11619 depth, field->offset);
11620 */
11625 /*
11626 * The pointer we're computing here is
11627 *
11628 * super_info.static_data + field->offset
11629 */
11637 /* The value is offset by 1 */
11646 }
11666 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
11668 }
11671 /* This makes so that inline cannot trigger */
11672 /* .cctors: too many apps depend on them */
11673 /* running with a specific order... */
11680 }
11681 }
11682 }
11690 }
11695 }
11696 }
11698 /* Generate IR to do the actual load/store operation */
11701 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11703 }
11722 }
11723 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
11724 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
11730 }
11734 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
11740 sp++;
11744 sp++;
11749 sp++;
11753 sp++;
11758 sp++;
11762 sp++;
11770 sp++;
11780 sp++;
11783 }
11788 sp++;
11796 }
11797 }
11808 }
11809 }
11812 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
11814 }
11819 }
11828 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11830 }
11831 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
11836 /* insert call to write barrier */
11838 }
11844 /*
11845 * Array opcodes
11846 */
11851 guint32 field_token;
11871 }
11878 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
11880 /* vtable */
11883 /* array len */
11888 else
11892 /* Decompose now to avoid problems with references to the domainvar */
11901 /* Decompose later since it is needed by abcrem */
11916 /* Needed so mono_emit_load_get_addr () gets called */
11918 }
11919 }
11926 /*
11927 * we inline/optimize the initialization sequence if possible.
11928 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
11929 * for small sizes open code the memcpy
11930 * ensure the rva field is big enough
11931 */
11932 if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, cfg->cbb, 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))) {
11937 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
11939 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
11942 }
11946 }
11949 }
11954 UNVERIFIED;
11960 /* This flag will be inherited by the decomposition */
11965 ip ++;
11973 UNVERIFIED;
11979 /* we need to make sure that this array is exactly the type it needs
11980 * to be for correctness. the wrappers are lax with their usage
11981 * so we need to ignore them here
11982 */
11987 }
12017 }
12018 else
12022 UNVERIFIED;
12027 // FIXME-VT: OP_ICONST optimization
12034 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
12044 }
12048 else
12051 }
12072 }
12073 else
12077 UNVERIFIED;
12083 else
12087 }
12105 }
12109 }
12127 // FIXME:
12130 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12132 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
12140 // FIXME:
12145 }
12146 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
12152 }
12167 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
12175 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
12176 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12177 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12183 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
12184 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12185 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12186 }
12187 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
12195 }
12197 gpointer handle;
12211 }
12214 CHECK_CFG_ERROR;
12215 }
12217 LOAD_ERROR;
12222 /* This case handles ldtoken
12223 of an open type, like for
12224 typeof(Gen<>). */
12227 context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type ((MonoType *)handle));
12232 else
12234 }
12255 }
12276 if (mono_class_get_checked (tclass->image, tclass->type_token, &error) == tclass && !generic_context) {
12277 /* Special case for static synchronized wrappers */
12278 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
12281 /* FIXME: n is not a normal token */
12284 }
12287 }
12289 MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, &cfg->error);
12290 CHECK_CFG_ERROR;
12292 }
12305 MONO_RGCTX_INFO_TYPE);
12314 }
12319 }
12323 }
12324 }
12329 }
12333 UNVERIFIED;
12338 ip++;
12347 /* This can complicate code generation for llvm since the return value might not be defined */
12353 UNVERIFIED;
12354 /* mono_save_seq_point_info () depends on this */
12359 ip++;
12362 /*
12363 * Control will leave the method so empty the stack, otherwise
12364 * the next basic block will start with a nonempty stack.
12365 */
12367 sp--;
12368 }
12380 }
12382 /* empty the stack */
12384 sp--;
12385 }
12387 /*
12388 * If this leave statement is in a catch block, check for a
12389 * pending exception, and rethrow it if necessary.
12390 * We avoid doing this in runtime invoke wrappers, since those are called
12391 * by native code which excepts the wrapper to catch all exceptions.
12392 */
12396 /*
12397 * Use <= in the final comparison to handle clauses with multiple
12398 * leave statements, like in bug #78024.
12399 * The ordering of the exception clauses guarantees that we find the
12400 * innermost clause.
12401 */
12402 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) {
12406 /*
12407 MonoInst *load;
12409 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
12410 */
12416 /*
12417 * Currently, we always rethrow the abort exception, despite the
12418 * fact that this is not correct. See thread6.cs for an example.
12419 * But propagating the abort exception is more important than
12420 * getting the sematics right.
12421 */
12427 }
12428 }
12430 #ifdef ENABLE_LLVM
12432 #endif
12451 /*
12452 * Link the finally bblock with the target, since it will
12453 * conceptually branch there.
12454 */
12458 }
12459 }
12461 }
12473 else
12477 }
12479 /*
12480 * Mono specific opcodes
12481 */
12489 gpointer func;
12510 }
12530 }
12536 }
12538 gpointer ptr;
12549 /* Can't embed random pointers into AOT code */
12552 }
12555 gpointer ptr;
12569 }
12572 gpointer ptr;
12586 }
12590 }
12597 // FIXME:
12603 }
12620 }
12633 /*
12634 * Similar to LDOBJ, but instead load the unmanaged
12635 * representation of the vtype to the stack.
12636 */
12645 {
12660 }
12663 /*
12664 * Same as RET, but return the native representation of a vtype
12665 * to the caller.
12666 */
12682 }
12686 UNVERIFIED;
12695 }
12706 else
12711 }
12730 MonoTlsKey key;
12746 }
12747 }
12753 }
12757 /* It would be easier to call a trampoline, but that would put an
12758 * extra frame on the stack, confusing exception handling. So
12759 * implement it inline using an opcode for now.
12760 */
12763 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12764 /* prevent it from being register allocated */
12766 }
12768 /* Has to use a call inst since it local regalloc expects it */
12782 }
12788 }
12804 }
12812 cfg->orig_domain_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12825 /* AOT code is only used in the root domain */
12829 }
12840 }
12842 /* AOT code is only used in the root domain */
12853 }
12857 /* Restore the original domain */
12863 }
12869 /*
12870 * This is the same as CEE_CALLI, but passes an additional argument
12871 * to the called method in llvmonly mode.
12872 * This is only used by delegate invoke wrappers to call the
12873 * actual delegate method.
12874 */
12887 CHECK_CFG_ERROR;
12900 /*
12901 * The lowest bit of 'arg' determines whenever the callee uses the gsharedvt
12902 * cconv. This is set by mono_init_delegate ().
12903 */
12917 /* Normal case: callee uses a normal cconv, have to add an out wrapper */
12920 /*
12921 * ADDR points to a gsharedvt-out wrapper, have to pass <callee, arg> as an extra arg.
12922 */
12930 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12935 /* Gsharedvt case: callee uses a gsharedvt cconv, no conversion is needed */
12943 /* Caller uses a normal calling conv */
12957 /* Normal case: callee uses a normal cconv, no conversion is needed */
12960 /* Gsharedvt case: callee uses a gsharedvt cconv, have to add an in wrapper */
12965 /*
12966 * ADDR points to a gsharedvt-in wrapper, have to pass <callee, arg> as an extra arg.
12967 */
12975 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12982 }
12984 /* Same as CEE_CALLI */
12986 /*
12987 * We pass the address to the gsharedvt trampoline in the rgctx reg
12988 */
12996 }
12997 }
13002 CHECK_CFG_EXCEPTION;
13008 }
13030 }
13032 }
13038 /* somewhat similar to LDTOKEN */
13041 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
13052 }
13065 /*
13066 * The following transforms:
13067 * CEE_CEQ into OP_CEQ
13068 * CEE_CGT into OP_CGT
13069 * CEE_CGT_UN into OP_CGT_UN
13070 * CEE_CLT into OP_CLT
13071 * CEE_CLT_UN into OP_CLT_UN
13072 */
13081 if ((arg1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((arg1->type == STACK_PTR) || (arg1->type == STACK_OBJ) || (arg1->type == STACK_MP))))
13087 else
13095 /*
13096 * The backends expect the fceq opcodes to do the
13097 * comparison too.
13098 */
13102 }
13107 }
13116 CHECK_CFG_ERROR;
13125 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
13131 /*
13132 * Optimize the common case of ldftn+delegate creation
13133 */
13134 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
13135 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13143 LOAD_ERROR;
13153 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
13154 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
13157 }
13158 }
13160 /* FIXME: SGEN support */
13164 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13165 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, FALSE))) {
13166 sp --;
13168 CHECK_CFG_EXCEPTION;
13170 sp ++;
13172 }
13174 }
13175 }
13176 }
13185 }
13193 CHECK_CFG_ERROR;
13202 /*
13203 * Optimize the common case of ldvirtftn+delegate creation
13204 */
13205 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ) && (ip > header->code && ip [-1] == CEE_DUP)) {
13206 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13215 LOAD_ERROR;
13224 /* FIXME: SGEN support */
13228 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13229 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, is_virtual))) {
13232 CHECK_CFG_EXCEPTION;
13234 sp ++;
13236 }
13238 }
13239 }
13240 }
13250 else
13256 }
13283 UNVERIFIED;
13307 }
13313 }
13321 UNVERIFIED;
13332 UNVERIFIED;
13334 /*
13335 * Inlining this into a loop in a parent could lead to
13336 * stack overflows which is different behavior than the
13337 * non-inlined case, thus disable inlining in this case.
13338 */
13344 /* if size != zero */
13348 //size is zero, so result is NULL
13370 }
13378 UNVERIFIED;
13389 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
13392 }
13395 UNVERIFIED;
13398 }
13401 /* FIXME: record alignment? we can assume 1 for now */
13412 /* Can't inline tail calls at this time */
13425 else
13443 /* Skip optimized paths for volatile operations. */
13444 if ((ip [1] == CEE_CPBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
13446 } else if ((ip [1] == CEE_INITBLK) && !(ins_flag & MONO_INST_VOLATILE) && (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)) {
13447 /* emit_memset only works when val == 0 */
13455 /*
13456 * FIXME: It's unclear whether we should be emitting both the acquire
13457 * and release barriers for cpblk. It is technically both a load and
13458 * store operation, so it seems like that's the sensible thing to do.
13459 *
13460 * FIXME: We emit full barriers on both sides of the operation for
13461 * simplicity. We should have a separate atomic memcpy method instead.
13462 */
13476 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
13478 }
13481 }
13482 }
13487 }
13494 /* we ignore the no-nullcheck for now since we
13495 * really do it explicitly only when doing callvirt->call
13496 */
13505 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
13508 }
13509 }
13514 UNVERIFIED;
13529 }
13531 guint32 val;
13537 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (method->klass->image) && !generic_context) {
13539 CHECK_CFG_ERROR;
13550 }
13555 }
13564 // FIXME:
13567 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
13569 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
13573 }
13584 UNVERIFIED;
13588 UNVERIFIED;
13589 }
13591 }
13594 UNVERIFIED;
13598 UNVERIFIED;
13599 }
13600 }
13602 UNVERIFIED;
13606 /* This could already be set because of inlining, #693905 */
13614 }
13626 }
13629 }
13631 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
13633 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
13635 #endif
13645 }
13646 }
13649 /* Emit initialization for ref vars */
13650 // FIXME: Avoid duplication initialization for IL locals.
13656 }
13657 }
13662 }
13670 /*
13671 * Make seq points at backward branch targets interruptable.
13672 */
13676 }
13678 /* Add a sequence point for method entry/exit events */
13684 }
13686 /*
13687 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
13688 * the code they refer to was dead (#11880).
13689 */
13692 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
13697 }
13698 }
13699 }
13708 else
13714 }
13717 /* get_most_deep_clause () in mini-llvm.c depends on this for inlined bblocks */
13720 }
13721 }
13726 /* Method is too large */
13728 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Method %s is too complex.", mname));
13730 }
13737 mono_error_exit:
13741 exception_exit:
13745 unverified:
13749 cleanup:
13755 else
13757 }
13759 static int
13761 {
13775 }
13778 }
13780 int
13782 {
13827 #if SIZEOF_REGISTER == 8
13830 #endif
13848 #if defined(TARGET_X86) || defined (TARGET_AMD64)
13853 #endif
13854 #if defined(TARGET_AMD64)
13857 #endif
13868 }
13871 }
13873 static int
13875 {
13901 }
13904 }
13906 static int
13908 {
13927 }
13930 }
13932 int
13934 {
13935 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
13936 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13948 #if SIZEOF_REGISTER == 8
13951 #endif
13952 }
13953 #endif
13956 }
13960 {
13961 #if defined(TARGET_X86)
13993 }
13994 #endif
13996 #if defined(TARGET_AMD64)
13997 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
14048 }
14049 #endif
14052 }
14056 {
14057 #if defined(TARGET_X86) || defined(TARGET_AMD64)
14065 }
14066 #endif
14069 }
14073 {
14074 #ifdef TARGET_X86
14075 /* FIXME: This has sign extension issues */
14076 /*
14077 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14078 return OP_X86_COMPARE_MEMBASE8_IMM;
14079 */
14081 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14093 }
14094 #endif
14096 #ifdef TARGET_AMD64
14097 /* FIXME: This has sign extension issues */
14098 /*
14099 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14100 return OP_X86_COMPARE_MEMBASE8_IMM;
14101 */
14105 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14108 /* FIXME: This only works for 32 bit immediates
14109 case OP_COMPARE_IMM:
14110 case OP_LCOMPARE_IMM:
14111 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
14112 return OP_AMD64_COMPARE_MEMBASE_IMM;
14113 */
14122 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14129 }
14130 #endif
14133 }
14137 {
14138 #ifdef TARGET_X86
14139 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14156 }
14157 #endif
14159 #ifdef TARGET_AMD64
14160 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && cfg->backend->ilp32)) {
14174 }
14175 } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32)) {
14190 }
14191 }
14192 #endif
14195 }
14197 int
14199 {
14201 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
14206 #endif
14207 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
14213 #endif
14214 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
14217 #endif
14220 }
14221 }
14223 /**
14224 * mono_handle_global_vregs:
14225 *
14226 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
14227 * for them.
14228 */
14229 void
14231 {
14236 vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
14238 #ifdef MONO_ARCH_SIMD_INTRINSICS
14241 #endif
14243 /* Find local vregs used in more than one bb */
14255 gint32 prev_bb;
14285 }
14287 #if SIZEOF_REGISTER == 4
14288 /* In the LLVM case, the long opcodes are not decomposed */
14290 /*
14291 * Since some instructions reference the original long vreg,
14292 * and some reference the two component vregs, it is quite hard
14293 * to determine when it needs to be global. So be conservative.
14294 */
14296 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14300 }
14302 /*
14303 * Make the component vregs volatile since the optimizations can
14304 * get confused otherwise.
14305 */
14308 }
14309 #endif
14315 /* 0 is a valid block num */
14318 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
14328 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
14329 else
14333 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14336 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
14343 }
14344 }
14346 /* Flag as having been used in more than one bb */
14348 }
14349 }
14350 }
14351 }
14353 /* If a variable is used in only one bblock, convert it into a local vreg */
14364 #if SIZEOF_REGISTER == 8
14366 #endif
14367 #if !defined(TARGET_X86)
14368 /* Enabling this screws up the fp stack on x86 */
14370 #endif
14374 /*
14375 if (var->type == STACK_VTYPE && cfg->gsharedvt && mini_is_gsharedvt_variable_type (var->inst_vtype))
14376 break;
14377 */
14379 /* Arguments are implicitly global */
14380 /* Putting R4 vars into registers doesn't work currently */
14381 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
14382 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 && var != cfg->gsharedvt_info_var && var != cfg->gsharedvt_locals_var && var != cfg->lmf_addr_var) {
14383 /*
14384 * Make that the variable's liveness interval doesn't contain a call, since
14385 * that would cause the lvreg to be spilled, making the whole optimization
14386 * useless.
14387 */
14388 /* This is too slow for JIT compilation */
14389 #if 0
14409 }
14410 }
14415 ins_index ++;
14416 }
14420 }
14421 #endif
14427 }
14429 }
14430 }
14432 /*
14433 * Compress the varinfo and vars tables so the liveness computation is faster and
14434 * takes up less space.
14435 */
14447 #if SIZEOF_REGISTER == 4
14449 /* Modify the two component vars too */
14456 }
14457 #endif
14458 }
14459 pos ++;
14460 }
14461 }
14465 }
14467 /*
14468 * mono_allocate_gsharedvt_vars:
14469 *
14470 * Allocate variables with gsharedvt types to entries in the MonoGSharedVtMethodRuntimeInfo.entries array.
14471 * Initialize cfg->gsharedvt_vreg_to_idx with the mapping between vregs and indexes.
14472 */
14473 void
14475 {
14478 cfg->gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
14486 /* Local */
14492 /* Arg */
14495 }
14496 }
14497 }
14498 }
14500 /**
14501 * mono_spill_global_vars:
14502 *
14503 * Generate spill code for variables which are not allocated to registers,
14504 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
14505 * code is generated which could be optimized by the local optimization passes.
14506 */
14507 void
14509 {
14525 /* FIXME: Move this function to mini.c */
14529 #ifdef MONO_ARCH_SIMD_INTRINSICS
14531 #endif
14533 #if SIZEOF_REGISTER == 4
14534 /* Create MonoInsts for longs */
14561 }
14564 }
14565 }
14566 }
14567 #endif
14570 /* registers need liveness info even for !non refs */
14576 }
14577 }
14579 /* FIXME: widening and truncation */
14581 /*
14582 * As an optimization, when a variable allocated to the stack is first loaded into
14583 * an lvreg, we will remember the lvreg and use it the next time instead of loading
14584 * the variable again.
14585 */
14587 vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
14591 /*
14592 * These arrays contain the first and last instructions accessing a given
14593 * variable.
14594 * Since we emit bblocks in the same order we process them here, and we
14595 * don't split live ranges, these will precisely describe the live range of
14596 * the variable, i.e. the instruction range where a valid value can be found
14597 * in the variables location.
14598 * The live range is computed using the liveness info computed by the liveness pass.
14599 * We can't use vmv->range, since that is an abstract live range, and we need
14600 * one which is instruction precise.
14601 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
14602 */
14603 /* FIXME: Only do this if debugging info is requested */
14609 /* Add spill loads/stores */
14616 /* Clear vreg_to_lvreg array */
14634 /*
14635 * We handle LDADDR here as well, since it can only be decomposed
14636 * when variable addresses are known.
14637 */
14642 /* Happens on SPARC/S390 where vtypes are passed by reference */
14647 }
14653 NOT_IMPLEMENTED;
14655 /* gsharedvt arg passed by ref */
14668 /*
14669 * gsharedvt local.
14670 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
14671 */
14678 /* Mark the instruction used to compute the locals var as used */
14681 /* Load the offset */
14684 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
14690 }
14692 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
14693 /* Load the locals area address */
14696 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
14701 }
14702 /* Compute the address */
14717 }
14721 }
14726 }
14728 /*
14729 * Store opcodes have destbasereg in the dreg, but in reality, it is an
14730 * src register.
14731 * FIXME:
14732 */
14746 else
14756 }
14758 /***************/
14759 /* DREG */
14760 /***************/
14762 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
14776 } 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)) {
14777 /*
14778 * Instead of emitting a load+store, use a _membase opcode.
14779 */
14789 }
14792 guint32 lvreg;
14798 /* Invalidate any previous lvreg for this vreg */
14806 }
14810 #if SIZEOF_REGISTER != 8
14812 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, MONO_LVREG_LS (ins->dreg));
14814 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, MONO_LVREG_MS (ins->dreg));
14817 }
14818 else
14819 #endif
14820 {
14823 /* Try to fuse the store into the instruction itself */
14824 /* FIXME: Add more instructions */
14825 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
14831 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE) || (ins->opcode == OP_RMOVE))) {
14849 // FIXME: The backends expect the base reg to be in inst_basereg
14856 /* printf ("INS: "); mono_print_ins (ins); */
14857 /* Create a store instruction */
14858 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
14860 /* Insert it after the instruction */
14865 /*
14866 * We can't assign ins->dreg to var->dreg here, since the
14867 * sregs could use it. So set a flag, and do it after
14868 * the sregs.
14869 */
14870 if ((!cfg->backend->use_fpstack || ((store_opcode != OP_STORER8_MEMBASE_REG) && (store_opcode != OP_STORER4_MEMBASE_REG))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)))
14872 }
14873 }
14874 }
14879 }
14887 }
14888 }
14890 /************/
14891 /* SREGS */
14892 /************/
14903 guint32 load_opcode;
14907 //mono_inst_set_src_registers (ins, sregs);
14911 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14915 /* var->dreg is a hreg */
14918 }
14921 }
14932 /* The variable is already loaded to an lvreg */
14936 //mono_inst_set_src_registers (ins, sregs);
14938 }
14940 /* Try to fuse the load into the instruction */
14944 //mono_inst_set_src_registers (ins, sregs);
14946 } else if ((srcindex == 1) && (op_to_op_src2_membase (cfg, load_opcode, ins->opcode) != -1)) {
14949 //mono_inst_set_src_registers (ins, sregs);
14956 //printf ("%d ", srcindex); mono_print_ins (ins);
14960 if ((!cfg->backend->use_fpstack || ((load_opcode != OP_LOADR8_MEMBASE) && (load_opcode != OP_LOADR4_MEMBASE))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && !no_lvreg) {
14962 /*
14963 * sreg refers to the value loaded by the load
14964 * emitted below, but we need to use ins->dreg
14965 * since it refers to the store emitted earlier.
14966 */
14968 }
14973 }
14974 }
14977 //mono_inst_set_src_registers (ins, sregs);
14979 #if SIZEOF_REGISTER != 8
14981 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_MS (sreg), var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
14983 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_LS (sreg), var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
14986 }
14987 else
14988 #endif
14989 {
14990 #if SIZEOF_REGISTER == 4
14992 #endif
14996 }
14997 }
15002 }
15004 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
15010 }
15011 }
15012 }
15021 }
15027 }
15030 /* Clear vreg_to_lvreg array */
15037 }
15041 }
15043 /* Extend the live range based on the liveness info */
15049 /* The liveness info is incomplete */
15053 /* Live from at least the first ins of this bb */
15056 }
15059 /* Live at least until the last ins of this bb */
15062 }
15063 }
15064 }
15065 }
15067 /*
15068 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
15069 * by storing the current native offset into MonoMethodVar->live_range_start/end.
15070 */
15071 if (cfg->backend->have_liverange_ops && cfg->compute_precise_live_ranges && cfg->comp_done & MONO_COMP_LIVENESS) {
15081 }
15088 else
15090 }
15091 }
15092 }
15095 /* Nullify if unused */
15098 }
15104 }
15106 static void
15108 {
15116 source = mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, ins->sreg1);
15123 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
15126 else
15128 } else if (!context_used && (mono_class_is_marshalbyref (klass) || mono_class_is_interface (klass))) {
15141 }
15147 else
15149 }
15155 }
15157 void
15159 {
15168 }
15169 }
15170 }
15171 }
15174 /**
15175 * FIXME:
15176 * - use 'iadd' instead of 'int_add'
15177 * - handling ovf opcodes: decompose in method_to_ir.
15178 * - unify iregs/fregs
15179 * -> partly done, the missing parts are:
15180 * - a more complete unification would involve unifying the hregs as well, so
15181 * code wouldn't need if (fp) all over the place. but that would mean the hregs
15182 * would no longer map to the machine hregs, so the code generators would need to
15183 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
15184 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
15185 * fp/non-fp branches speeds it up by about 15%.
15186 * - use sext/zext opcodes instead of shifts
15187 * - add OP_ICALL
15188 * - get rid of TEMPLOADs if possible and use vregs instead
15189 * - clean up usage of OP_P/OP_ opcodes
15190 * - cleanup usage of DUMMY_USE
15191 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
15192 * stack
15193 * - set the stack type and allocate a dreg in the EMIT_NEW macros
15194 * - get rid of all the <foo>2 stuff when the new JIT is ready.
15195 * - make sure handle_stack_args () is called before the branch is emitted
15196 * - when the new IR is done, get rid of all unused stuff
15197 * - COMPARE/BEQ as separate instructions or unify them ?
15198 * - keeping them separate allows specialized compare instructions like
15199 * compare_imm, compare_membase
15200 * - most back ends unify fp compare+branch, fp compare+ceq
15201 * - integrate mono_save_args into inline_method
15202 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
15203 * - handle long shift opts on 32 bit platforms somehow: they require
15204 * 3 sregs (2 for arg1 and 1 for arg2)
15205 * - make byref a 'normal' type.
15206 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
15207 * variable if needed.
15208 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
15209 * like inline_method.
15210 * - remove inlining restrictions
15211 * - fix LNEG and enable cfold of INEG
15212 * - generalize x86 optimizations like ldelema as a peephole optimization
15213 * - add store_mem_imm for amd64
15214 * - optimize the loading of the interruption flag in the managed->native wrappers
15215 * - avoid special handling of OP_NOP in passes
15216 * - move code inserting instructions into one function/macro.
15217 * - try a coalescing phase after liveness analysis
15218 * - add float -> vreg conversion + local optimizations on !x86
15219 * - figure out how to handle decomposed branches during optimizations, ie.
15220 * compare+branch, op_jump_table+op_br etc.
15221 * - promote RuntimeXHandles to vregs
15222 * - vtype cleanups:
15223 * - add a NEW_VARLOADA_VREG macro
15224 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
15225 * accessing vtype fields.
15226 * - get rid of I8CONST on 64 bit platforms
15227 * - dealing with the increase in code size due to branches created during opcode
15228 * decomposition:
15229 * - use extended basic blocks
15230 * - all parts of the JIT
15231 * - handle_global_vregs () && local regalloc
15232 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
15233 * - sources of increase in code size:
15234 * - vtypes
15235 * - long compares
15236 * - isinst and castclass
15237 * - lvregs not allocated to global registers even if used multiple times
15238 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
15239 * meaningful.
15240 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
15241 * - add all micro optimizations from the old JIT
15242 * - put tree optimizations into the deadce pass
15243 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
15244 * specific function.
15245 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
15246 * fcompare + branchCC.
15247 * - create a helper function for allocating a stack slot, taking into account
15248 * MONO_CFG_HAS_SPILLUP.
15249 * - merge r68207.
15250 * - merge the ia64 switch changes.
15251 * - optimize mono_regstate2_alloc_int/float.
15252 * - fix the pessimistic handling of variables accessed in exception handler blocks.
15253 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
15254 * parts of the tree could be separated by other instructions, killing the tree
15255 * arguments, or stores killing loads etc. Also, should we fold loads into other
15256 * instructions if the result of the load is used multiple times ?
15257 * - make the REM_IMM optimization in mini-x86.c arch-independent.
15258 * - LAST MERGE: 108395.
15259 * - when returning vtypes in registers, generate IR and append it to the end of the
15260 * last bb instead of doing it in the epilog.
15261 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
15262 */
15264 /*
15266 NOTES
15267 -----
15269 - When to decompose opcodes:
15270 - earlier: this makes some optimizations hard to implement, since the low level IR
15271 no longer contains the neccessary information. But it is easier to do.
15272 - later: harder to implement, enables more optimizations.
15273 - Branches inside bblocks:
15274 - created when decomposing complex opcodes.
15275 - branches to another bblock: harmless, but not tracked by the branch
15276 optimizations, so need to branch to a label at the start of the bblock.
15277 - branches to inside the same bblock: very problematic, trips up the local
15278 reg allocator. Can be fixed by spitting the current bblock, but that is a
15279 complex operation, since some local vregs can become global vregs etc.
15280 - Local/global vregs:
15281 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
15282 local register allocator.
15283 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
15284 structure, created by mono_create_var (). Assigned to hregs or the stack by
15285 the global register allocator.
15286 - When to do optimizations like alu->alu_imm:
15287 - earlier -> saves work later on since the IR will be smaller/simpler
15288 - later -> can work on more instructions
15289 - Handling of valuetypes:
15290 - When a vtype is pushed on the stack, a new temporary is created, an
15291 instruction computing its address (LDADDR) is emitted and pushed on
15292 the stack. Need to optimize cases when the vtype is used immediately as in
15293 argument passing, stloc etc.
15294 - Instead of the to_end stuff in the old JIT, simply call the function handling
15295 the values on the stack before emitting the last instruction of the bb.
15296 */