| blob | f35ba71f466fa63e6f810ae9312fbb64b2d93471 |
1 /**
2 * \file
3 * Convert CIL to the JIT internal representation
4 *
5 * Author:
6 * Paolo Molaro (lupus@ximian.com)
7 * Dietmar Maurer (dietmar@ximian.com)
8 *
9 * (C) 2002 Ximian, Inc.
10 * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
11 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
12 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
13 */
15 #include <config.h>
16 #include <glib.h>
17 #include <mono/utils/mono-compiler.h>
20 #ifndef DISABLE_JIT
22 #include <signal.h>
24 #ifdef HAVE_UNISTD_H
25 #include <unistd.h>
26 #endif
28 #include <math.h>
29 #include <string.h>
30 #include <ctype.h>
32 #ifdef HAVE_SYS_TIME_H
33 #include <sys/time.h>
34 #endif
36 #ifdef HAVE_ALLOCA_H
37 #include <alloca.h>
38 #endif
40 #include <mono/utils/memcheck.h>
41 #include <mono/metadata/abi-details.h>
42 #include <mono/metadata/assembly.h>
43 #include <mono/metadata/attrdefs.h>
44 #include <mono/metadata/loader.h>
45 #include <mono/metadata/tabledefs.h>
46 #include <mono/metadata/class.h>
47 #include <mono/metadata/class-abi-details.h>
48 #include <mono/metadata/object.h>
49 #include <mono/metadata/exception.h>
50 #include <mono/metadata/exception-internals.h>
51 #include <mono/metadata/opcodes.h>
52 #include <mono/metadata/mono-endian.h>
53 #include <mono/metadata/tokentype.h>
54 #include <mono/metadata/tabledefs.h>
55 #include <mono/metadata/marshal.h>
56 #include <mono/metadata/debug-helpers.h>
57 #include <mono/metadata/debug-internals.h>
58 #include <mono/metadata/gc-internals.h>
59 #include <mono/metadata/security-manager.h>
60 #include <mono/metadata/threads-types.h>
61 #include <mono/metadata/security-core-clr.h>
62 #include <mono/metadata/profiler-private.h>
63 #include <mono/metadata/profiler.h>
64 #include <mono/metadata/monitor.h>
65 #include <mono/utils/mono-memory-model.h>
66 #include <mono/utils/mono-error-internals.h>
67 #include <mono/metadata/mono-basic-block.h>
68 #include <mono/metadata/reflection-internals.h>
69 #include <mono/utils/mono-threads-coop.h>
70 #include <mono/utils/mono-utils-debug.h>
71 #include <mono/utils/mono-logger-internals.h>
72 #include <mono/metadata/verify-internals.h>
73 #include <mono/metadata/icall-decl.h>
90 #define BRANCH_COST 10
91 #define CALL_COST 10
92 /* Used for the JIT */
93 #define INLINE_LENGTH_LIMIT 20
94 /*
95 * The aot and jit inline limits should be different,
96 * since aot sees the whole program so we can let opt inline methods for us,
97 * while the jit only sees one method, so we have to inline things ourselves.
98 */
99 /* Used by LLVM AOT */
100 #define LLVM_AOT_INLINE_LENGTH_LIMIT 30
101 /* Used to LLVM JIT */
102 #define LLVM_JIT_INLINE_LENGTH_LIMIT 100
107 gboolean
109 {
111 }
113 void
115 {
122 }
124 /* These have 'cfg' as an implicit argument */
125 #define INLINE_FAILURE(msg) do { \
126 if ((cfg->method != cfg->current_method) && (cfg->current_method->wrapper_type == MONO_WRAPPER_NONE)) { \
127 inline_failure (cfg, msg); \
128 goto exception_exit; \
129 } \
130 } while (0)
131 #define CHECK_CFG_EXCEPTION do {\
132 if (cfg->exception_type != MONO_EXCEPTION_NONE) \
133 goto exception_exit; \
134 } while (0)
135 #define FIELD_ACCESS_FAILURE(method, field) do { \
136 field_access_failure ((cfg), (method), (field)); \
137 goto exception_exit; \
138 } while (0)
139 #define GENERIC_SHARING_FAILURE(opcode) do { \
140 if (cfg->gshared) { \
141 gshared_failure (cfg, opcode, __FILE__, __LINE__); \
142 goto exception_exit; \
143 } \
144 } while (0)
145 #define GSHAREDVT_FAILURE(opcode) do { \
146 if (cfg->gsharedvt) { \
147 gsharedvt_failure (cfg, opcode, __FILE__, __LINE__); \
148 goto exception_exit; \
149 } \
150 } while (0)
151 #define OUT_OF_MEMORY_FAILURE do { \
152 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
154 goto exception_exit; \
155 } while (0)
156 #define DISABLE_AOT(cfg) do { \
157 if ((cfg)->verbose_level >= 2) \
159 (cfg)->disable_aot = TRUE; \
160 } while (0)
161 #define LOAD_ERROR do { \
162 break_on_unverified (); \
163 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD); \
164 goto exception_exit; \
165 } while (0)
167 #define TYPE_LOAD_ERROR(klass) do { \
168 cfg->exception_ptr = klass; \
169 LOAD_ERROR; \
170 } while (0)
172 #define CHECK_CFG_ERROR do {\
173 if (!is_ok (cfg->error)) { \
174 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
175 goto mono_error_exit; \
176 } \
177 } while (0)
184 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
189 /* helper methods signatures */
191 /* type loading helpers */
192 static GENERATE_TRY_GET_CLASS_WITH_CACHE (debuggable_attribute, "System.Diagnostics", "DebuggableAttribute")
194 static GENERATE_GET_CLASS_WITH_CACHE (geqcomparer, "System.Collections.Generic", "GenericEqualityComparer`1");
196 /*
197 * Instruction metadata
198 */
199 #ifdef MINI_OP
200 #undef MINI_OP
201 #endif
202 #ifdef MINI_OP3
203 #undef MINI_OP3
204 #endif
206 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
212 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == TARGET_SIZEOF_VOID_P
213 #define LREG IREG
214 #else
216 #endif
217 /* keep in sync with the enum in mini.h */
218 const char
219 mini_ins_info[] = {
221 };
222 #undef MINI_OP
223 #undef MINI_OP3
225 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
226 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
227 /*
228 * This should contain the index of the last sreg + 1. This is not the same
229 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
230 */
233 };
234 #undef MINI_OP
235 #undef MINI_OP3
237 guint32
239 {
241 }
243 guint32
245 {
247 }
249 guint32
251 {
253 }
255 guint32
257 {
259 }
261 guint32
263 {
265 }
267 /*
268 * mono_alloc_ireg_ref:
269 *
270 * Allocate an IREG, and mark it as holding a GC ref.
271 */
272 guint32
274 {
276 }
278 /*
279 * mono_alloc_ireg_mp:
280 *
281 * Allocate an IREG, and mark it as holding a managed pointer.
282 */
283 guint32
285 {
287 }
289 /*
290 * mono_alloc_ireg_copy:
291 *
292 * Allocate an IREG with the same GC type as VREG.
293 */
294 guint32
296 {
301 else
303 }
305 guint
307 {
312 handle_enum:
336 #if SIZEOF_REGISTER == 8
338 #else
340 #endif
349 }
365 else
369 }
371 }
373 void
375 {
393 }
395 static MONO_NEVER_INLINE gboolean
397 {
401 }
403 }
405 static void
407 {
410 }
414 {
418 mono_error_set_generic_error (cfg->error, "System", "FieldAccessException", "Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);
421 }
425 {
429 }
433 {
435 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", m_class_get_name_space (cfg->current_method->klass), m_class_get_name (cfg->current_method->klass), cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name (opcode), line);
437 }
441 {
442 cfg->exception_message = g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", m_class_get_name_space (cfg->current_method->klass), m_class_get_name (cfg->current_method->klass), cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), file, line);
446 }
448 void
450 {
454 }
456 /*
457 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
458 * foo<T> (int i) { ldarg.0; box T; }
459 */
460 #define UNVERIFIED do { \
461 if (cfg->gsharedvt) { \
462 if (cfg->verbose_level > 2) \
464 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
465 goto exception_exit; \
466 } \
467 break_on_unverified (); \
468 goto unverified; \
469 } while (0)
471 #define GET_BBLOCK(cfg,tblock,ip) do { \
472 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
473 if (!(tblock)) { \
474 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
475 NEW_BBLOCK (cfg, (tblock)); \
476 (tblock)->cil_code = (ip); \
477 ADD_BBLOCK (cfg, (tblock)); \
478 } \
479 } while (0)
481 /* Emit conversions so both operands of a binary opcode are of the same type */
482 static void
484 {
493 /* Mixing r4/r8 is allowed by the spec */
501 }
509 }
510 }
512 #if SIZEOF_REGISTER == 8
513 /* FIXME: Need to add many more cases */
520 }
521 #endif
522 }
524 #define ADD_BINOP(op) do { \
525 MONO_INST_NEW (cfg, ins, (op)); \
526 sp -= 2; \
527 ins->sreg1 = sp [0]->dreg; \
528 ins->sreg2 = sp [1]->dreg; \
529 type_from_op (cfg, ins, sp [0], sp [1]); \
530 CHECK_TYPE (ins); \
532 add_widen_op (cfg, ins, &sp [0], &sp [1]); \
533 ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
534 MONO_ADD_INS ((cfg)->cbb, (ins)); \
535 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
536 } while (0)
538 #define ADD_UNOP(op) do { \
539 MONO_INST_NEW (cfg, ins, (op)); \
540 sp--; \
541 ins->sreg1 = sp [0]->dreg; \
542 type_from_op (cfg, ins, sp [0], NULL); \
543 CHECK_TYPE (ins); \
544 (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
545 MONO_ADD_INS ((cfg)->cbb, (ins)); \
546 *sp++ = mono_decompose_opcode (cfg, ins); \
547 } while (0)
549 #define ADD_BINCOND(next_block) do { \
550 MonoInst *cmp; \
551 sp -= 2; \
552 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
553 cmp->sreg1 = sp [0]->dreg; \
554 cmp->sreg2 = sp [1]->dreg; \
555 add_widen_op (cfg, cmp, &sp [0], &sp [1]); \
556 type_from_op (cfg, cmp, sp [0], sp [1]); \
557 CHECK_TYPE (cmp); \
558 type_from_op (cfg, ins, sp [0], sp [1]); \
559 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
560 GET_BBLOCK (cfg, tblock, target); \
561 link_bblock (cfg, cfg->cbb, tblock); \
562 ins->inst_true_bb = tblock; \
563 if ((next_block)) { \
564 link_bblock (cfg, cfg->cbb, (next_block)); \
565 ins->inst_false_bb = (next_block); \
566 start_new_bblock = 1; \
567 } else { \
568 GET_BBLOCK (cfg, tblock, next_ip); \
569 link_bblock (cfg, cfg->cbb, tblock); \
570 ins->inst_false_bb = tblock; \
571 start_new_bblock = 2; \
572 } \
573 if (sp != stack_start) { \
574 handle_stack_args (cfg, stack_start, sp - stack_start); \
575 CHECK_UNVERIFIABLE (cfg); \
576 } \
577 MONO_ADD_INS (cfg->cbb, cmp); \
578 MONO_ADD_INS (cfg->cbb, ins); \
579 } while (0)
581 /* *
582 * link_bblock: Links two basic blocks
583 *
584 * links two basic blocks in the control flow graph, the 'from'
585 * argument is the starting block and the 'to' argument is the block
586 * the control flow ends to after 'from'.
587 */
588 static void
590 {
594 #if 0
597 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
598 else
603 else
605 }
606 #endif
613 }
614 }
616 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
619 }
623 }
630 }
631 }
633 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
636 }
640 }
641 }
643 void
645 {
647 }
649 static void
652 static void
654 {
657 //start must exist in cil_offset_to_bb as those are il offsets used by EH which should have GET_BBLOCK early.
663 //no one claimed this bb, take it.
667 }
669 //current region is an early handler, bail
672 }
674 //current region is a try, only overwrite if new region is a handler
677 }
678 }
682 }
684 static void
686 {
698 mark_bb_in_region (cfg, ((i + 1) << 8) | MONO_REGION_FILTER | clause->flags, clause->data.filter_offset, clause->handler_offset);
700 guint handler_region;
705 else
708 mark_bb_in_region (cfg, handler_region, clause->handler_offset, clause->handler_offset + clause->handler_len);
709 mark_bb_in_region (cfg, ((i + 1) << 8) | clause->flags, clause->try_offset, clause->try_offset + clause->try_len);
710 }
716 }
718 }
721 static gboolean
723 {
730 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FAULT)
735 }
737 }
739 /* Find clauses between ip and target, from inner to outer */
742 {
757 }
758 }
760 }
762 static void
764 {
772 /* prevent it from being register allocated */
776 }
778 MonoInst *
780 {
782 }
786 {
794 /* prevent it from being register allocated */
800 }
802 /*
803 * Returns the type used in the eval stack when @type is loaded.
804 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
805 */
806 void
808 {
816 }
818 handle_enum:
862 }
878 }
882 }
883 }
885 /*
886 * The following tables are used to quickly validate the IL code in type_from_op ().
887 */
888 #define IF_P8(v) (SIZEOF_VOID_P == 8 ? v : STACK_INV)
889 #define IF_P8_I8 IF_P8(STACK_I8)
890 #define IF_P8_PTR IF_P8(STACK_PTR)
892 static const char
898 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R8},
902 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4}
903 };
905 static const char
906 neg_table [] = {
908 };
910 /* reduce the size of this table */
911 static const char
921 };
923 #define P1 (SIZEOF_VOID_P == 8)
924 static const char
926 /* Inv i L p F & O vt r4 */
936 };
937 #undef P1
939 /* reduce the size of this table */
940 static const char
950 };
952 /*
953 * Tables to map from the non-specific opcode to the matching
954 * type-specific opcode.
955 */
956 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
957 static const guint16
959 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
960 };
962 /* handles from CEE_NEG to CEE_CONV_U8 */
963 static const guint16
965 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
966 };
968 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
969 static const guint16
971 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
972 };
974 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
975 static const guint16
977 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
978 };
980 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
981 static const guint16
983 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
984 };
986 /* handles from CEE_BEQ to CEE_BLT_UN */
987 static const guint16
989 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
990 };
992 /* handles from CEE_CEQ to CEE_CLT_UN */
993 static const guint16
995 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
996 };
998 /*
999 * Sets ins->type (the type on the eval stack) according to the
1000 * type of the opcode and the arguments to it.
1001 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
1002 *
1003 * FIXME: this function sets ins->type unconditionally in some cases, but
1004 * it should set it to invalid for some types (a conv.x on an object)
1005 */
1006 static void
1008 {
1010 /* binops */
1016 /* FIXME: check unverifiable args for STACK_MP */
1038 if ((src1->type == STACK_I8) || ((TARGET_SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
1044 else
1049 if ((src1->type == STACK_I8) || ((TARGET_SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
1075 /* unops */
1083 else
1107 }
1141 #if TARGET_SIZEOF_VOID_P == 8
1143 #else
1145 #endif
1156 else
1159 }
1232 }
1237 else
1239 }
1240 }
1242 void
1244 {
1246 }
1250 {
1262 case MONO_CEE_LDIND_REF:return mono_defaults.object_class; //FIXME we should try to return a more specific type
1264 }
1265 }
1267 #if 0
1269 static const char
1272 };
1274 static int
1276 {
1287 }
1288 args++;
1289 }
1310 }
1323 }
1324 /*if (!param_table [args [i].type] [sig->params [i]->type])
1325 return 0;*/
1326 }
1328 }
1329 #endif
1331 /*
1332 * When we need a pointer to the current domain many times in a method, we
1333 * call mono_domain_get() once and we store the result in a local variable.
1334 * This function returns the variable that represents the MonoDomain*.
1335 */
1338 {
1340 /* Make sure we don't generate references after checking whenever to init this */
1343 /* Avoid optimizing it away */
1345 }
1347 }
1349 /*
1350 * The got_var contains the address of the Global Offset Table when AOT
1351 * compiling.
1352 */
1353 MonoInst *
1355 {
1360 }
1362 }
1364 static void
1366 {
1369 /* force the var to be stack allocated */
1371 }
1372 }
1376 {
1382 }
1398 }
1400 }
1404 {
1438 else
1443 }
1446 }
1450 {
1484 }
1486 }
1488 /*
1489 * We try to share variables when possible
1490 */
1493 {
1500 /* inlining can result in deeper stacks */
1520 }
1522 }
1524 static void
1526 {
1527 /*
1528 * Don't use this if a generic_context is set, since that means AOT can't
1529 * look up the method using just the image+token.
1530 * table == 0 means this is a reference made from a wrapper.
1531 */
1533 MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1537 }
1538 }
1540 /*
1541 * This function is called to handle items that are left on the evaluation stack
1542 * at basic block boundaries. What happens is that we save the values to local variables
1543 * and we reload them later when first entering the target basic block (with the
1544 * handle_loaded_temps () function).
1545 * A single joint point will use the same variables (stored in the array bb->out_stack or
1546 * bb->in_stack, if the basic block is before or after the joint point).
1547 *
1548 * This function needs to be called _before_ emitting the last instruction of
1549 * the bb (i.e. before emitting a branch).
1550 * If the stack merge fails at a join point, cfg->unverifiable is set.
1551 */
1552 static void
1554 {
1559 gboolean found;
1567 //printf ("bblock %d has out:", bb->block_num);
1571 /* exception handlers are linked, but they should not be considered for stack args */
1574 //printf (" %d", outb->block_num);
1579 }
1580 }
1581 //printf ("\n");
1585 /*
1586 * try to reuse temps already allocated for this purpouse, if they occupy the same
1587 * stack slot and if they are of the same type.
1588 * This won't cause conflicts since if 'local' is used to
1589 * store one of the values in the in_stack of a bblock, then
1590 * the same variable will be used for the same outgoing stack
1591 * slot as well.
1592 * This doesn't work when inlining methods, since the bblocks
1593 * in the inlined methods do not inherit their in_stack from
1594 * the bblock they are inlined to. See bug #58863 for an
1595 * example.
1596 */
1598 }
1599 }
1600 }
1604 /* exception handlers are linked, but they should not be considered for stack args */
1611 }
1613 }
1616 }
1627 }
1629 /*
1630 * It is possible that the out bblocks already have in_stack assigned, and
1631 * the in_stacks differ. In this case, we will store to all the different
1632 * in_stacks.
1633 */
1638 /* Find a bblock which has a different in_stack */
1642 /* exception handlers are linked, but they should not be considered for stack args */
1644 bindex++;
1646 }
1655 }
1659 }
1660 bindex ++;
1661 }
1662 }
1663 }
1665 MonoInst*
1667 {
1671 MONO_DISABLE_WARNING (4306) // 'type cast': conversion from 'MonoJumpInfoType' to 'MonoInst *' of greater size
1673 MONO_RESTORE_WARNING
1675 MonoJumpInfo ji;
1676 gpointer target;
1685 }
1687 }
1691 {
1703 }
1705 }
1709 {
1718 }
1724 /*
1725 * tls getters are critical pieces of code and we don't want to resolve them
1726 * through the standard plt/tramp mechanism since we might expose ourselves
1727 * to crashes and infinite recursions.
1728 * Therefore the NOCALL part of MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL, FALSE in is_plt_patch.
1729 */
1730 EMIT_NEW_AOTCONST (cfg, addr, MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL, GUINT_TO_POINTER (jit_icall_id));
1734 }
1735 }
1737 /*
1738 * emit_push_lmf:
1739 *
1740 * Emit IR to push the current LMF onto the LMF stack.
1741 */
1742 static void
1744 {
1745 /*
1746 * Emit IR to push the LMF:
1747 * lmf_addr = <lmf_addr from tls>
1748 * lmf->lmf_addr = lmf_addr
1749 * lmf->prev_lmf = *lmf_addr
1750 * *lmf_addr = lmf
1751 */
1758 /*
1759 * Store lmf_addr in a variable, so it can be allocated to a global register.
1760 */
1773 /* Save previous_lmf */
1775 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
1776 /* Set new lmf */
1778 }
1780 /*
1781 * emit_pop_lmf:
1782 *
1783 * Emit IR to pop the current LMF from the LMF stack.
1784 */
1785 static void
1787 {
1798 /*
1799 * Emit IR to pop the LMF:
1800 * *(lmf->lmf_addr) = lmf->prev_lmf
1801 */
1802 /* This could be called before emit_push_lmf () */
1808 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
1810 }
1812 /*
1813 * target_type_is_incompatible:
1814 * @cfg: MonoCompile context
1815 *
1816 * Check that the item @arg on the evaluation stack can be stored
1817 * in the target type (can be a local, or field, etc).
1818 * The cfg arg can be used to check if we need verification or just
1819 * validity checks.
1820 *
1821 * Returns: non-0 value if arg can't be stored on a target.
1822 */
1823 static int
1825 {
1830 /* FIXME: check that the pointed to types match */
1832 /* This is needed to handle gshared types + ldaddr. We lower the types so we can handle enums and other typedef-like types. */
1833 MonoClass *target_class_lowered = mono_class_from_mono_type_internal (mini_get_underlying_type (m_class_get_byval_arg (mono_class_from_mono_type_internal (target))));
1834 MonoClass *source_class_lowered = mono_class_from_mono_type_internal (mini_get_underlying_type (m_class_get_byval_arg (arg->klass)));
1836 /* if the target is native int& or X* or same type */
1837 if (target->type == MONO_TYPE_I || target->type == MONO_TYPE_PTR || target_class_lowered == source_class_lowered)
1840 /* Both are primitive type byrefs and the source points to a larger type that the destination */
1841 if (MONO_TYPE_IS_PRIMITIVE_SCALAR (m_class_get_byval_arg (target_class_lowered)) && MONO_TYPE_IS_PRIMITIVE_SCALAR (m_class_get_byval_arg (source_class_lowered)) &&
1842 mono_class_instance_size (target_class_lowered) <= mono_class_instance_size (source_class_lowered))
1845 }
1849 }
1865 /* STACK_MP is needed when setting pinned locals */
1867 #if SIZEOF_VOID_P == 8
1869 #endif
1875 /*
1876 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
1877 * in native int. (#688008).
1878 */
1889 /* FIXME: check type compatibility */
1894 #if SIZEOF_VOID_P == 8
1896 #endif
1928 /* The second cases is needed when doing partial sharing */
1929 if (klass != arg->klass && target_class != arg->klass && target_class != mono_class_from_mono_type_internal (mini_get_underlying_type (m_class_get_byval_arg (arg->klass))))
1935 /* FIXME: check type compatibility */
1937 }
1947 }
1951 }
1953 }
1955 /*
1956 * convert_value:
1957 *
1958 * Emit some implicit conversions which are not part of the .net spec, but are allowed by MS.NET.
1959 */
1962 {
1974 }
1983 }
1987 }
1989 }
1991 /*
1992 * Prepare arguments for passing to a function call.
1993 * Return a non-zero value if the arguments can't be passed to the given
1994 * signature.
1995 * The type checks are not yet complete and some conversions may need
1996 * casts on 32 or 64 bit architectures.
1997 *
1998 * FIXME: implement this using target_type_is_incompatible ()
1999 */
2000 static gboolean
2002 {
2009 args++;
2010 }
2016 }
2018 handle_enum:
2033 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2068 }
2081 /* gsharedvt */
2088 }
2089 }
2091 }
2093 MonoJumpInfo *
2095 {
2103 }
2105 int
2107 {
2110 else
2112 }
2114 int
2116 {
2119 else
2121 }
2123 /*
2124 * check_method_sharing:
2125 *
2126 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2127 */
2128 static void
2129 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2130 {
2141 /*
2142 * Pass vtable iff target method might
2143 * be shared, which means that sharing
2144 * is enabled for its class and its
2145 * context is sharable (and it's not a
2146 * generic method).
2147 */
2148 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2150 }
2155 else
2163 }
2164 }
2170 }
2172 static gboolean
2174 {
2181 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
2182 #ifdef TARGET_AMD64
2185 #endif
2188 }
2190 MonoInst*
2191 mono_emit_jit_icall_by_info (MonoCompile *cfg, int il_offset, MonoJitICallInfo *info, MonoInst **args)
2192 {
2193 /*
2194 * Call the jit icall without a wrapper if possible.
2195 * The wrapper is needed to be able to do stack walks for asynchronously suspended
2196 * threads when debugging.
2197 */
2204 }
2206 /*
2207 * Inline the wrapper method, which is basically a call to the C icall, and
2208 * an exception check.
2209 */
2216 }
2218 }
2222 {
2227 /*
2228 * Native code might return non register sized integers
2229 * without initializing the upper bits.
2230 */
2246 }
2255 }
2256 }
2257 }
2260 }
2266 static void
2268 {
2270 args [0] = emit_get_rgctx_method (cfg, mono_method_check_context_used (caller), caller, MONO_RGCTX_INFO_METHOD);
2271 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (callee), callee, MONO_RGCTX_INFO_METHOD);
2273 }
2275 static void
2277 {
2279 }
2283 {
2286 method = mono_class_get_method_from_name_checked (klass, method_name, num_params, flags, error);
2290 }
2292 MonoMethod*
2294 {
2300 }
2302 }
2304 MonoInst*
2306 {
2309 /*
2310 * Add a release memory barrier so the object contents are flushed
2311 * to memory before storing the reference into another object.
2312 */
2320 }
2322 void
2324 {
2326 target_mgreg_t card_table_mask;
2335 //method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !MONO_INS_IS_PCONST_NULL (sp [1])
2341 if (cfg->backend->have_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
2353 /*
2354 * We emit a fast light weight write barrier. This always marks cards as in the concurrent
2355 * collector case, so, for the serial collector, it might slightly slow down nursery
2356 * collections. We also expect that the host system and the target system have the same card
2357 * table configuration, which is the case if they have the same pointer size.
2358 */
2364 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
2365 * IMM's larger than 32bits.
2366 */
2375 }
2378 }
2380 MonoMethod*
2382 {
2388 }
2390 }
2392 void
2394 {
2397 guint32 align;
2403 /* FIXME: Optimize this for the case when dest is an LDADDR */
2413 mini_emit_calli (cfg, mono_method_signature_internal (bzero_method), iargs, bzero_ins, NULL, NULL);
2415 }
2417 klass = mono_class_from_mono_type_internal (mini_get_underlying_type (m_class_get_byval_arg (klass)));
2423 }
2430 }
2431 }
2433 static gboolean
2435 {
2436 /* gshared dim methods use an mrgctx */
2440 }
2442 /*
2443 * emit_get_rgctx:
2444 *
2445 * Emit IR to return either the this pointer for instance method,
2446 * or the mrgctx for static methods.
2447 */
2450 {
2467 }
2486 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2488 }
2496 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this_ins->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2498 }
2499 }
2502 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
2503 {
2504 MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
2507 else
2516 }
2520 {
2524 // FIXME: No fastpath since the slot is not a compile time constant
2529 else
2532 #if 0
2533 /*
2534 * FIXME: This can be called during decompose, which is a problem since it creates
2535 * new bblocks.
2536 * Also, the fastpath doesn't work since the slot number is dynamically allocated.
2537 */
2539 gboolean mrgctx;
2556 }
2566 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, rgctx_reg, rgctx->dreg, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
2567 // FIXME: Avoid this check by allocating the table when the vtable is created etc.
2572 }
2577 /* load ptr to next array */
2579 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
2580 else
2583 /* is the ptr null? */
2585 /* if yes, jump to actual trampoline */
2587 }
2589 /* fetch slot */
2592 /* is the slot null? */
2594 /* if yes, jump to actual trampoline */
2597 /* Fastpath */
2606 /* Slowpath */
2612 else
2623 #endif
2624 }
2626 /*
2627 * emit_rgctx_fetch:
2628 *
2629 * Emit IR to load the value of the rgctx entry ENTRY from the rgctx
2630 * given by RGCTX.
2631 */
2634 {
2637 else
2638 return mini_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, mono_icall_sig_ptr_ptr, &rgctx);
2639 }
2641 /*
2642 * mini_emit_get_rgctx_klass:
2643 *
2644 * Emit IR to load the property RGCTX_TYPE of KLASS. If context_used is 0, emit
2645 * normal constants, else emit a load from the rgctx.
2646 */
2647 MonoInst*
2650 {
2660 }
2661 }
2663 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_CLASS, klass, rgctx_type);
2667 }
2672 {
2673 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_SIGNATURE, sig, rgctx_type);
2677 }
2682 {
2687 call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
2691 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_GSHAREDVT_CALL, call_info, rgctx_type);
2695 }
2697 /*
2698 * emit_get_rgctx_virt_method:
2699 *
2700 * Return data for method VIRT_METHOD for a receiver of type KLASS.
2701 */
2705 {
2710 info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
2714 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_VIRT_METHOD, info, rgctx_type);
2718 }
2723 {
2727 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_GSHAREDVT_METHOD, info, MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO);
2731 }
2733 /*
2734 * emit_get_rgctx_method:
2735 *
2736 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2737 * normal constants, else emit a load from the rgctx.
2738 */
2742 {
2761 }
2763 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_METHODCONST, cmethod, rgctx_type);
2767 }
2768 }
2773 {
2774 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_FIELD, field, rgctx_type);
2778 }
2780 MonoInst*
2783 {
2785 }
2787 static int
2789 {
2799 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
2801 }
2807 new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
2809 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
2812 }
2822 }
2824 /*
2825 * emit_get_gsharedvt_info:
2826 *
2827 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
2828 */
2831 {
2836 /* Load info->entries [idx] */
2838 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * TARGET_SIZEOF_VOID_P));
2841 }
2843 MonoInst*
2844 mini_emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
2845 {
2847 }
2849 /*
2850 * On return the caller must check @klass for load errors.
2851 */
2852 static void
2854 {
2868 }
2871 }
2876 /*
2877 * Using an opcode instead of emitting IR here allows the hiding of the call inside the opcode,
2878 * so this doesn't have to clobber any regs and it doesn't break basic blocks.
2879 */
2889 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, inited_reg, vtable_arg->dreg, MONO_STRUCT_OFFSET (MonoVTable, initialized));
2899 }
2900 }
2902 static void
2903 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
2904 {
2913 }
2914 }
2916 void
2918 {
2930 }
2936 }
2938 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2939 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
2941 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
2943 MonoInst *class_ins = mini_emit_get_rgctx_klass (cfg, mini_class_check_context_used (cfg, klass), klass, MONO_RGCTX_INFO_KLASS);
2944 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), class_ins->dreg);
2948 }
2949 }
2951 void
2953 {
2954 /* Reset the variables holding the cast details */
2957 /* It is enough to reset the from field */
2958 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
2959 }
2960 }
2962 /*
2963 * On return the caller must check @array_class for load errors
2964 */
2965 static void
2967 {
2975 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2981 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
2987 vtable_ins = mini_emit_get_rgctx_klass (cfg, context_used, array_class, MONO_RGCTX_INFO_VTABLE);
2997 }
3006 }
3008 }
3009 }
3014 }
3016 /**
3017 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3018 * generic code is generated.
3019 */
3022 {
3027 else
3034 /* FIXME: What if the class is shared? We might not
3035 have to get the address of the method from the
3036 RGCTX. */
3039 MONO_RGCTX_INFO_METHOD_FTNDESC);
3040 cfg->signatures = g_slist_prepend_mempool (cfg->mempool, cfg->signatures, mono_method_signature_internal (method));
3044 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3047 return mini_emit_calli (cfg, mono_method_signature_internal (method), &val, addr, NULL, rgctx);
3048 }
3061 }
3064 }
3065 }
3069 {
3078 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3079 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
3081 /* FIXME: generics */
3084 // Check rank == 0
3088 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3094 /* This assertion is from the unboxcast insn */
3106 }
3108 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, MONO_ABI_SIZEOF (MonoObject));
3114 }
3118 {
3126 /* obj */
3129 /* klass */
3132 /* CASTCLASS */
3142 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
3145 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
3148 /* Non-ref case */
3149 /* UNBOX */
3155 /* Ref case */
3158 /* Save the ref to a temporary */
3165 /* Nullable case */
3168 {
3169 MonoInst *addr = mini_emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
3173 unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
3180 else
3185 }
3189 /* End */
3192 /* LDOBJ */
3196 }
3198 /*
3199 * Returns NULL and set the cfg exception on error.
3200 */
3203 {
3205 MonoJitICallId alloc_ftn;
3213 }
3217 MonoRgctxInfoType rgctx_info;
3221 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (klass, for_box, known_instance_size);
3225 else
3236 }
3245 }
3247 }
3250 }
3257 } else if (cfg->compile_aot && cfg->cbb->out_of_line && m_class_get_type_token (klass) && m_class_get_image (klass) == mono_defaults.corlib && !mono_class_is_ginst (klass)) {
3258 /* This happens often in argument checking code, eg. throw new FooException... */
3259 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3268 }
3280 }
3283 }
3286 }
3288 /*
3289 * Returns NULL and set the cfg exception on error.
3290 */
3291 MonoInst*
3293 {
3297 mono_error_set_bad_image (cfg->error, m_class_get_image (cfg->method->klass), "Cannot box IsByRefLike type '%s.%s'", m_class_get_name_space (klass), m_class_get_name (klass));
3300 }
3308 MONO_RGCTX_INFO_METHOD_FTNDESC);
3311 /* FIXME: What if the class is shared? We might not
3312 have to get the method address from the RGCTX. */
3314 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3317 return mini_emit_calli (cfg, mono_method_signature_internal (method), &val, addr, NULL, rgctx);
3318 }
3331 }
3334 }
3335 }
3351 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
3354 /* Non-ref case */
3358 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (klass), alloc->dreg, MONO_ABI_SIZEOF (MonoObject), val->dreg);
3366 /* Ref case */
3369 /* val is a vtype, so has to load the value manually */
3372 src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (klass), OP_LOCAL, val->dreg);
3377 /* Nullable case */
3380 {
3382 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
3386 /*
3387 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
3388 * construct that method at JIT time, so have to do things by hand.
3389 */
3390 box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
3397 else
3402 }
3409 }
3415 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (klass), alloc->dreg, MONO_ABI_SIZEOF (MonoObject), val->dreg);
3417 }
3419 static gboolean
3421 {
3425 }
3427 }
3429 G_GNUC_UNUSED MonoInst*
3430 mini_handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, int enum_val_reg, MonoInst *enum_flag)
3431 {
3434 gboolean is_i4;
3439 #if SIZEOF_REGISTER == 8
3442 #endif
3448 }
3450 {
3461 }
3473 }
3476 }
3477 }
3482 {
3487 info = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
3492 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->method, context_used_is_mrgctx (cfg, context_used), MONO_PATCH_INFO_DELEGATE_TRAMPOLINE, info, rgctx_type);
3496 }
3499 /*
3500 * Returns NULL and set the cfg exception on error.
3501 */
3503 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int target_method_context_used, int invoke_context_used, gboolean virtual_)
3504 {
3507 gpointer trampoline;
3516 //FIXME verify & fix any issue with removing invoke_context_used restriction
3517 if (invoke_context_used || !mono_get_delegate_virtual_invoke_impl (mono_method_signature_internal (invoke), target_method_context_used ? NULL : method))
3519 }
3525 /* Inline the contents of mono_delegate_ctor */
3527 /* Set target field */
3528 /* Optimize away setting of NULL target */
3533 }
3536 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3539 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
3541 }
3542 }
3544 /* Set method field */
3546 //If compiling with gsharing enabled, it's faster to load method the delegate trampoline info than to use a rgctx slot
3547 MonoInst *method_ins = emit_get_rgctx_method (cfg, target_method_context_used, method, MONO_RGCTX_INFO_METHOD);
3548 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3549 }
3551 /*
3552 * To avoid looking up the compiled code belonging to the target method
3553 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3554 * store it, and we fill it after the method has been compiled.
3555 */
3560 code_slot_ins = emit_get_rgctx_method (cfg, target_method_context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3566 code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
3570 }
3574 }
3575 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3576 }
3581 obj,
3582 target,
3584 };
3588 }
3591 }
3593 tramp_ins = emit_get_rgctx_dele_tramp (cfg, target_method_context_used | invoke_context_used, klass, method, virtual_, MONO_RGCTX_INFO_DELEGATE_TRAMP_INFO);
3595 //This is emited as a contant store for the non-shared case.
3596 //We copy from the delegate trampoline info as it's faster than a rgctx fetch
3598 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method));
3599 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), dreg);
3603 del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
3611 else
3614 }
3616 /* Set invoke_impl field */
3618 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3621 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
3622 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
3625 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
3626 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
3627 }
3631 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
3633 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3636 }
3638 /*
3639 * handle_constrained_gsharedvt_call:
3640 *
3641 * Handle constrained calls where the receiver is a gsharedvt type.
3642 * Return the instruction representing the call. Set the cfg exception on failure.
3643 */
3645 handle_constrained_gsharedvt_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, MonoClass *constrained_class,
3647 {
3650 gboolean supported;
3652 /*
3653 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
3654 * 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
3655 * pack the arguments into an array, and do the rest of the work in in an icall.
3656 */
3657 supported = ((cmethod->klass == mono_defaults.object_class) || mono_class_is_interface (cmethod->klass) || (!m_class_is_valuetype (cmethod->klass) && m_class_get_image (cmethod->klass) != mono_defaults.corlib));
3659 supported = (MONO_TYPE_IS_VOID (fsig->ret) || MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_IS_REFERENCE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret) || m_class_is_enumtype (mono_class_from_mono_type_internal (fsig->ret)) || mini_is_gsharedvt_type (fsig->ret));
3664 /* Allow scalar parameters and a gsharedvt first parameter */
3665 supported = MONO_TYPE_IS_PRIMITIVE (fsig->params [0]) || MONO_TYPE_IS_REFERENCE (fsig->params [0]) || fsig->params [0]->byref || mini_is_gsharedvt_type (fsig->params [0]);
3668 if (!(fsig->params [i]->byref || MONO_TYPE_IS_PRIMITIVE (fsig->params [i]) || MONO_TYPE_IS_REFERENCE (fsig->params [i]) || MONO_TYPE_ISSTRUCT (fsig->params [i])))
3670 }
3671 }
3672 }
3673 }
3677 /*
3678 * This case handles calls to
3679 * - object:ToString()/Equals()/GetHashCode(),
3680 * - System.IComparable<T>:CompareTo()
3681 * - System.IEquatable<T>:Equals ()
3682 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
3683 */
3686 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
3687 args [2] = mini_emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_class), constrained_class, MONO_RGCTX_INFO_KLASS);
3689 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
3691 /* Call mono_gsharedvt_constrained_call (gpointer mp, MonoMethod *cmethod, MonoClass *klass, gboolean deref_arg, gpointer *args) */
3692 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
3699 /* Only the first argument is allowed to be gsharedvt */
3700 /* args [3] = deref_arg */
3703 ins = mini_emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type_internal (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
3705 /* deref_arg = BOX_TYPE != MONO_GSHAREDVT_BOX_TYPE_VTYPE */
3709 }
3714 if (mini_is_gsharedvt_type (fsig->params [i]) || MONO_TYPE_IS_PRIMITIVE (fsig->params [i]) || MONO_TYPE_ISSTRUCT (fsig->params [i])) {
3717 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, args [4]->dreg, i * sizeof (target_mgreg_t), addr_reg);
3719 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, args [4]->dreg, i * sizeof (target_mgreg_t), sp [i + 1]->dreg);
3720 }
3721 }
3725 }
3731 } else if (MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret) || m_class_is_enumtype (mono_class_from_mono_type_internal (fsig->ret))) {
3734 /* Unbox */
3735 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, MONO_ABI_SIZEOF (MonoObject));
3737 /* Load value */
3740 /* ins represents the call result */
3741 }
3744 }
3750 exception_exit:
3752 }
3754 static void
3756 {
3766 /* Add it to the start of the first bblock */
3770 }
3771 else
3776 /*
3777 * Add a dummy use to keep the got_var alive, since real uses might
3778 * only be generated by the back ends.
3779 * Add it to end_bblock, so the variable's lifetime covers the whole
3780 * method.
3781 * It would be better to make the usage of the got var explicit in all
3782 * cases when the backend needs it (i.e. calls, throw etc.), so this
3783 * wouldn't be needed.
3784 */
3787 }
3789 static gboolean
3791 {
3792 // FIXME: Under netcore, these are decorated with the [DoesNotReturn] attribute
3797 }
3802 static gboolean
3804 {
3805 MonoMethodHeaderSummary header;
3808 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
3811 #endif
3824 /*runtime, icall and pinvoke are checked by summary call*/
3832 /* Used to mark methods containing StackCrawlMark locals */
3835 /* also consider num_locals? */
3836 /* Do the size check early to avoid creating vtables */
3848 }
3850 }
3852 #ifdef ENABLE_NETCORE
3856 else
3860 }
3861 #else
3864 else
3866 #endif
3867 if (header.code_size >= limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
3870 /*
3871 * if we can initialize the class of the method right away, we do,
3872 * otherwise we don't allow inlining if the class needs initialization,
3873 * since it would mean inserting a call to mono_runtime_class_init()
3874 * inside the inlined code
3875 */
3876 if (cfg->gshared && m_class_has_cctor (method->klass) && mini_class_check_context_used (cfg, method->klass))
3880 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
3888 }
3893 }
3894 }
3895 }
3899 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3901 /* No vtable created yet */
3907 }
3908 /* This makes so that inline cannot trigger */
3909 /* .cctors: too many apps depend on them */
3910 /* running with a specific order... */
3916 }
3917 }
3921 /* No vtable created yet */
3927 }
3930 }
3932 /*
3933 * If we're compiling for shared code
3934 * the cctor will need to be run at aot method load time, for example,
3935 * or at the end of the compilation of the inlining method.
3936 */
3937 if (mono_class_needs_cctor_run (method->klass, NULL) && !mono_class_is_before_field_init (method->klass))
3939 }
3941 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
3943 /* FIXME: */
3949 }
3950 #endif
3965 }
3967 static gboolean
3968 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
3969 {
3974 }
3979 }
3985 /* The initialization is already done before the method is called */
3989 }
3991 int
3993 {
3997 #if SIZEOF_REGISTER == 8
3998 /* The array reg is 64 bits but the index reg is only 32 */
4000 /*
4001 * abcrem can't handle the OP_SEXT_I4, so add this after abcrem,
4002 * during OP_BOUNDS_CHECK decomposition, and in the implementation
4003 * of OP_X86_LEA for llvm.
4004 */
4009 }
4010 #else
4016 }
4017 #endif
4020 }
4022 MonoInst*
4023 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
4024 {
4026 guint32 size;
4035 }
4045 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4049 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
4054 }
4055 #endif
4062 /* gsharedvt */
4066 rgctx_ins = mini_emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE);
4070 }
4072 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
4078 }
4081 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
4082 {
4096 guint32 size;
4104 #if SIZEOF_REGISTER == 8
4105 /* The array reg is 64 bits but the index reg is only 32 */
4107 /* Not needed */
4115 }
4116 #else
4117 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
4118 #endif
4120 /* range checking */
4144 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
4151 }
4154 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, guchar *ip, gboolean is_set)
4155 {
4167 /* emit_ldelema_2 depends on OP_LMUL */
4168 if (!cfg->backend->emulate_mul_div && rank == 2 && (cfg->opt & MONO_OPT_INTRINS) && !mini_is_gsharedvt_variable_klass (eclass)) {
4170 }
4174 else
4180 }
4182 static gboolean
4184 {
4186 }
4188 MonoInst*
4189 mini_emit_array_store (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, gboolean safety_checks)
4190 {
4217 // FIXME-VT: OP_ICONST optimization
4219 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (klass), addr->dreg, 0, sp [2]->dreg);
4224 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
4231 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (klass), array_reg, offset, sp [2]->dreg);
4236 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (klass), addr->dreg, 0, sp [2]->dreg);
4239 }
4241 }
4242 }
4244 MonoInst*
4246 {
4253 }
4255 /*
4256 * This entry point could be used later for arbitrary method
4257 * redirection.
4258 */
4262 {
4264 /* managed string allocation support */
4271 #ifndef MONO_CROSS_COMPILE
4273 #endif
4279 }
4280 }
4282 }
4284 static void
4286 {
4291 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4293 /*
4294 * FIXME: We should use *args++ = sp [0], but that would mean the arg
4295 * would be different than the MonoInst's used to represent arguments, and
4296 * the ldelema implementation can't deal with that.
4297 * Solution: When ldelema is used on an inline argument, create a var for
4298 * it, emit ldelema on that var, and emit the saving code below in
4299 * inline_method () if needed.
4300 */
4303 /* This uses cfg->args [i] which is set by the preceeding line */
4306 sp++;
4307 }
4308 }
4310 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4311 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4313 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4314 static gboolean
4316 {
4325 else
4327 }
4335 //return (strncmp_result <= 0);
4339 }
4340 }
4341 #endif
4343 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4344 static gboolean
4346 {
4356 }
4357 }
4365 //return (strncmp_result <= 0);
4369 }
4370 }
4371 #endif
4373 static void
4375 {
4409 }
4410 }
4412 static void
4414 {
4437 }
4438 }
4440 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
4441 static void
4443 {
4453 else
4455 }
4456 }
4458 int
4459 mini_inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, guchar *ip, guint real_offset, gboolean inline_always)
4460 {
4462 }
4464 /*
4465 * inline_method:
4466 *
4467 * Return the cost of inlining CMETHOD, or zero if it should not be inlined.
4468 */
4469 static int
4470 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4472 {
4480 guint prev_real_offset;
4486 guint32 prev_cil_offset_to_bb_len;
4493 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4496 #endif
4497 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4500 #endif
4506 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4511 }
4513 /* allocate local variables */
4521 }
4523 }
4525 /*Must verify before creating locals as it can cause the JIT to assert.*/
4529 }
4531 /* allocate space to store the return value */
4534 }
4537 cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
4541 /* allocate start and end blocks */
4542 /* This is needed so if the inline is aborted, we can clean up */
4589 if ((costs >= 0 && costs < 60) || inline_always || (costs >= 0 && (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))) {
4591 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4597 /* always add some code to avoid block split failures */
4604 /*
4605 * Get rid of the begin and end bblocks if possible to aid local
4606 * optimizations.
4607 */
4611 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4620 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4623 }
4625 /* There could be a bblock after 'prev', and making 'prev' the current bb could cause problems */
4627 }
4629 /*
4630 * Its possible that the rvar is set in some prev bblock, but not in others.
4631 * (#1835).
4632 */
4643 }
4644 }
4645 }
4648 }
4651 /*
4652 * If the inlined method contains only a throw, then the ret var is not
4653 * set, so set it to a dummy value.
4654 */
4660 }
4666 printf ("INLINE ABORTED %s (cost %d) %s\n", mono_method_full_name (cmethod, TRUE), costs, msg ? msg : "");
4667 }
4672 /* This gets rid of the newly added bblocks */
4674 }
4677 }
4679 /*
4680 * Some of these comments may well be out-of-date.
4681 * Design decisions: we do a single pass over the IL code (and we do bblock
4682 * splitting/merging in the few cases when it's required: a back jump to an IL
4683 * address that was not already seen as bblock starting point).
4684 * Code is validated as we go (full verification is still better left to metadata/verify.c).
4685 * Complex operations are decomposed in simpler ones right away. We need to let the
4686 * arch-specific code peek and poke inside this process somehow (except when the
4687 * optimizations can take advantage of the full semantic info of coarse opcodes).
4688 * All the opcodes of the form opcode.s are 'normalized' to opcode.
4689 * MonoInst->opcode initially is the IL opcode or some simplification of that
4690 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4691 * opcode with value bigger than OP_LAST.
4692 * At this point the IR can be handed over to an interpreter, a dumb code generator
4693 * or to the optimizing code generator that will translate it to SSA form.
4694 *
4695 * Profiling directed optimizations.
4696 * We may compile by default with few or no optimizations and instrument the code
4697 * or the user may indicate what methods to optimize the most either in a config file
4698 * or through repeated runs where the compiler applies offline the optimizations to
4699 * each method and then decides if it was worth it.
4700 */
4702 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4703 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4704 #define CHECK_STACK_OVF() if (((sp - stack_start) + 1) > header->max_stack) UNVERIFIED
4705 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4706 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4707 #define CHECK_OPSIZE(size) if ((size) < 1 || ip + (size) > end) UNVERIFIED
4708 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4709 #define CHECK_TYPELOAD(klass) if (!(klass) || mono_class_has_failure (klass)) TYPE_LOAD_ERROR ((klass))
4711 /* offset from br.s -> br like opcodes */
4712 #define BIG_BRANCH_OFFSET 13
4714 static gboolean
4716 {
4720 }
4722 static int
4723 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, guchar *start, guchar *end, guchar **pos)
4724 {
4728 guint cli_addr;
4736 UNVERIFIED;
4740 ip++;
4775 guint32 j;
4785 }
4787 }
4794 }
4799 /* Find the start of the bblock containing the throw */
4803 bb_start --;
4804 }
4807 }
4808 }
4810 unverified:
4811 exception_exit:
4814 }
4817 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error)
4818 {
4827 }
4830 }
4833 }
4836 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4837 {
4839 MonoMethod *method = mini_get_method_allow_open (m, token, klass, context, cfg ? cfg->error : error);
4841 if (method && cfg && !cfg->gshared && mono_class_is_open_constructed_type (m_class_get_byval_arg (method->klass))) {
4842 mono_error_set_bad_image (cfg->error, m_class_get_image (cfg->method->klass), "Method with open type while not compiling gshared");
4844 }
4850 }
4853 mini_get_signature (MonoMethod *method, guint32 token, MonoGenericContext *context, MonoError *error)
4854 {
4861 fsig = mono_metadata_parse_signature_checked (m_class_get_image (method->klass), token, error);
4863 }
4866 }
4868 }
4872 {
4878 }
4881 }
4883 static void
4885 {
4891 }
4893 /*
4894 * Return the original method is a wrapper is specified. We can only access
4895 * the custom attributes from the original method.
4896 */
4899 {
4903 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
4907 /* in other cases we need to find the original method */
4909 }
4911 static void
4912 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field)
4913 {
4914 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4915 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
4918 }
4920 static void
4921 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
4922 {
4923 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
4924 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
4927 }
4931 // If ip is desired_il_op, return the next ip, else NULL.
4932 {
4935 // mono_opcode_value_and_size updates ip, but not in the expected way.
4939 }
4941 }
4944 il_read_op_and_token (guchar *ip, guchar *end, guchar first_byte, MonoOpcodeEnum desired_il_op, guint32 *token)
4945 {
4950 }
4953 il_read_branch_and_target (guchar *ip, guchar *end, guchar first_byte, MonoOpcodeEnum desired_il_op, int size, guchar **target)
4954 {
4965 }
4966 // FIXME verify it is within the function and start of an instruction.
4969 }
4971 }
4973 #define il_read_brtrue(ip, end, target) (il_read_branch_and_target (ip, end, CEE_BRTRUE, MONO_CEE_BRTRUE, 4, target))
4974 #define il_read_brtrue_s(ip, end, target) (il_read_branch_and_target (ip, end, CEE_BRTRUE_S, MONO_CEE_BRTRUE_S, 1, target))
4975 #define il_read_brfalse(ip, end, target) (il_read_branch_and_target (ip, end, CEE_BRFALSE, MONO_CEE_BRFALSE, 4, target))
4976 #define il_read_brfalse_s(ip, end, target) (il_read_branch_and_target (ip, end, CEE_BRFALSE_S, MONO_CEE_BRFALSE_S, 1, target))
4977 #define il_read_dup(ip, end) (il_read_op (ip, end, CEE_DUP, MONO_CEE_DUP))
4978 #define il_read_newobj(ip, end, token) (il_read_op_and_token (ip, end, CEE_NEW_OBJ, MONO_CEE_NEWOBJ, token))
4979 #define il_read_ldtoken(ip, end, token) (il_read_op_and_token (ip, end, CEE_LDTOKEN, MONO_CEE_LDTOKEN, token))
4980 #define il_read_call(ip, end, token) (il_read_op_and_token (ip, end, CEE_CALL, MONO_CEE_CALL, token))
4981 #define il_read_callvirt(ip, end, token) (il_read_op_and_token (ip, end, CEE_CALLVIRT, MONO_CEE_CALLVIRT, token))
4982 #define il_read_initobj(ip, end, token) (il_read_op_and_token (ip, end, CEE_PREFIX1, MONO_CEE_INITOBJ, token))
4983 #define il_read_constrained(ip, end, token) (il_read_op_and_token (ip, end, CEE_PREFIX1, MONO_CEE_CONSTRAINED_, token))
4984 #define il_read_unbox_any(ip, end, token) (il_read_op_and_token (ip, end, CEE_UNBOX_ANY, MONO_CEE_UNBOX_ANY, token))
4986 /*
4987 * Check that the IL instructions at ip are the array initialization
4988 * sequence and return the pointer to the data and the size.
4989 */
4994 {
4995 /*
4996 * newarr[System.Int32]
4997 * dup
4998 * ldtoken field valuetype ...
4999 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5000 */
5002 guint32 token;
5003 guint32 field_token;
5012 guint32 rva;
5017 MonoClassField *field = mono_field_from_token_checked (m_class_get_image (method->klass), field_token, &dummy_class, NULL, error);
5023 }
5030 if (strcmp (cmethod->name, "InitializeArray") || strcmp (m_class_get_name (cmethod->klass), "RuntimeHelpers") || m_class_get_image (cmethod->klass) != mono_defaults.corlib)
5036 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5037 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5049 #endif
5052 }
5057 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5063 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5064 /* for aot code we do the lookup on load */
5068 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5071 }
5077 }
5079 }
5081 static void
5083 {
5090 method_code = g_strdup_printf ("could not parse method body due to %s", mono_error_get_message (error));
5094 else
5096 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code));
5100 }
5102 guint32
5104 {
5109 handle_enum:
5141 }
5144 case MONO_TYPE_MVAR: //TODO I believe we don't need to handle gsharedvt as there won't be match and, for example, u1 is not covariant to u32
5148 }
5150 }
5152 static void
5154 {
5170 }
5171 }
5177 /* Optimize reg-reg moves away */
5178 /*
5179 * Can't optimize other opcodes, since sp[0] might point to
5180 * the last ins of a decomposed opcode.
5181 */
5185 }
5186 }
5188 static void
5190 {
5206 }
5207 }
5210 }
5212 /*
5213 * ldloca inhibits many optimizations so try to get rid of it in common
5214 * cases.
5215 */
5218 {
5219 guint32 token;
5226 /* From the INITOBJ case */
5232 }
5233 exception_exit:
5235 }
5239 {
5240 /*
5241 * Devirt EqualityComparer.Default.Equals () calls for some types.
5242 * The corefx code excepts these calls to be devirtualized.
5243 * This depends on the implementation of EqualityComparer.Default, which is
5244 * in mcs/class/referencesource/mscorlib/system/collections/generic/equalitycomparer.cs
5245 */
5249 MonoType *param_type = mono_class_get_generic_class (cmethod->klass)->context.class_inst->type_argv [0];
5251 MonoGenericContext ctx;
5260 inst = mono_class_inflate_generic_class_checked (mono_class_get_iequatable_class (), &ctx, error);
5263 /* EqualityComparer<T>.Default returns specific types depending on T */
5264 // FIXME: Add more
5265 /* 1. Implements IEquatable<T> */
5266 /*
5267 * Can't use this for string/byte as it might use a different comparer:
5268 *
5269 * // Specialize type byte for performance reasons
5270 * if (t == typeof(byte)) {
5271 * return (EqualityComparer<T>)(object)(new ByteEqualityComparer());
5272 * }
5273 * #if MOBILE
5274 * // Breaks .net serialization compatibility
5275 * if (t == typeof (string))
5276 * return (EqualityComparer<T>)(object)new InternalStringComparer ();
5277 * #endif
5278 */
5279 if (mono_class_is_assignable_from_internal (inst, mono_class_from_mono_type_internal (param_type)) && param_type->type != MONO_TYPE_U1 && param_type->type != MONO_TYPE_STRING) {
5302 /* Force decompose */
5305 }
5306 }
5309 }
5311 static gboolean
5313 {
5320 }
5322 }
5324 /*
5325 * is_jit_optimizer_disabled:
5326 *
5327 * Determine whenever M's assembly has a DebuggableAttribute with the
5328 * IsJITOptimizerDisabled flag set.
5329 */
5330 static gboolean
5332 {
5347 /* Linked away */
5352 }
5364 /* Decode the attribute. See reflection.c */
5369 // FIXME: Support named parameters
5371 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
5373 /* Two boolean arguments */
5374 p ++;
5376 }
5378 }
5385 }
5387 gboolean
5389 {
5393 }
5395 static gboolean
5396 mono_is_not_supported_tailcall_helper (gboolean value, const char *svalue, MonoMethod *method, MonoMethod *cmethod)
5397 {
5398 // Return value, printing if it inhibits tailcall.
5403 mono_tailcall_print ("%s %s -> %s %s%s%s:%d\n", __func__, method->name, cmethod->name, lparen, svalue, rparen, value);
5404 }
5406 }
5408 #define IS_NOT_SUPPORTED_TAILCALL(x) (mono_is_not_supported_tailcall_helper((x), #x, method, cmethod))
5410 static gboolean
5411 is_supported_tailcall (MonoCompile *cfg, const guint8 *ip, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig,
5413 {
5414 // Some checks apply to "regular", some to "calli", some to both.
5415 // To ease burden on caller, always compute regular and calli.
5429 // FIXME in calli, there is no type for for the this parameter,
5430 // so we assume it might be valuetype; in future we should issue a range
5431 // check, so rule out pointing to frame (for other reference parameters also)
5433 if ( IS_NOT_SUPPORTED_TAILCALL (cmethod && fsig->hasthis && m_class_is_valuetype (cmethod->klass)) // This might point to the current method's stack. Emit range check?
5437 || IS_NOT_SUPPORTED_TAILCALL (!cmethod && fsig->hasthis) // FIXME could be valuetype to current frame; range check
5438 || IS_NOT_SUPPORTED_TAILCALL (cmethod && cmethod->wrapper_type && cmethod->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)
5440 // http://www.mono-project.com/docs/advanced/runtime/docs/generic-sharing/
5441 //
5442 // 1. Non-generic non-static methods of reference types have access to the
5443 // RGCTX via the “this” argument (this->vtable->rgctx).
5444 // 2. a Non-generic static methods of reference types and b. non-generic methods
5445 // of value types need to be passed a pointer to the caller’s class’s VTable in the MONO_ARCH_RGCTX_REG register.
5446 // 3. Generic methods need to be passed a pointer to the MRGCTX in the MONO_ARCH_RGCTX_REG register
5447 //
5448 // That is what vtable_arg is here (always?).
5449 //
5450 // Passing vtable_arg uses (requires?) a volatile non-parameter register,
5451 // such as AMD64 rax, r10, r11, or the return register on many architectures.
5452 // ARM32 does not always clearly have such a register. ARM32's return register
5453 // is a parameter register.
5454 // iPhone could use r9 except on old systems. iPhone/ARM32 is not particularly
5455 // important. Linux/arm32 is less clear.
5456 // ARM32's scratch r12 might work but only with much collateral change.
5457 //
5458 // Imagine F1 calls F2, and F2 tailcalls F3.
5459 // F2 and F3 are managed. F1 is native.
5460 // Without a tailcall, F2 can save and restore everything needed for F1.
5461 // However if the extra parameter were in a non-volatile, such as ARM32 V5/R8,
5462 // F3 cannot easily restore it for F1, in the current scheme. The current
5463 // scheme where the extra parameter is not merely an extra parameter, but
5464 // passed "outside of the ABI".
5465 //
5466 // If all native to managed transitions are intercepted and wrapped (w/o tailcall),
5467 // then they can preserve this register and the rest of the managed callgraph
5468 // treat it as volatile.
5469 //
5470 // Interface method dispatch has the same problem (imt_arg).
5474 ) {
5478 }
5481 if (IS_NOT_SUPPORTED_TAILCALL (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)) {
5485 }
5486 }
5496 // Require an exact match on return type due to various conversions in emit_move_return_value that would be skipped.
5497 // The main troublesome conversions are double <=> float.
5498 // CoreCLR allows some conversions here, such as integer truncation.
5499 // As well I <=> I[48] and U <=> U[48] would be ok, for matching size.
5500 if (IS_NOT_SUPPORTED_TAILCALL (mini_get_underlying_type (caller_signature->ret)->type != mini_get_underlying_type (callee_signature->ret)->type)
5501 || IS_NOT_SUPPORTED_TAILCALL (!mono_arch_tailcall_supported (cfg, caller_signature, callee_signature, virtual_))) {
5505 }
5507 /* Debugging support */
5508 #if 0
5513 }
5514 #endif
5515 // See check_sp in mini_emit_calli_full.
5518 exit:
5519 mono_tailcall_print ("tail.%s %s -> %s tailcall:%d tailcall_calli:%d gshared:%d extra_arg:%d virtual_:%d\n",
5520 mono_opcode_name (*ip), method->name, cmethod ? cmethod->name : "calli", tailcall, tailcall_calli,
5525 }
5527 /*
5528 * is_addressable_valuetype_load
5529 *
5530 * Returns true if a previous load can be done without doing an extra copy, given the new instruction ip and the type of the object being loaded ldtype
5531 */
5532 static gboolean
5534 {
5535 /* Avoid loading a struct just to load one of its fields */
5540 }
5542 /*
5543 * handle_ctor_call:
5544 *
5545 * Handle calls made to ctors from NEWOBJ opcodes.
5546 */
5547 static void
5548 handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used,
5550 {
5553 if (m_class_is_valuetype (cmethod->klass) && mono_class_generic_sharing_enabled (cmethod->klass) &&
5557 CHECK_CFG_ERROR;
5568 CHECK_CFG_ERROR;
5571 }
5572 }
5573 }
5575 /* Avoid virtual calls to ctors if possible */
5581 CHECK_CFG_EXCEPTION;
5593 // FIXME-VT: Clean this up
5597 }
5601 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
5604 // FIXME: Avoid initializing vtable_arg
5608 }
5614 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
5618 MONO_RGCTX_INFO_METHOD_FTNDESC);
5625 }
5630 }
5631 exception_exit:
5632 mono_error_exit:
5634 }
5638 gboolean inst_tailcall;
5641 /*
5642 * handle_constrained_call:
5643 *
5644 * Handle constrained calls. Return a MonoInst* representing the call or NULL.
5645 * May overwrite sp [0] and modify the ref_... parameters.
5646 */
5648 handle_constrained_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoClass *constrained_class, MonoInst **sp,
5649 HandleCallData *cdata, MonoMethod **ref_cmethod, gboolean *ref_virtual, gboolean *ref_emit_widen)
5650 {
5654 gboolean constrained_is_generic_param =
5663 }
5664 }
5667 if ((cmethod->klass != mono_defaults.object_class) && m_class_is_valuetype (constrained_class) && m_class_is_valuetype (cmethod->klass)) {
5668 /* The 'Own method' case below */
5669 } else if (m_class_get_image (cmethod->klass) != mono_defaults.corlib && !mono_class_is_interface (cmethod->klass) && !m_class_is_valuetype (cmethod->klass)) {
5670 /* 'The type parameter is instantiated as a reference type' case below. */
5672 ins = handle_constrained_gsharedvt_call (cfg, cmethod, fsig, sp, constrained_class, ref_emit_widen);
5673 CHECK_CFG_EXCEPTION;
5676 mono_tailcall_print ("missed tailcall constrained_class %s -> %s\n", method->name, cmethod->name);
5678 }
5679 }
5684 /*
5685 * The receiver is a valuetype, but the exact type is not known at compile time. This means the
5686 * called method is not known at compile time either. The called method could end up being
5687 * one of the methods on the parent classes (object/valuetype/enum), in which case we need
5688 * to box the receiver.
5689 * A simple solution would be to box always and make a normal virtual call, but that would
5690 * be bad performance wise.
5691 */
5694 /*
5695 * The parent classes implement no generic interfaces, so the called method will be a vtype method, so no boxing neccessary.
5696 */
5697 /* If the method is not abstract, it's a default interface method, and we need to box */
5699 }
5701 if (!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) && (cmethod->klass == mono_defaults.object_class || cmethod->klass == m_class_get_parent (mono_defaults.enum_class) || cmethod->klass == mono_defaults.enum_class)) {
5702 /* The called method is not virtual, i.e. Object:GetType (), the receiver is a vtype, has to box */
5703 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (constrained_class), sp [0]->dreg, 0);
5705 sp [0] = mini_emit_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
5706 CHECK_CFG_EXCEPTION;
5712 /*
5713 * Determine at runtime whenever the called method is defined on object/valuetype/enum, and emit a boxing call
5714 * if needed.
5715 * FIXME: It is possible to inline the called method in a lot of cases, i.e. for T_INT,
5716 * the no-box case goes to a method in Int32, while the box case goes to a method in Enum.
5717 */
5718 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
5723 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);
5724 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, box_type->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
5727 /* Non-ref case */
5729 /* addr is an ftndesc in this case */
5731 else
5736 /* Ref case */
5738 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (constrained_class), sp [0]->dreg, 0);
5740 sp [0] = mini_emit_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
5741 CHECK_CFG_EXCEPTION;
5744 else
5754 mono_tailcall_print ("missed tailcall constrained_partial_need_box %s -> %s\n", method->name, cmethod->name);
5758 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
5761 else
5764 mono_tailcall_print ("missed tailcall constrained_partial %s -> %s\n", method->name, cmethod->name);
5766 }
5770 /*
5771 * The type parameter is instantiated as a reference
5772 * type. We have a managed pointer on the stack, so
5773 * we need to dereference it here.
5774 */
5778 } else if (cmethod->klass == mono_defaults.object_class || cmethod->klass == m_class_get_parent (mono_defaults.enum_class) || cmethod->klass == mono_defaults.enum_class) {
5779 /*
5780 * The type parameter is instantiated as a valuetype,
5781 * but that type doesn't override the method we're
5782 * calling, so we need to box `this'.
5783 */
5784 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (constrained_class), sp [0]->dreg, 0);
5786 sp [0] = mini_emit_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
5787 CHECK_CFG_EXCEPTION;
5790 /* Enums/default interface methods */
5791 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (constrained_class), sp [0]->dreg, 0);
5793 sp [0] = mini_emit_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
5794 CHECK_CFG_EXCEPTION;
5795 }
5797 }
5799 exception_exit:
5801 }
5803 static void
5805 {
5806 MonoType *ret_type = mini_get_underlying_type (mono_method_signature_internal (cfg->method)->ret);
5820 else
5823 }
5825 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5835 }
5836 #else
5838 #endif
5839 }
5840 }
5843 gint32 i32;
5844 gint64 i64;
5857 mono_opcode_decode (guchar *ip, guint op_size, MonoOpcodeEnum il_op, MonoOpcodeParameter *parameter)
5858 {
5859 #define Push0 (0)
5860 #define Pop0 (0)
5861 #define Push1 (1)
5862 #define Pop1 (1)
5863 #define PushI (1)
5864 #define PopI (1)
5865 #define PushI8 (1)
5866 #define PopI8 (1)
5867 #define PushRef (1)
5868 #define PopRef (1)
5869 #define PushR4 (1)
5870 #define PopR4 (1)
5871 #define PushR8 (1)
5872 #define PopR8 (1)
5873 #define VarPush (-1)
5874 #define VarPop (-1)
5877 #define OPDEF(name, str, pops, pushes, param, param_constant, a, b, c, flow) {param_constant + 1, pops, pushes },
5879 #undef OPDEF
5880 };
5882 #undef Push0
5883 #undef Pop0
5884 #undef Push1
5885 #undef Pop1
5886 #undef PushI
5887 #undef PopI
5888 #undef PushI8
5889 #undef PopI8
5890 #undef PushRef
5891 #undef PopRef
5892 #undef PushR4
5893 #undef PopR4
5894 #undef PushR8
5895 #undef PopR8
5896 #undef VarPush
5897 #undef VarPop
5899 gint32 delta;
5917 // FIXME check token type?
5937 branch_target:
5944 }
5946 }
5948 /*
5949 * mono_method_to_ir:
5950 *
5951 * Translate the .net IL into linear IR.
5952 *
5953 * @start_bblock: if not NULL, the starting basic block, used during inlining.
5954 * @end_bblock: if not NULL, the ending basic block, used during inlining.
5955 * @return_var: if not NULL, the place where the return value is stored, used during inlining.
5956 * @inline_args: if not NULL, contains the arguments to the inline call
5957 * @inline_offset: if not zero, the real offset from the inline call, or zero otherwise.
5958 * @is_virtual_call: whether this method is being called as a result of a call to callvirt
5959 *
5960 * This method is used to turn ECMA IL into Mono's internal Linear IR
5961 * reprensetation. It is used both for entire methods, as well as
5962 * inlining existing methods. In the former case, the @start_bblock,
5963 * @end_bblock, @return_var, @inline_args are all set to NULL, and the
5964 * inline_offset is set to zero.
5965 *
5966 * Returns: the inline cost, or -1 if there was an error processing this method.
5967 */
5968 int
5969 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5972 {
5974 // Buffer to hold parameters to mono_new_array, instead of varargs.
5996 guint num_args;
6012 /* serialization and xdomain stuff may need access to private fields and methods */
6020 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
6032 }
6045 /* We could hit a seq point before attaching to the JIT (#8338) */
6047 }
6056 }
6065 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6066 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);
6071 }
6077 {
6080 }
6082 }
6083 } else if (!method->wrapper_type && !method->dynamic && mono_debug_image_has_debug_info (m_class_get_image (method->klass))) {
6084 /* Methods without line number info like auto-generated property accessors */
6085 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
6086 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);
6088 }
6089 }
6091 /*
6092 * Methods without init_locals set could cause asserts in various passes
6093 * (#497220). To work around this, we emit dummy initialization opcodes
6094 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
6095 * on some platforms.
6096 */
6099 else
6106 }
6108 /* SkipVerification is not allowed if core-clr is enabled */
6112 }
6126 }
6134 }
6136 cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
6144 param_types [0] = m_class_is_valuetype (method->klass) ? m_class_get_this_arg (method->klass) : m_class_get_byval_arg (method->klass);
6151 /* ENTRY BLOCK */
6157 /* EXIT BLOCK */
6170 }
6171 /* handle exception clauses */
6185 /*
6186 * Linking the try block with the EH block hinders inlining as we won't be able to
6187 * merge the bblocks from inlining and produce an artificial hole for no good reason.
6188 */
6201 if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FILTER) {
6202 /* finally clauses already have a seq point */
6203 /* seq points for filter clauses are emitted below */
6206 }
6208 /* todo: is a fault block unsafe to optimize? */
6211 }
6213 /*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);
6214 while (p < end) {
6215 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
6216 }*/
6217 /* catch and filter blocks get the exception object on the stack */
6221 /* mostly like handle_stack_args (), but just sets the input args */
6222 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
6229 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
6230 /* The EH code passes in the exception in a register to both JITted and LLVM compiled code */
6235 }
6236 #else
6239 /*
6240 * Add a dummy use for the exvar so its liveness info will be
6241 * correct.
6242 */
6244 #endif
6249 }
6257 /* The filter block shares the exvar with the handler block */
6261 }
6262 }
6268 /*
6269 * In shared generic code with catch
6270 * clauses containing type variables
6271 * the exception handling code has to
6272 * be able to get to the rgctx.
6273 * Therefore we have to make sure that
6274 * the vtable/mrgctx argument (for
6275 * static or generic methods) or the
6276 * "this" argument (for non-static
6277 * methods) are live.
6278 */
6287 }
6288 }
6289 }
6295 }
6297 /* FIRST CODE BLOCK */
6310 }
6311 }
6313 /* we use a separate basic block for the initialization code */
6330 info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
6333 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
6337 /* prevent it from being register allocated */
6338 //var->flags |= MONO_INST_VOLATILE;
6341 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
6344 /* Allocate locals */
6346 /* prevent it from being register allocated */
6347 //locals_var->flags |= MONO_INST_VOLATILE;
6351 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
6360 /*
6361 if (init_locals)
6362 ins->flags |= MONO_INST_INIT;
6363 */
6364 }
6367 /* check if this is native code, e.g. an icall or a p/invoke */
6374 /* if this ia a native call then it can only be JITted from platform code */
6380 }
6381 }
6382 }
6383 }
6384 }
6386 CHECK_CFG_EXCEPTION;
6389 UNVERIFIED;
6393 UNVERIFIED;
6394 }
6401 UNVERIFIED;
6402 }
6405 /* We force the vtable variable here for all shared methods
6406 for the possibility that they might show up in a stack
6407 trace where their exact instantiation is needed. */
6414 /* FIXME: Is there a better way to do this?
6415 We need the variable live for the duration
6416 of the whole method. */
6418 }
6419 }
6421 /* add a check for this != NULL to inlined methods */
6428 }
6433 CHECK_CFG_ERROR;
6435 }
6437 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
6438 stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
6453 else
6465 }
6474 }
6485 }
6493 }
6496 }
6497 }
6514 }
6516 }
6517 }
6518 /*
6519 * Sequence points are points where the debugger can place a breakpoint.
6520 * Currently, we generate these automatically at points where the IL
6521 * stack is empty.
6522 */
6523 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
6524 /*
6525 * Make methods interruptable at the beginning, and at the targets of
6526 * backward branches.
6527 * Also, do this at the start of every bblock in methods with clauses too,
6528 * to be able to handle instructions with inprecise control flow like
6529 * throw/endfinally.
6530 * Backward branches are handled at the end of method-to-ir ().
6531 */
6533 gboolean sym_seq_point = sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code);
6535 /* Avoid sequence points on empty IL like .volatile */
6536 // FIXME: Enable this
6537 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
6566 }
6567 }
6568 }
6573 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
6575 // Variables shared by CEE_CALLI CEE_CALL CEE_CALLVIRT CEE_JMP.
6576 // Initialize to either what they all need or zero.
6584 // These are used only in CALL/CALLVIRT but must be initialized also for CALLI,
6585 // since it jumps into CALL/CALLVIRT.
6591 // FIXME split 500 lines load/store field into separate file/function.
6593 MonoOpcodeParameter parameter;
6600 // Check stack size for push/pop except variable cases -- -1 like call/ret/newobj.
6607 }
6614 /*
6615 * The C# compiler uses these nops to notify the JIT that it should
6616 * insert seq points.
6617 */
6620 }
6623 else
6634 }
6647 }
6662 }
6676 UNVERIFIED;
6693 UNVERIFIED;
6706 }
6711 }
6744 #ifdef TARGET_POWERPC
6745 /* FIXME: Clean this up */
6748 #endif
6749 /* FIXME: we should really allocate this only late in the compilation process */
6767 }
6771 }
6776 #ifdef TARGET_POWERPC
6777 /* FIXME: Clean this up */
6780 #endif
6782 /* FIXME: we should really allocate this only late in the compilation process */
6800 }
6804 }
6807 sp--;
6821 }
6825 #ifdef TARGET_X86
6827 /* we need to pop the value from the x86 FP stack */
6829 #endif
6839 UNVERIFIED;
6840 /* FIXME: check the signature matches */
6842 CHECK_CFG_ERROR;
6858 /*
6859 * The code in mono-basic-block.c treats the rest of the code as dead, but we
6860 * have to emit a normal return since llvm expects it.
6861 */
6870 /* Handle tailcalls similarly to calls */
6876 // FIXME Other initialization of the tailcall field occurs after
6877 // it is used. So this is the only "real" use and needs more attention.
6891 }
6895 }
6897 // FIXME tail.calli is problemetic because the this pointer's type
6898 // is not in the signature, and we cannot check for a byref valuetype.
6902 // Variables shared by CEE_CALLI and CEE_CALL/CEE_CALLVIRT.
6911 //GSHAREDVT_FAILURE (il_op);
6917 CHECK_CFG_ERROR;
6922 /*
6923 * This is a call through a function pointer using a pinvoke
6924 * signature. Have to create a wrapper and call that instead.
6925 * FIXME: This is very slow, need to create a wrapper at JIT time
6926 * instead based on the signature.
6927 */
6931 // FIXME tailcall?
6933 }
6939 //g_assert (!virtual_ || fsig->hasthis);
6943 if (!(cfg->method->wrapper_type && cfg->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD) && check_call_signature (cfg, fsig, sp)) {
6946 UNVERIFIED;
6947 }
6951 /*
6952 * Making generic calls out of gsharedvt methods.
6953 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
6954 * patching gshared method addresses into a gsharedvt method.
6955 */
6957 /*
6958 * We pass the address to the gsharedvt trampoline in the rgctx reg
6959 */
6962 }
6969 /* Not tested */
6973 // FIXME:
6976 addr = emit_get_rgctx_sig (cfg, context_used, fsig, MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI);
6979 }
6981 /* Prevent inlining of methods with indirect calls */
6984 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
6985 MonoJumpInfoType info_type;
6986 gpointer info_data;
6988 /*
6989 * Instead of emitting an indirect call, emit a direct call
6990 * with the contents of the aotconst as the patch info.
6991 */
6998 }
7001 // non-JIT icall, mostly builtin, but also user-extensible
7003 ins = (MonoInst*)mini_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR_CALL, info_data, fsig, sp);
7012 }
7013 }
7016 }
7033 // Variables shared by CEE_CALLI and CEE_CALL/CEE_CALLVIRT.
7036 // variables to help in assertions
7049 /* Used to pass arguments to called functions */
7050 HandleCallData cdata;
7054 CHECK_CFG_ERROR;
7062 gboolean constrained_is_generic_param =
7071 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_class, generic_context, cfg->error);
7072 CHECK_CFG_ERROR;
7073 }
7079 /*
7080 * This is needed since get_method_constrained can't find
7081 * the method in klass representing a type var.
7082 * The type var is guaranteed to be a reference type in this
7083 * case.
7084 */
7088 cmethod = mono_get_method_constrained_checked (image, token, constrained_class, generic_context, &cil_method, cfg->error);
7089 CHECK_CFG_ERROR;
7090 }
7091 }
7094 /* Use the corresponding method from the base type to avoid boxing */
7100 }
7101 }
7106 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), cfg->error);
7107 CHECK_CFG_ERROR;
7108 }
7112 }
7120 else
7122 }
7124 {
7125 /*
7126 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
7127 * converts to a callvirt.
7128 *
7129 * tests/bug-515884.il is an example of this behavior
7130 */
7131 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
7133 if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
7135 }
7143 LOAD_ERROR;
7147 } else if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && direct_icalls_enabled (cfg, cmethod)) {
7155 CHECK_CFG_ERROR;
7156 }
7161 /* See code below */
7162 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature_internal (cmethod)->param_count == 1) {
7167 /*
7168 * We want to extend the try block to cover the call, but we can't do it if the
7169 * call is made directly since its followed by an exception check.
7170 */
7172 }
7173 }
7180 /* Don't support calls made using type arguments for now */
7181 /*
7182 if (cfg->gsharedvt) {
7183 if (mini_is_gsharedvt_signature (fsig))
7184 GSHAREDVT_FAILURE (il_op);
7185 }
7186 */
7194 UNVERIFIED;
7201 //g_assert (!virtual_ || fsig->hasthis);
7208 MonoMethod *new_cmethod = mono_class_get_virtual_method (sp [0]->klass, cmethod, FALSE, error);
7212 }
7217 }
7222 /*
7223 * We have the `constrained.' prefix opcode.
7224 */
7226 ins = handle_constrained_call (cfg, cmethod, fsig, constrained_class, sp, &cdata, &cmethod, &virtual_, &emit_widen);
7227 CHECK_CFG_EXCEPTION;
7231 }
7239 UNVERIFIED;
7240 }
7242 if ((m_class_get_parent (cmethod->klass) == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
7245 #ifndef ENABLE_NETCORE
7246 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
7250 }
7253 mono_tailcall_print ("missed tailcall intrins_sharable %s -> %s\n", method->name, cmethod->name);
7255 }
7256 #endif
7258 /*
7259 * Implement a workaround for the inherent races involved in locking:
7260 * Monitor.Enter ()
7261 * try {
7262 * } finally {
7263 * Monitor.Exit ()
7264 * }
7265 * If a thread abort happens between the call to Monitor.Enter () and the start of the
7266 * try block, the Exit () won't be executed, see:
7267 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
7268 * To work around this, we extend such try blocks to include the last x bytes
7269 * of the Monitor.Enter () call.
7270 */
7271 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature_internal (cmethod)->param_count == 1) {
7275 /*
7276 * Only extend try blocks with a finally, to avoid catching exceptions thrown
7277 * from Monitor.Enter like ArgumentNullException.
7278 */
7280 /* Mark this bblock as needing to be extended */
7282 }
7283 }
7285 /* Conversion to a JIT intrinsic */
7290 }
7291 // FIXME This is only missed if in fact the intrinsic involves a call.
7295 }
7296 CHECK_CFG_ERROR;
7298 /*
7299 * If the callee is a shared method, then its static cctor
7300 * might not get called after the call was patched.
7301 */
7302 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)) {
7305 }
7315 /* Generic method interface
7316 calls are resolved via a
7317 helper function and don't
7318 need an imt. */
7321 }
7323 /*
7324 * If a shared method calls another
7325 * shared method then the caller must
7326 * have a generic sharing context
7327 * because the magic trampoline
7328 * requires it. FIXME: We shouldn't
7329 * have to force the vtable/mrgctx
7330 * variable here. Instead there
7331 * should be a flag in the cfg to
7332 * request a generic sharing context.
7333 */
7337 }
7341 vtable_arg = mini_emit_get_rgctx_klass (cfg, context_used, cmethod->klass, MONO_RGCTX_INFO_VTABLE);
7344 CHECK_CFG_ERROR;
7348 }
7349 }
7355 /*
7356 * emit_get_rgctx_method () calls mono_class_vtable () so check
7357 * for type load errors before.
7358 */
7361 }
7365 /* !marshalbyref is needed to properly handle generic methods + remoting */
7372 }
7373 }
7381 }
7386 /* Calling virtual generic methods */
7388 // These temporaries help detangle "pure" computation of
7389 // inputs to is_supported_tailcall from side effects, so that
7390 // is_supported_tailcall can be computed just once.
7405 /* Prevent inlining of methods that contain indirect calls */
7411 if (cfg->backend->have_generalized_imt_trampoline && cfg->backend->gshared_supported && cmethod->wrapper_type == MONO_WRAPPER_NONE) {
7422 }
7423 }
7425 // Capture some intent before computing tailcall.
7427 gboolean make_generic_call_out_of_gsharedvt_method;
7428 gboolean will_have_imt_arg;
7433 /*
7434 * Making generic calls out of gsharedvt methods.
7435 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
7436 * patching gshared method addresses into a gsharedvt method.
7437 */
7438 if (cfg->gsharedvt && (mini_is_gsharedvt_signature (fsig) || cmethod->is_inflated || mono_class_is_ginst (cmethod->klass)) &&
7439 !(m_class_get_rank (cmethod->klass) && m_class_get_byval_arg (cmethod->klass)->type != MONO_TYPE_SZARRAY) &&
7449 }
7450 }
7451 }
7453 #ifdef ENABLE_NETCORE
7456 }
7457 #endif
7459 /* Tail prefix / tailcall optimization */
7461 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests.
7462 Inlining and stack traces are not guaranteed however. */
7463 /* FIXME: runtime generic context pointer for jumps? */
7464 /* FIXME: handle this for generic sharing eventually */
7466 // tailcall means "the backend can and will handle it".
7467 // inst_tailcall means the tail. prefix is present.
7468 tailcall_extra_arg = vtable_arg || imt_arg || will_have_imt_arg || mono_class_is_interface (cmethod->klass);
7471 // Writes to imt_arg, vtable_arg, virtual_, cmethod, must not occur from here (inputs to is_supported_tailcall).
7472 // Capture values to later assert they don't change.
7482 /* Prevent inlining of methods with tailcalls (the call stack would be altered) */
7484 }
7487 }
7496 /* FIXME: This should be a managed pointer */
7510 mono_tailcall_print ("missed tailcall virtual generic %s -> %s\n", method->name, cmethod->name);
7512 }
7513 CHECK_CFG_ERROR;
7515 /* Inlining */
7517 (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
7524 /* Prevent inlining of methods that call wrappers */
7526 // FIXME? Does this write to cmethod impact tailcall_supported? Probably not.
7527 // Neither pinvoke or icall are likely to be tailcalled.
7530 }
7537 /* *sp is already set by inline_method */
7541 // FIXME This is missed if the inlinee contains tail calls that
7542 // would work, but not once inlined into caller.
7543 // This matchingness could be a factor in inlining.
7544 // i.e. Do not inline if it hurts tailcall, do inline
7545 // if it helps and/or or is neutral, and helps performance
7546 // using usual heuristics.
7547 // Note that inlining will expose multiple tailcall opportunities
7548 // so the tradeoff is not obvious. If we can tailcall anything
7549 // like desktop, then this factor mostly falls away, except
7550 // that inlining can affect tailcall performance due to
7551 // signature match/mismatch.
7555 }
7556 }
7558 /* Tail recursion elimination */
7559 if (((cfg->opt & MONO_OPT_TAILCALL) || inst_tailcall) && il_op == MONO_CEE_CALL && cmethod == method && next_ip < end && next_ip [0] == CEE_RET && !vtable_arg) {
7563 /* Prevent inlining of methods with tailcalls (the call stack would be altered) */
7566 /* keep it simple */
7574 }
7587 /* skip the CEE_RET, too */
7593 }
7594 }
7598 /*
7599 * Synchronized wrappers.
7600 * Its hard to determine where to replace a method with its synchronized
7601 * wrapper without causing an infinite recursion. The current solution is
7602 * to add the synchronized wrapper in the trampolines, and to
7603 * change the called method to a dummy wrapper, and resolve that wrapper
7604 * to the real method in mono_jit_compile_method ().
7605 */
7608 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig)) {
7609 // FIXME? Does this write to cmethod impact tailcall_supported? Probably not.
7611 }
7612 }
7614 /*
7615 * Making generic calls out of gsharedvt methods.
7616 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
7617 * patching gshared method addresses into a gsharedvt method.
7618 */
7621 //if (mono_class_is_interface (cmethod->klass))
7622 //GSHAREDVT_FAILURE (il_op);
7623 // disable for possible remoting calls
7624 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
7627 /* virtual generic call */
7630 /* Same as the virtual generic case above */
7635 /* This can happen when we call a fully instantiated iface method */
7640 }
7641 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
7643 }
7645 if ((m_class_get_parent (cmethod->klass) == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
7648 MonoRgctxInfoType info_type;
7652 else
7657 // FIXME: Avoid initializing vtable_arg
7660 mono_tailcall_print ("missed tailcall llvmonly gsharedvt %s -> %s\n", method->name, cmethod->name);
7665 }
7667 }
7669 /* Generic sharing */
7671 /*
7672 * Use this if the callee is gsharedvt sharable too, since
7673 * at runtime we might find an instantiation so the call cannot
7674 * be patched (the 'no_patch' code path in mini-trampolines.c).
7675 */
7686 /*
7687 * We are compiling a call to a
7688 * generic method from shared code,
7689 * which means that we have to look up
7690 * the method in the rgctx and do an
7691 * indirect call.
7692 */
7698 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GSHAREDVT_OUT_WRAPPER);
7699 else
7701 // FIXME: Avoid initializing imt_arg/vtable_arg
7704 mono_tailcall_print ("missed tailcall context_used_llvmonly %s -> %s\n", method->name, cmethod->name);
7706 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
7708 mono_tailcall_print ("%s tailcall_calli#2 %s -> %s\n", tailcall_calli ? "making" : "missed", method->name, cmethod->name);
7712 }
7714 }
7716 /* Direct calls to icalls */
7721 /* Inline the wrapper */
7729 /* *sp is already set by inline_method */
7737 }
7739 /* Array methods */
7753 }
7758 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
7777 }
7783 }
7790 }
7792 /* Tail prefix / tailcall optimization */
7795 /* Prevent inlining of methods with tailcalls (the call stack would be altered) */
7797 }
7799 /*
7800 * Virtual calls in llvm-only mode.
7801 */
7805 }
7807 /* Common call */
7808 if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING) && !(cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
7812 call_end:
7813 // Check that the decision to tailcall would not have changed.
7815 // FIXME? cmethod does change, weaken the assert if we weren't tailcalling anyway.
7816 // If this still fails, restructure the code, or call tailcall_supported again and assert no change.
7820 g_assert (!called_is_supported_tailcall || tailcall_extra_arg == (vtable_arg || imt_arg || will_have_imt_arg || mono_class_is_interface (cmethod->klass)));
7826 /*
7827 * Handle devirt of some A.B.C calls by replacing the result of A.B with a OP_TYPED_OBJREF instruction, so the .C
7828 * call can be devirtualized above.
7829 */
7836 }
7837 calli_end:
7842 // FIXME: Eliminate unreachable epilogs
7844 /*
7845 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
7846 * only reachable from this call.
7847 */
7853 }
7858 /* End of call, INS should contain the result of the call, if any */
7864 else
7866 }
7870 #ifdef TARGET_WIN32
7871 // Making icalls etc could clobber the value so emit inline code
7872 // to read last error on Windows.
7878 #else
7880 #endif
7881 }
7886 /* See mini_emit_method_call_full () */
7888 }
7891 /*
7892 * Clang can convert these calls to tailcalls which screw up the stack
7893 * walk. This happens even when the -fno-optimize-sibling-calls
7894 * option is passed to clang.
7895 * Work around this by emitting a dummy call.
7896 */
7898 }
7900 CHECK_CFG_EXCEPTION;
7903 // FIXME When not followed by CEE_RET, correct behavior is to raise an exception.
7907 }
7912 //check is is a nested call and remove the non_empty_stack of the last call, only for non native methods
7917 }
7918 else
7920 }
7922 }
7924 }
7931 /* return from inlined method */
7932 /*
7933 * If in_count == 0, that means the ret is unreachable due to
7934 * being preceeded by a throw. In that case, inline_method () will
7935 * handle setting the return value
7936 * (test case: test_0_inline_throw ()).
7937 */
7946 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7947 UNVERIFIED;
7949 //g_assert (returnvar != -1);
7952 }
7961 /*
7962 * Place a seq point here too even through the IL stack is not
7963 * empty, so a step over on
7964 * call <FOO>
7965 * ret
7966 * will work correctly.
7967 */
7970 }
7977 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
7978 UNVERIFIED;
7981 }
7982 }
7984 UNVERIFIED;
8000 }
8032 }
8047 UNVERIFIED;
8049 sp--;
8059 }
8066 #if SIZEOF_REGISTER == 4
8068 /* Convert it to OP_LCOMPARE */
8076 }
8077 #endif
8083 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * 2);
8093 }
8120 gboolean use_op_switch;
8126 UNVERIFIED;
8139 }
8142 /*
8143 * Link the current bb with the targets as well, so handle_stack_args
8144 * will set their in_stack correctly.
8145 */
8154 /* Undo the links */
8158 }
8166 table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
8171 #ifdef TARGET_ARM
8172 /* ARM implements SWITCH statements differently */
8173 /* FIXME: Make it use the generic implementation */
8176 #endif
8193 else
8196 #if SIZEOF_REGISTER == 8
8197 /* The upper word might not be zero, and we add it to a 64 bit address later */
8199 #endif
8209 }
8211 /* FIXME: Use load_memindex */
8215 }
8219 }
8233 ins = mini_emit_memory_load (cfg, m_class_get_byval_arg (ldind_to_type (il_op)), sp [0], 0, ins_flag);
8248 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
8250 }
8254 if (!mini_debug_options.weak_memory_model && il_op == MONO_CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER)
8263 /* stind.ref must only be used with object references. */
8265 UNVERIFIED;
8266 if (cfg->gen_write_barriers && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !MONO_INS_IS_PCONST_NULL (sp [1]))
8268 }
8272 }
8282 /* Use the immediate opcodes if possible */
8285 if ((sp [1]->opcode == OP_ICONST) && mono_arch_is_inst_imm (ins->opcode, imm_opcode, sp [1]->inst_c0)) {
8292 }
8293 }
8320 /* Use the immediate opcodes if possible */
8324 mono_arch_is_inst_imm (ins->opcode, imm_opcode, sp [1]->opcode == OP_ICONST ? sp [1]->inst_c0 : sp [1]->inst_l)) {
8328 #if SIZEOF_REGISTER == 8
8330 #else
8332 #endif
8335 }
8338 /* Might be followed by an instruction added by add_widen_op */
8341 }
8342 }
8347 }
8361 /* Special case this earlier so we have long constants in the IR */
8362 if ((il_op == MONO_CEE_CONV_I8 || il_op == MONO_CEE_CONV_U8) && (sp [-1]->opcode == OP_ICONST)) {
8366 #if SIZEOF_REGISTER == 8
8369 else
8371 #else
8374 else
8376 #endif
8378 }
8381 }
8393 }
8403 }
8420 CHECK_CFG_EXCEPTION;
8447 /* Optimize the common ldobj+stloc combination */
8464 }
8465 }
8476 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
8478 }
8481 }
8483 /* Optimize the ldobj+stobj combination */
8484 if (next_ip + 4 < end && next_ip [0] == CEE_STOBJ && ip_in_bb (cfg, cfg->cbb, next_ip) && read32 (next_ip + 1) == token) {
8487 sp --;
8495 }
8503 }
8509 }
8516 else
8525 }
8531 CHECK_CFG_ERROR;
8537 /*
8538 * Avoid relocations in AOT and save some space by using a
8539 * version of helper_ldstr specialized to mscorlib.
8540 */
8544 /* Avoid creating the string object */
8548 }
8549 }
8550 else
8555 }
8559 ins->inst_p0 = mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), cfg->error);
8560 CHECK_CFG_ERROR;
8563 OUT_OF_MEMORY_FAILURE;
8567 }
8568 }
8569 }
8571 sp++;
8576 MonoInst this_ins;
8581 CHECK_CFG_ERROR;
8584 CHECK_CFG_ERROR;
8598 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), cfg->error);
8599 CHECK_CFG_ERROR;
8600 }
8605 }
8610 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)) {
8613 }
8615 /*
8616 if (cfg->gsharedvt) {
8617 if (mini_is_gsharedvt_variable_signature (sig))
8618 GSHAREDVT_FAILURE (il_op);
8619 }
8620 */
8625 /*
8626 * Generate smaller code for the common newobj <exception> instruction in
8627 * argument checking code.
8628 */
8653 }
8657 }
8659 /* move the args to allow room for 'this' in the first position */
8663 }
8668 /* check_call_signature () requires sp[0] to be set */
8672 UNVERIFIED;
8679 /* Optimize the common cases */
8692 // FIXME Maximum value of param_count? Realistically 64. Fits in imm?
8698 }
8699 array_new_localalloc_ins->inst_imm = MAX (array_new_localalloc_ins->inst_imm, n * sizeof (target_mgreg_t));
8702 NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, dreg, i * sizeof (target_mgreg_t), sp [i + 1]->dreg);
8704 }
8710 // FIXME Adjust sp by n - 3? Attempts failed.
8713 }
8718 /* we simply pass a null pointer */
8720 /* now call the string ctor */
8730 /*
8731 * The code generated by mini_emit_virtual_call () expects
8732 * iargs [0] to be a boxed instance, but luckily the vcall
8733 * will be transformed into a normal call there.
8734 */
8743 CHECK_CFG_ERROR;
8746 /*
8747 * TypeInitializationExceptions thrown from the mono_runtime_class_init
8748 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
8749 * As a workaround, we call class cctors before allocating objects.
8750 */
8751 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
8754 printf ("class %s.%s needs init call for ctor\n", m_class_get_name_space (cmethod->klass), m_class_get_name (cmethod->klass));
8756 }
8760 }
8766 /* Now call the actual ctor */
8768 CHECK_CFG_EXCEPTION;
8769 }
8772 /* Valuetype */
8778 }
8784 }
8791 UNVERIFIED;
8800 CHECK_CFG_EXCEPTION;
8805 }
8832 }
8837 /* LDOBJ */
8841 }
8845 }
8863 }
8868 UNVERIFIED;
8870 UNVERIFIED;
8871 /* frequent check in generic code: box (struct), brtrue */
8873 /*
8874 * Look for:
8875 *
8876 * <push int/long ptr>
8877 * <push int/long>
8878 * box MyFlags
8879 * constrained. MyFlags
8880 * callvirt instace bool class [mscorlib] System.Enum::HasFlag (class [mscorlib] System.Enum)
8881 *
8882 * If we find this sequence and the operand types on box and constrained
8883 * are equal, we can emit a specialized instruction sequence instead of
8884 * the very slow HasFlag () call.
8885 * This code sequence is generated by older mcs/csc, the newer one is handled in
8886 * emit_inst_for_method ().
8887 */
8888 guint32 constrained_token;
8889 guint32 callvirt_token;
8892 // FIXME ip_in_bb as we go?
8919 }
8920 }
8922 guint32 unbox_any_token;
8924 /*
8925 * Common in generic code:
8926 * box T1, unbox.any T2.
8927 */
8938 }
8939 }
8941 #ifdef ENABLE_NETCORE
8942 // Optimize
8943 //
8944 // box
8945 // ldnull
8946 // ceq (or cgt.un)
8947 //
8948 // to just
8949 //
8950 // ldc.i4.0 (or 1)
8952 if ((ldnull_ip = il_read_op (next_ip, end, CEE_LDNULL, MONO_CEE_LDNULL)) && ip_in_bb (cfg, cfg->cbb, ldnull_ip)) {
8967 }
8968 }
8969 #endif
8971 gboolean is_true;
8973 // FIXME: LLVM can't handle the inconsistent bb linking
8989 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8991 }
8993 /*
8994 * We need to link both bblocks, since it is needed for handling stack
8995 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
8996 * Branching to only one of them would lead to inconsistencies, so
8997 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
8998 */
9009 }
9018 /* The JIT can't eliminate the iconst+compare */
9022 }
9026 }
9028 if (m_class_is_enumtype (klass) && !mini_is_gsharedvt_klass (klass) && !(val->type == STACK_I8 && TARGET_SIZEOF_VOID_P == 4)) {
9029 /* Can't do this with 64 bit enums on 32 bit since the vtype decomp pass is ran after the long decomp pass */
9042 }
9045 /* Create domainvar early so it gets initialized earlier than this code */
9050 }
9051 CHECK_CFG_EXCEPTION;
9054 }
9068 EMIT_NEW_VARLOADA (cfg, ins, get_vreg_to_inst (cfg, val->dreg), m_class_get_byval_arg (val->klass));
9074 }
9077 }
9085 #ifndef DISABLE_REMOTING
9087 #endif
9088 guint foffset;
9089 gboolean is_instance;
9091 gboolean is_special_static;
9096 is_instance = (il_op == MONO_CEE_LDFLD || il_op == MONO_CEE_LDFLDA || il_op == MONO_CEE_STFLD);
9103 }
9105 UNVERIFIED;
9107 UNVERIFIED;
9110 sp--;
9112 }
9113 }
9118 }
9121 CHECK_CFG_ERROR;
9122 }
9128 /* if the class is Critical then transparent code cannot access it's fields */
9132 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
9133 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
9134 if (mono_security_core_clr_enabled ())
9135 ensure_method_is_allowed_to_access_field (cfg, method, field);
9136 */
9140 /*
9141 * LDFLD etc. is usable on static fields as well, so convert those cases to
9142 * the static case.
9143 */
9157 }
9159 }
9168 }
9169 }
9171 /* INSTANCE CASE */
9175 foffset = m_class_is_valuetype (klass) ? field->offset - MONO_ABI_SIZEOF (MonoObject): field->offset;
9179 UNVERIFIED;
9180 #ifndef DISABLE_REMOTING
9181 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
9190 EMIT_NEW_ICONST (cfg, iargs [3], m_class_is_valuetype (klass) ? field->offset - MONO_ABI_SIZEOF (MonoObject) :
9197 CHECK_CFG_EXCEPTION;
9205 }
9207 #endif
9208 {
9214 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
9216 }
9224 /* The value is offset by 1 */
9228 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !MONO_INS_IS_PCONST_NULL (sp [1])) {
9231 /* The decomposition will call mini_emit_memory_copy () which will emit a wbarrier if needed */
9233 }
9235 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !MONO_INS_IS_PCONST_NULL (sp [1])) {
9236 /* insert call to write barrier */
9245 }
9246 }
9252 }
9254 }
9256 #ifndef DISABLE_REMOTING
9257 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
9258 MonoMethod *wrapper = (il_op == MONO_CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
9266 EMIT_NEW_ICONST (cfg, iargs [3], m_class_is_valuetype (klass) ? field->offset - MONO_ABI_SIZEOF (MonoObject) : field->offset);
9270 CHECK_CFG_EXCEPTION;
9281 }
9283 #endif
9288 /* Have to compute the address of the variable */
9292 var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (klass), OP_LOCAL, sp [0]->dreg);
9293 else
9298 }
9304 }
9312 /* The value is offset by 1 */
9317 }
9326 #ifdef MONO_ARCH_SIMD_INTRINSICS
9332 }
9333 }
9334 #endif
9341 /* The value is offset by 1 */
9343 EMIT_NEW_BIALU (cfg, field_add_inst, OP_PADD, alloc_ireg_mp (cfg), sp [0]->dreg, offset_ins->dreg);
9345 }
9352 }
9353 }
9358 /* STATIC CASE */
9362 mono_error_set_field_missing (cfg->error, field->parent, field->name, NULL, "Using static instructions with literal field");
9363 CHECK_CFG_ERROR;
9364 }
9366 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
9367 * to be called here.
9368 */
9371 CHECK_CFG_ERROR;
9373 }
9383 else
9386 /* Generate IR to compute the field address */
9387 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
9388 /*
9389 * Fast access to TLS data
9390 * Inline version of get_thread_static_data () in
9391 * threads.c.
9392 */
9393 guint32 offset;
9400 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
9405 /* For TLS variables, this will return the TLS offset */
9411 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHL_IMM, idx_reg, idx_reg, TARGET_SIZEOF_VOID_P == 8 ? 3 : 2);
9428 }
9441 }
9446 /*
9447 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
9448 method->klass->name_space, method->klass->name, method->name,
9449 depth, field->offset);
9450 */
9455 /*
9456 * The pointer we're computing here is
9457 *
9458 * super_info.static_data + field->offset
9459 */
9467 /* The value is offset by 1 */
9476 }
9489 CHECK_CFG_ERROR;
9497 printf ("class %s.%s needs init call for %s\n", m_class_get_name_space (klass), m_class_get_name (klass), mono_field_get_name (field));
9499 }
9502 /* This makes so that inline cannot trigger */
9503 /* .cctors: too many apps depend on them */
9504 /* running with a specific order... */
9511 }
9512 }
9513 }
9521 }
9526 }
9527 }
9529 /* Generate IR to do the actual load/store operation */
9533 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
9537 }
9538 }
9556 CHECK_CFG_ERROR;
9558 }
9559 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
9560 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
9566 }
9570 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
9576 sp++;
9580 sp++;
9585 sp++;
9589 sp++;
9594 sp++;
9598 sp++;
9606 sp++;
9616 sp++;
9619 }
9624 sp++;
9632 }
9633 }
9641 }
9642 }
9644 field_access_end:
9645 if ((il_op == MONO_CEE_LDFLD || il_op == MONO_CEE_LDSFLD) && (ins_flag & MONO_INST_VOLATILE)) {
9646 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
9648 }
9652 }
9658 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
9664 /*
9665 * Array opcodes
9666 */
9671 guint32 field_token;
9678 UNVERIFIED;
9689 }
9696 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
9698 /* vtable */
9701 /* array len */
9706 else
9710 /* Decompose now to avoid problems with references to the domainvar */
9719 /* Decompose later since it is needed by abcrem */
9722 CHECK_CFG_ERROR;
9735 /* Needed so mono_emit_load_get_addr () gets called */
9737 }
9738 }
9745 /*
9746 * we inline/optimize the initialization sequence if possible.
9747 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
9748 * for small sizes open code the memcpy
9749 * ensure the rva field is big enough
9750 */
9762 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
9764 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, m_class_get_image (method->klass), GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
9767 }
9770 }
9773 }
9777 UNVERIFIED;
9784 /* This flag will be inherited by the decomposition */
9795 UNVERIFIED;
9801 /* we need to make sure that this array is exactly the type it needs
9802 * to be for correctness. the wrappers are lax with their usage
9803 * so we need to ignore them here
9804 */
9809 }
9835 }
9836 else
9840 UNVERIFIED;
9845 // FIXME-VT: OP_ICONST optimization
9852 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
9862 }
9865 }
9883 }
9884 else
9888 UNVERIFIED;
9895 }
9913 }
9916 }
9932 // FIXME:
9935 src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.typed_reference_class), OP_LOCAL, sp [0]->dreg);
9937 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
9945 // FIXME:
9950 }
9951 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
9956 }
9969 loc = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.typed_reference_class), OP_LOCAL);
9972 MonoInst *const_ins = mini_emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
9975 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
9976 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, m_class_offsetof_byval_arg ());
9977 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
9979 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
9986 }
9988 gpointer handle;
9997 }
10000 CHECK_CFG_ERROR;
10001 }
10003 LOAD_ERROR;
10008 /* This case handles ldtoken
10009 of an open type, like for
10010 typeof(Gen<>). */
10013 context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type_internal ((MonoType *)handle));
10018 else
10020 }
10041 }
10062 if (mono_class_get_checked (m_class_get_image (tclass), m_class_get_type_token (tclass), error) == tclass && !generic_context) {
10063 /* Special case for static synchronized wrappers */
10064 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, m_class_get_image (tclass), m_class_get_type_token (tclass), generic_context);
10067 /* FIXME: n is not a normal token */
10070 }
10073 }
10075 MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, cfg->error);
10076 CHECK_CFG_ERROR;
10078 }
10092 MONO_RGCTX_INFO_TYPE);
10101 }
10106 }
10110 }
10111 }
10115 }
10118 UNVERIFIED;
10131 /* This can complicate code generation for llvm since the return value might not be defined */
10137 UNVERIFIED;
10138 /* mono_save_seq_point_info () depends on this */
10145 /*
10146 * Control will leave the method so empty the stack, otherwise
10147 * the next basic block will start with a nonempty stack.
10148 */
10150 sp--;
10151 }
10157 /* empty the stack */
10161 /*
10162 * If this leave statement is in a catch block, check for a
10163 * pending exception, and rethrow it if necessary.
10164 * We avoid doing this in runtime invoke wrappers, since those are called
10165 * by native code which excepts the wrapper to catch all exceptions.
10166 */
10170 /*
10171 * Use <= in the final comparison to handle clauses with multiple
10172 * leave statements, like in bug #78024.
10173 * The ordering of the exception clauses guarantees that we find the
10174 * innermost clause.
10175 */
10176 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((il_op == MONO_CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
10180 /*
10181 MonoInst *load;
10183 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
10184 */
10190 /*
10191 * Currently, we always rethrow the abort exception, despite the
10192 * fact that this is not correct. See thread6.cs for an example.
10193 * But propagating the abort exception is more important than
10194 * getting the semantics right.
10195 */
10201 }
10202 }
10204 #ifdef ENABLE_LLVM
10206 #endif
10210 /*
10211 * For each finally clause that we exit we need to invoke the finally block.
10212 * After each invocation we need to add try holes for all the clauses that
10213 * we already exited.
10214 */
10225 /*
10226 * Emit instrumentation code before linking the basic blocks below as this
10227 * will alter cfg->cbb.
10228 */
10243 /* Throw exception if exvar is set */
10244 /* FIXME Do we need this for calls from catch/filter ? */
10257 /*
10258 * Link the finally bblock with the target, since it will
10259 * conceptually branch there.
10260 */
10264 }
10265 }
10266 }
10276 }
10278 /*
10279 * Mono specific opcodes
10280 */
10295 /*
10296 * This is called on unattached threads, so it cannot go through the trampoline
10297 * infrastructure. Use an indirect call through a got slot initialized at load time
10298 * instead.
10299 */
10300 EMIT_NEW_AOTCONST (cfg, addr, MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL, GUINT_TO_POINTER (jit_icall_id));
10304 }
10306 /*
10307 * Parts of the initlocals code needs to come after this, since it might call methods like memset.
10308 */
10314 }
10321 }
10323 MonoJumpInfoType ldptr_type;
10339 mono_ldptr:
10347 gpointer ptr;
10354 /* Can't embed random pointers into AOT code */
10357 }
10367 gpointer ptr;
10375 /*
10376 * This is generated by emit_native_wrapper () to resolve the pinvoke address
10377 * before the call, its not needed when using direct pinvoke.
10378 * This is not an optimization, but its used to avoid looking up pinvokes
10379 * on platforms which don't support dlopen ().
10380 */
10384 }
10389 }
10392 }
10399 // FIXME:
10404 }
10418 }
10430 /*
10431 * Similar to LDOBJ, but instead load the unmanaged
10432 * representation of the vtype to the stack.
10433 */
10440 {
10454 }
10457 /*
10458 * Same as RET, but return the native representation of a vtype
10459 * to the caller.
10460 */
10474 }
10478 UNVERIFIED;
10488 }
10504 MonoTlsKey key;
10515 }
10519 /* It would be easier to call a trampoline, but that would put an
10520 * extra frame on the stack, confusing exception handling. So
10521 * implement it inline using an opcode for now.
10522 */
10527 /* prevent it from being register allocated */
10529 }
10531 /* Has to use a call inst since local regalloc expects it */
10540 /* OP_DYN_CALL might need to allocate a dynamically sized param area */
10545 }
10550 }
10563 }
10569 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, sp [0]->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr));
10572 }
10578 /*
10579 * This is the same as CEE_CALLI, but passes an additional argument
10580 * to the called method in llvmonly mode.
10581 * This is only used by delegate invoke wrappers to call the
10582 * actual delegate method.
10583 */
10593 CHECK_CFG_ERROR;
10606 /*
10607 * The lowest bit of 'arg' determines whenever the callee uses the gsharedvt
10608 * cconv. This is set by mono_init_delegate ().
10609 */
10623 /* Normal case: callee uses a normal cconv, have to add an out wrapper */
10626 /*
10627 * ADDR points to a gsharedvt-out wrapper, have to pass <callee, arg> as an extra arg.
10628 */
10636 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, TARGET_SIZEOF_VOID_P, arg->dreg);
10641 /* Gsharedvt case: callee uses a gsharedvt cconv, no conversion is needed */
10649 /* Caller uses a normal calling conv */
10663 /* Normal case: callee uses a normal cconv, no conversion is needed */
10666 /* Gsharedvt case: callee uses a gsharedvt cconv, have to add an in wrapper */
10671 /*
10672 * ADDR points to a gsharedvt-in wrapper, have to pass <callee, arg> as an extra arg.
10673 */
10681 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, TARGET_SIZEOF_VOID_P, arg->dreg);
10688 }
10690 /* Same as CEE_CALLI */
10692 /*
10693 * We pass the address to the gsharedvt trampoline in the rgctx reg
10694 */
10702 }
10703 }
10708 CHECK_CFG_EXCEPTION;
10713 }
10722 // Just an IL prefix, setting this flag, picked up by call instructions.
10739 /* Used by COOP only, so this is good enough */
10744 }
10747 /* somewhat similar to LDTOKEN */
10749 vtvar = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.argumenthandle_class), OP_LOCAL);
10759 }
10771 /*
10772 * The following transforms:
10773 * CEE_CEQ into OP_CEQ
10774 * CEE_CGT into OP_CGT
10775 * CEE_CGT_UN into OP_CGT_UN
10776 * CEE_CLT into OP_CLT
10777 * CEE_CLT_UN into OP_CLT_UN
10778 */
10787 if ((arg1->type == STACK_I8) || ((TARGET_SIZEOF_VOID_P == 8) && ((arg1->type == STACK_PTR) || (arg1->type == STACK_OBJ) || (arg1->type == STACK_MP))))
10793 else
10801 /*
10802 * The backends expect the fceq opcodes to do the
10803 * comparison too.
10804 */
10808 }
10812 }
10818 CHECK_CFG_ERROR;
10827 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
10833 /*
10834 * Optimize the common case of ldftn+delegate creation
10835 */
10836 if ((sp > stack_start) && (next_ip + 4 < end) && ip_in_bb (cfg, cfg->cbb, next_ip) && (next_ip [0] == CEE_NEWOBJ)) {
10837 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (next_ip + 1), NULL, generic_context);
10838 if (ctor_method && (m_class_get_parent (ctor_method->klass) == mono_defaults.multicastdelegate_class)) {
10845 LOAD_ERROR;
10855 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
10856 if (mono_method_signature_internal (invoke)->param_count == mono_method_signature_internal (cmethod)->param_count) {
10859 }
10860 }
10864 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip + 6, NULL));
10865 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, invoke_context_used, FALSE))) {
10866 sp --;
10868 CHECK_CFG_EXCEPTION;
10869 sp ++;
10874 CHECK_CFG_ERROR;
10875 }
10876 }
10877 }
10878 }
10886 }
10891 CHECK_CFG_ERROR;
10900 /*
10901 * Optimize the common case of ldvirtftn+delegate creation
10902 */
10903 if (previous_il_op == MONO_CEE_DUP && (sp > stack_start) && (next_ip + 4 < end) && ip_in_bb (cfg, cfg->cbb, next_ip) && (next_ip [0] == CEE_NEWOBJ)) {
10904 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (next_ip + 1), NULL, generic_context);
10905 if (ctor_method && (m_class_get_parent (ctor_method->klass) == mono_defaults.multicastdelegate_class)) {
10913 LOAD_ERROR;
10924 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip + 6, NULL));
10925 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, invoke_context_used, is_virtual))) {
10928 CHECK_CFG_EXCEPTION;
10931 sp ++;
10934 CHECK_CFG_ERROR;
10935 }
10936 }
10937 }
10938 }
10948 else
10953 }
10959 UNVERIFIED;
10961 /*
10962 * Inlining this into a loop in a parent could lead to
10963 * stack overflows which is different behavior than the
10964 * non-inlined case, thus disable inlining in this case.
10965 */
10971 /* if size != zero */
10975 //size is zero, so result is NULL
10996 }
11003 UNVERIFIED;
11013 ((next_ip - header->code) > clause->data.filter_offset && (next_ip - header->code) <= clause->handler_offset) &&
11016 }
11019 UNVERIFIED;
11022 }
11025 /* FIXME: record alignment? we can assume 1 for now */
11033 /* Can't inline tailcalls at this time */
11042 else
11067 /* we ignore the no-nullcheck for now since we
11068 * really do it explicitly only when doing callvirt->call
11069 */
11077 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
11080 }
11081 }
11086 UNVERIFIED;
11100 }
11103 UNVERIFIED;
11116 /* This can complicate code generation for llvm since the return value might not be defined */
11120 }
11122 guint32 val;
11125 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (m_class_get_image (method->klass)) && !generic_context) {
11127 CHECK_CFG_ERROR;
11141 }
11142 }
11146 }
11154 // FIXME:
11157 src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.typed_reference_class), OP_LOCAL, sp [0]->dreg);
11159 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, m_class_get_byval_arg (mono_defaults.typehandle_class), src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
11162 }
11174 UNVERIFIED;
11178 UNVERIFIED;
11179 }
11180 }
11182 UNVERIFIED;
11186 /* This could already be set because of inlining, #693905 */
11194 }
11206 }
11208 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
11210 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
11212 #endif
11221 /*
11222 * Vtype initialization might need to be done after CEE_JIT_ATTACH, since it can make calls to memset (),
11223 * which need the trampoline code to work.
11224 */
11227 else
11230 }
11231 }
11234 /* Emit initialization for ref vars */
11235 // FIXME: Avoid duplication initialization for IL locals.
11241 }
11242 }
11247 }
11255 /*
11256 * Make seq points at backward branch targets interruptable.
11257 */
11261 }
11263 /* Add a sequence point for method entry/exit events */
11269 }
11271 /*
11272 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
11273 * the code they refer to was dead (#11880).
11274 */
11277 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
11282 }
11283 }
11284 }
11292 /* get_most_deep_clause () in mini-llvm.c depends on this for inlined bblocks */
11295 }
11296 }
11301 /* Method is too large */
11303 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Method %s is too complex.", mname));
11305 }
11312 mono_error_exit:
11319 exception_exit:
11326 unverified:
11333 cleanup:
11339 else
11341 }
11343 static int
11345 {
11359 }
11362 }
11364 int
11366 {
11411 #if SIZEOF_REGISTER == 8
11416 #endif
11434 #if defined(TARGET_X86) || defined (TARGET_AMD64)
11439 #endif
11440 #if defined(TARGET_AMD64)
11443 #endif
11454 }
11457 }
11459 static int
11461 {
11480 }
11483 }
11485 int
11487 {
11488 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
11489 #if defined(TARGET_X86) || defined(TARGET_AMD64)
11501 #if SIZEOF_REGISTER == 8
11504 #endif
11505 }
11506 #endif
11509 }
11511 static int
11513 {
11514 #if defined(TARGET_X86)
11546 }
11547 #endif
11549 #if defined(TARGET_AMD64)
11550 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
11601 }
11602 #endif
11605 }
11607 static int
11609 {
11610 #if defined(TARGET_X86) || defined(TARGET_AMD64)
11618 }
11619 #endif
11622 }
11624 static int
11626 {
11627 #ifdef TARGET_X86
11628 /* FIXME: This has sign extension issues */
11629 /*
11630 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
11631 return OP_X86_COMPARE_MEMBASE8_IMM;
11632 */
11634 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11646 }
11647 #endif
11649 #ifdef TARGET_AMD64
11650 /* FIXME: This has sign extension issues */
11651 /*
11652 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
11653 return OP_X86_COMPARE_MEMBASE8_IMM;
11654 */
11658 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
11661 /* FIXME: This only works for 32 bit immediates
11662 case OP_COMPARE_IMM:
11663 case OP_LCOMPARE_IMM:
11664 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
11665 return OP_AMD64_COMPARE_MEMBASE_IMM;
11666 */
11675 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
11682 }
11683 #endif
11686 }
11688 static int
11690 {
11691 #ifdef TARGET_X86
11692 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
11709 }
11710 #endif
11712 #ifdef TARGET_AMD64
11713 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && cfg->backend->ilp32)) {
11727 }
11728 } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32)) {
11743 }
11744 }
11745 #endif
11748 }
11750 int
11752 {
11754 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
11759 #endif
11760 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
11766 #endif
11767 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
11770 #endif
11773 }
11774 }
11776 /**
11777 * mono_handle_global_vregs:
11778 *
11779 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
11780 * for them.
11781 */
11782 void
11784 {
11789 vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
11791 #ifdef MONO_ARCH_SIMD_INTRINSICS
11794 #endif
11796 /* Find local vregs used in more than one bb */
11808 gint32 prev_bb;
11838 }
11840 #if SIZEOF_REGISTER == 4
11841 /* In the LLVM case, the long opcodes are not decomposed */
11843 /*
11844 * Since some instructions reference the original long vreg,
11845 * and some reference the two component vregs, it is quite hard
11846 * to determine when it needs to be global. So be conservative.
11847 */
11849 mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.int64_class), OP_LOCAL, vreg);
11853 }
11855 /*
11856 * Make the component vregs volatile since the optimizations can
11857 * get confused otherwise.
11858 */
11861 }
11862 #endif
11868 /* 0 is a valid block num */
11871 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
11882 else
11886 mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.int64_class), OP_LOCAL, vreg);
11889 mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.double_class), OP_LOCAL, vreg);
11897 }
11898 }
11900 /* Flag as having been used in more than one bb */
11902 }
11903 }
11904 }
11905 }
11907 /* If a variable is used in only one bblock, convert it into a local vreg */
11918 #if SIZEOF_REGISTER == 8
11920 #endif
11921 #if !defined(TARGET_X86)
11922 /* Enabling this screws up the fp stack on x86 */
11924 #endif
11928 /*
11929 if (var->type == STACK_VTYPE && cfg->gsharedvt && mini_is_gsharedvt_variable_type (var->inst_vtype))
11930 break;
11931 */
11933 /* Arguments are implicitly global */
11934 /* Putting R4 vars into registers doesn't work currently */
11935 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
11936 if ((var->opcode != OP_ARG) && (var != cfg->ret) && !(var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && (vreg_to_bb [var->dreg] != -1) && (m_class_get_byval_arg (var->klass)->type != MONO_TYPE_R4) && !cfg->disable_vreg_to_lvreg && var != cfg->gsharedvt_info_var && var != cfg->gsharedvt_locals_var && var != cfg->lmf_addr_var) {
11937 /*
11938 * Make that the variable's liveness interval doesn't contain a call, since
11939 * that would cause the lvreg to be spilled, making the whole optimization
11940 * useless.
11941 */
11942 /* This is too slow for JIT compilation */
11943 #if 0
11963 }
11964 }
11969 ins_index ++;
11970 }
11974 }
11975 #endif
11981 }
11983 }
11984 }
11986 /*
11987 * Compress the varinfo and vars tables so the liveness computation is faster and
11988 * takes up less space.
11989 */
12001 #if SIZEOF_REGISTER == 4
12003 /* Modify the two component vars too */
12010 }
12011 #endif
12012 }
12013 pos ++;
12014 }
12015 }
12019 }
12021 /*
12022 * mono_allocate_gsharedvt_vars:
12023 *
12024 * Allocate variables with gsharedvt types to entries in the MonoGSharedVtMethodRuntimeInfo.entries array.
12025 * Initialize cfg->gsharedvt_vreg_to_idx with the mapping between vregs and indexes.
12026 */
12027 void
12029 {
12032 cfg->gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
12040 /* Local */
12046 /* Arg */
12049 }
12050 }
12051 }
12052 }
12054 /**
12055 * mono_spill_global_vars:
12056 *
12057 * Generate spill code for variables which are not allocated to registers,
12058 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
12059 * code is generated which could be optimized by the local optimization passes.
12060 */
12061 void
12063 {
12079 /* FIXME: Move this function to mini.c */
12083 #ifdef MONO_ARCH_SIMD_INTRINSICS
12085 #endif
12087 #if SIZEOF_REGISTER == 4
12088 /* Create MonoInsts for longs */
12115 }
12118 }
12119 }
12120 }
12121 #endif
12124 /* registers need liveness info even for !non refs */
12130 }
12131 }
12133 /* FIXME: widening and truncation */
12135 /*
12136 * As an optimization, when a variable allocated to the stack is first loaded into
12137 * an lvreg, we will remember the lvreg and use it the next time instead of loading
12138 * the variable again.
12139 */
12141 vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
12146 /*
12147 * These arrays contain the first and last instructions accessing a given
12148 * variable.
12149 * Since we emit bblocks in the same order we process them here, and we
12150 * don't split live ranges, these will precisely describe the live range of
12151 * the variable, i.e. the instruction range where a valid value can be found
12152 * in the variables location.
12153 * The live range is computed using the liveness info computed by the liveness pass.
12154 * We can't use vmv->range, since that is an abstract live range, and we need
12155 * one which is instruction precise.
12156 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
12157 */
12158 /* FIXME: Only do this if debugging info is requested */
12164 /* Add spill loads/stores */
12171 /* Clear vreg_to_lvreg array */
12189 /*
12190 * We handle LDADDR here as well, since it can only be decomposed
12191 * when variable addresses are known.
12192 */
12197 /* Happens on SPARC/S390 where vtypes are passed by reference */
12202 }
12208 NOT_IMPLEMENTED;
12210 /* gsharedvt arg passed by ref */
12223 /*
12224 * gsharedvt local.
12225 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
12226 */
12233 /* Mark the instruction used to compute the locals var as used */
12236 /* Load the offset */
12239 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
12245 }
12247 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * TARGET_SIZEOF_VOID_P));
12248 /* Load the locals area address */
12251 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
12256 }
12257 /* Compute the address */
12272 }
12276 }
12281 }
12283 /*
12284 * Store opcodes have destbasereg in the dreg, but in reality, it is an
12285 * src register.
12286 * FIXME:
12287 */
12301 else
12311 }
12313 /***************/
12314 /* DREG */
12315 /***************/
12317 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
12332 } 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)) {
12333 /*
12334 * Instead of emitting a load+store, use a _membase opcode.
12335 */
12346 }
12349 guint32 lvreg;
12355 /* Invalidate any previous lvreg for this vreg */
12363 }
12367 #if SIZEOF_REGISTER != 8
12369 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));
12371 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));
12374 }
12375 else
12376 #endif
12377 {
12380 /* Try to fuse the store into the instruction itself */
12381 /* FIXME: Add more instructions */
12382 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
12388 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE) || (ins->opcode == OP_RMOVE))) {
12406 // FIXME: The backends expect the base reg to be in inst_basereg
12413 /* printf ("INS: "); mono_print_ins (ins); */
12414 /* Create a store instruction */
12415 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
12417 /* Insert it after the instruction */
12422 /*
12423 * We can't assign ins->dreg to var->dreg here, since the
12424 * sregs could use it. So set a flag, and do it after
12425 * the sregs.
12426 */
12427 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)))
12429 }
12430 }
12431 }
12436 }
12444 }
12445 }
12447 /************/
12448 /* SREGS */
12449 /************/
12460 guint32 load_opcode;
12464 //mono_inst_set_src_registers (ins, sregs);
12468 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
12472 /* var->dreg is a hreg */
12475 }
12478 }
12489 /* The variable is already loaded to an lvreg */
12493 //mono_inst_set_src_registers (ins, sregs);
12495 }
12497 /* Try to fuse the load into the instruction */
12501 //mono_inst_set_src_registers (ins, sregs);
12503 } else if ((srcindex == 1) && (op_to_op_src2_membase (cfg, load_opcode, ins->opcode) != -1)) {
12506 //mono_inst_set_src_registers (ins, sregs);
12513 //printf ("%d ", srcindex); mono_print_ins (ins);
12517 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) {
12519 /*
12520 * sreg refers to the value loaded by the load
12521 * emitted below, but we need to use ins->dreg
12522 * since it refers to the store emitted earlier.
12523 */
12525 }
12529 printf ("\tCan't cache R%d because it's part of a dreg dest_membase optimization\n", var->dreg);
12532 }
12538 }
12540 }
12541 }
12544 //mono_inst_set_src_registers (ins, sregs);
12546 #if SIZEOF_REGISTER != 8
12548 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_MS (sreg), var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
12550 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_LS (sreg), var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
12553 }
12554 else
12555 #endif
12556 {
12557 #if SIZEOF_REGISTER == 4
12559 #endif
12563 }
12566 }
12571 }
12573 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
12579 }
12580 }
12581 }
12592 }
12595 }
12601 }
12604 /* Clear vreg_to_lvreg array */
12611 }
12615 }
12617 /* Extend the live range based on the liveness info */
12623 /* The liveness info is incomplete */
12627 /* Live from at least the first ins of this bb */
12630 }
12633 /* Live at least until the last ins of this bb */
12636 }
12637 }
12638 }
12639 }
12641 /*
12642 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
12643 * by storing the current native offset into MonoMethodVar->live_range_start/end.
12644 */
12655 }
12662 else
12664 }
12665 }
12666 }
12669 /* Nullify if unused */
12672 }
12678 }
12680 /**
12681 * FIXME:
12682 * - use 'iadd' instead of 'int_add'
12683 * - handling ovf opcodes: decompose in method_to_ir.
12684 * - unify iregs/fregs
12685 * -> partly done, the missing parts are:
12686 * - a more complete unification would involve unifying the hregs as well, so
12687 * code wouldn't need if (fp) all over the place. but that would mean the hregs
12688 * would no longer map to the machine hregs, so the code generators would need to
12689 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
12690 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
12691 * fp/non-fp branches speeds it up by about 15%.
12692 * - use sext/zext opcodes instead of shifts
12693 * - add OP_ICALL
12694 * - get rid of TEMPLOADs if possible and use vregs instead
12695 * - clean up usage of OP_P/OP_ opcodes
12696 * - cleanup usage of DUMMY_USE
12697 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
12698 * stack
12699 * - set the stack type and allocate a dreg in the EMIT_NEW macros
12700 * - get rid of all the <foo>2 stuff when the new JIT is ready.
12701 * - make sure handle_stack_args () is called before the branch is emitted
12702 * - when the new IR is done, get rid of all unused stuff
12703 * - COMPARE/BEQ as separate instructions or unify them ?
12704 * - keeping them separate allows specialized compare instructions like
12705 * compare_imm, compare_membase
12706 * - most back ends unify fp compare+branch, fp compare+ceq
12707 * - integrate mono_save_args into inline_method
12708 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
12709 * - handle long shift opts on 32 bit platforms somehow: they require
12710 * 3 sregs (2 for arg1 and 1 for arg2)
12711 * - make byref a 'normal' type.
12712 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
12713 * variable if needed.
12714 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
12715 * like inline_method.
12716 * - remove inlining restrictions
12717 * - fix LNEG and enable cfold of INEG
12718 * - generalize x86 optimizations like ldelema as a peephole optimization
12719 * - add store_mem_imm for amd64
12720 * - optimize the loading of the interruption flag in the managed->native wrappers
12721 * - avoid special handling of OP_NOP in passes
12722 * - move code inserting instructions into one function/macro.
12723 * - try a coalescing phase after liveness analysis
12724 * - add float -> vreg conversion + local optimizations on !x86
12725 * - figure out how to handle decomposed branches during optimizations, ie.
12726 * compare+branch, op_jump_table+op_br etc.
12727 * - promote RuntimeXHandles to vregs
12728 * - vtype cleanups:
12729 * - add a NEW_VARLOADA_VREG macro
12730 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
12731 * accessing vtype fields.
12732 * - get rid of I8CONST on 64 bit platforms
12733 * - dealing with the increase in code size due to branches created during opcode
12734 * decomposition:
12735 * - use extended basic blocks
12736 * - all parts of the JIT
12737 * - handle_global_vregs () && local regalloc
12738 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
12739 * - sources of increase in code size:
12740 * - vtypes
12741 * - long compares
12742 * - isinst and castclass
12743 * - lvregs not allocated to global registers even if used multiple times
12744 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
12745 * meaningful.
12746 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
12747 * - add all micro optimizations from the old JIT
12748 * - put tree optimizations into the deadce pass
12749 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
12750 * specific function.
12751 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
12752 * fcompare + branchCC.
12753 * - create a helper function for allocating a stack slot, taking into account
12754 * MONO_CFG_HAS_SPILLUP.
12755 * - merge r68207.
12756 * - optimize mono_regstate2_alloc_int/float.
12757 * - fix the pessimistic handling of variables accessed in exception handler blocks.
12758 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
12759 * parts of the tree could be separated by other instructions, killing the tree
12760 * arguments, or stores killing loads etc. Also, should we fold loads into other
12761 * instructions if the result of the load is used multiple times ?
12762 * - make the REM_IMM optimization in mini-x86.c arch-independent.
12763 * - LAST MERGE: 108395.
12764 * - when returning vtypes in registers, generate IR and append it to the end of the
12765 * last bb instead of doing it in the epilog.
12766 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
12767 */
12769 /*
12771 NOTES
12772 -----
12774 - When to decompose opcodes:
12775 - earlier: this makes some optimizations hard to implement, since the low level IR
12776 no longer contains the neccessary information. But it is easier to do.
12777 - later: harder to implement, enables more optimizations.
12778 - Branches inside bblocks:
12779 - created when decomposing complex opcodes.
12780 - branches to another bblock: harmless, but not tracked by the branch
12781 optimizations, so need to branch to a label at the start of the bblock.
12782 - branches to inside the same bblock: very problematic, trips up the local
12783 reg allocator. Can be fixed by spitting the current bblock, but that is a
12784 complex operation, since some local vregs can become global vregs etc.
12785 - Local/global vregs:
12786 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
12787 local register allocator.
12788 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
12789 structure, created by mono_create_var (). Assigned to hregs or the stack by
12790 the global register allocator.
12791 - When to do optimizations like alu->alu_imm:
12792 - earlier -> saves work later on since the IR will be smaller/simpler
12793 - later -> can work on more instructions
12794 - Handling of valuetypes:
12795 - When a vtype is pushed on the stack, a new temporary is created, an
12796 instruction computing its address (LDADDR) is emitted and pushed on
12797 the stack. Need to optimize cases when the vtype is used immediately as in
12798 argument passing, stloc etc.
12799 - Instead of the to_end stuff in the old JIT, simply call the function handling
12800 the values on the stack before emitting the last instruction of the bb.
12801 */