| blob | fc8f816db0a09d0c3bb97b1d487379881c7edbfc |
1 /*
2 * method-to-ir.c: Convert CIL to the JIT internal representation
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002 Ximian, Inc.
9 * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
10 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
11 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
12 */
14 #include <config.h>
15 #include <mono/utils/mono-compiler.h>
17 #ifndef DISABLE_JIT
19 #include <signal.h>
21 #ifdef HAVE_UNISTD_H
22 #include <unistd.h>
23 #endif
25 #include <math.h>
26 #include <string.h>
27 #include <ctype.h>
29 #ifdef HAVE_SYS_TIME_H
30 #include <sys/time.h>
31 #endif
33 #ifdef HAVE_ALLOCA_H
34 #include <alloca.h>
35 #endif
37 #include <mono/utils/memcheck.h>
39 #include <mono/metadata/abi-details.h>
40 #include <mono/metadata/assembly.h>
41 #include <mono/metadata/attrdefs.h>
42 #include <mono/metadata/loader.h>
43 #include <mono/metadata/tabledefs.h>
44 #include <mono/metadata/class.h>
45 #include <mono/metadata/object.h>
46 #include <mono/metadata/exception.h>
47 #include <mono/metadata/opcodes.h>
48 #include <mono/metadata/mono-endian.h>
49 #include <mono/metadata/tokentype.h>
50 #include <mono/metadata/tabledefs.h>
51 #include <mono/metadata/marshal.h>
52 #include <mono/metadata/debug-helpers.h>
53 #include <mono/metadata/mono-debug.h>
54 #include <mono/metadata/mono-debug-debugger.h>
55 #include <mono/metadata/gc-internals.h>
56 #include <mono/metadata/security-manager.h>
57 #include <mono/metadata/threads-types.h>
58 #include <mono/metadata/security-core-clr.h>
59 #include <mono/metadata/profiler-private.h>
60 #include <mono/metadata/profiler.h>
61 #include <mono/metadata/monitor.h>
62 #include <mono/metadata/debug-mono-symfile.h>
63 #include <mono/utils/mono-compiler.h>
64 #include <mono/utils/mono-memory-model.h>
65 #include <mono/utils/mono-error-internals.h>
66 #include <mono/metadata/mono-basic-block.h>
67 #include <mono/metadata/reflection-internals.h>
68 #include <mono/utils/mono-threads-coop.h>
81 #define BRANCH_COST 10
82 #define INLINE_LENGTH_LIMIT 20
84 /* These have 'cfg' as an implicit argument */
85 #define INLINE_FAILURE(msg) do { \
86 if ((cfg->method != cfg->current_method) && (cfg->current_method->wrapper_type == MONO_WRAPPER_NONE)) { \
87 inline_failure (cfg, msg); \
88 goto exception_exit; \
89 } \
90 } while (0)
91 #define CHECK_CFG_EXCEPTION do {\
92 if (cfg->exception_type != MONO_EXCEPTION_NONE) \
93 goto exception_exit; \
94 } while (0)
95 #define FIELD_ACCESS_FAILURE(method, field) do { \
96 field_access_failure ((cfg), (method), (field)); \
97 goto exception_exit; \
98 } while (0)
99 #define GENERIC_SHARING_FAILURE(opcode) do { \
100 if (cfg->gshared) { \
101 gshared_failure (cfg, opcode, __FILE__, __LINE__); \
102 goto exception_exit; \
103 } \
104 } while (0)
105 #define GSHAREDVT_FAILURE(opcode) do { \
106 if (cfg->gsharedvt) { \
107 gsharedvt_failure (cfg, opcode, __FILE__, __LINE__); \
108 goto exception_exit; \
109 } \
110 } while (0)
111 #define OUT_OF_MEMORY_FAILURE do { \
112 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
114 goto exception_exit; \
115 } while (0)
116 #define DISABLE_AOT(cfg) do { \
117 if ((cfg)->verbose_level >= 2) \
119 (cfg)->disable_aot = TRUE; \
120 } while (0)
121 #define LOAD_ERROR do { \
122 break_on_unverified (); \
123 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD); \
124 goto exception_exit; \
125 } while (0)
127 #define TYPE_LOAD_ERROR(klass) do { \
128 cfg->exception_ptr = klass; \
129 LOAD_ERROR; \
130 } while (0)
132 #define CHECK_CFG_ERROR do {\
133 if (!mono_error_ok (&cfg->error)) { \
134 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
135 goto mono_error_exit; \
136 } \
137 } while (0)
139 /* Determine whenever 'ins' represents a load of the 'this' argument */
140 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
148 MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
150 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
153 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp);
155 /* helper methods signatures */
161 /* type loading helpers */
162 static GENERATE_GET_CLASS_WITH_CACHE (runtime_helpers, System.Runtime.CompilerServices, RuntimeHelpers)
163 static GENERATE_TRY_GET_CLASS_WITH_CACHE (debuggable_attribute, System.Diagnostics, DebuggableAttribute)
165 /*
166 * Instruction metadata
167 */
168 #ifdef MINI_OP
169 #undef MINI_OP
170 #endif
171 #ifdef MINI_OP3
172 #undef MINI_OP3
173 #endif
175 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
181 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == SIZEOF_VOID_P
182 #define LREG IREG
183 #else
185 #endif
186 /* keep in sync with the enum in mini.h */
187 const char
188 ins_info[] = {
190 };
191 #undef MINI_OP
192 #undef MINI_OP3
194 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
195 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
196 /*
197 * This should contain the index of the last sreg + 1. This is not the same
198 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
199 */
202 };
203 #undef MINI_OP
204 #undef MINI_OP3
206 #define MONO_INIT_VARINFO(vi,id) do { \
207 (vi)->range.first_use.pos.bid = 0xffff; \
208 (vi)->reg = -1; \
209 (vi)->idx = (id); \
210 } while (0)
212 guint32
214 {
216 }
218 guint32
220 {
222 }
224 guint32
226 {
228 }
230 guint32
232 {
234 }
236 guint32
238 {
240 }
242 /*
243 * mono_alloc_ireg_ref:
244 *
245 * Allocate an IREG, and mark it as holding a GC ref.
246 */
247 guint32
249 {
251 }
253 /*
254 * mono_alloc_ireg_mp:
255 *
256 * Allocate an IREG, and mark it as holding a managed pointer.
257 */
258 guint32
260 {
262 }
264 /*
265 * mono_alloc_ireg_copy:
266 *
267 * Allocate an IREG with the same GC type as VREG.
268 */
269 guint32
271 {
276 else
278 }
280 guint
282 {
287 handle_enum:
311 #if SIZEOF_REGISTER == 8
313 #else
315 #endif
324 }
340 else
344 }
346 }
348 void
350 {
363 }
365 void
367 {
372 }
376 {
379 }
383 {
387 mono_error_set_generic_error (&cfg->error, "System", "FieldAccessException", "Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);
390 }
394 {
398 }
402 {
404 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), line);
406 }
410 {
411 cfg->exception_message = g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), file, line);
415 }
417 /*
418 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
419 * foo<T> (int i) { ldarg.0; box T; }
420 */
421 #define UNVERIFIED do { \
422 if (cfg->gsharedvt) { \
423 if (cfg->verbose_level > 2) \
425 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
426 goto exception_exit; \
427 } \
428 break_on_unverified (); \
429 goto unverified; \
430 } while (0)
432 #define GET_BBLOCK(cfg,tblock,ip) do { \
433 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
434 if (!(tblock)) { \
435 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
436 NEW_BBLOCK (cfg, (tblock)); \
437 (tblock)->cil_code = (ip); \
438 ADD_BBLOCK (cfg, (tblock)); \
439 } \
440 } while (0)
442 #if defined(TARGET_X86) || defined(TARGET_AMD64)
443 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
444 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
445 (dest)->dreg = alloc_ireg_mp ((cfg)); \
446 (dest)->sreg1 = (sr1); \
447 (dest)->sreg2 = (sr2); \
448 (dest)->inst_imm = (imm); \
449 (dest)->backend.shift_amount = (shift); \
450 MONO_ADD_INS ((cfg)->cbb, (dest)); \
451 } while (0)
452 #endif
454 /* Emit conversions so both operands of a binary opcode are of the same type */
455 static void
457 {
466 /* Mixing r4/r8 is allowed by the spec */
474 }
482 }
483 }
485 #if SIZEOF_REGISTER == 8
486 /* FIXME: Need to add many more cases */
493 }
494 #endif
495 }
497 #define ADD_BINOP(op) do { \
498 MONO_INST_NEW (cfg, ins, (op)); \
499 sp -= 2; \
500 ins->sreg1 = sp [0]->dreg; \
501 ins->sreg2 = sp [1]->dreg; \
502 type_from_op (cfg, ins, sp [0], sp [1]); \
503 CHECK_TYPE (ins); \
505 add_widen_op (cfg, ins, &sp [0], &sp [1]); \
506 ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
507 MONO_ADD_INS ((cfg)->cbb, (ins)); \
508 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
509 } while (0)
511 #define ADD_UNOP(op) do { \
512 MONO_INST_NEW (cfg, ins, (op)); \
513 sp--; \
514 ins->sreg1 = sp [0]->dreg; \
515 type_from_op (cfg, ins, sp [0], NULL); \
516 CHECK_TYPE (ins); \
517 (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
518 MONO_ADD_INS ((cfg)->cbb, (ins)); \
519 *sp++ = mono_decompose_opcode (cfg, ins); \
520 } while (0)
522 #define ADD_BINCOND(next_block) do { \
523 MonoInst *cmp; \
524 sp -= 2; \
525 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
526 cmp->sreg1 = sp [0]->dreg; \
527 cmp->sreg2 = sp [1]->dreg; \
528 type_from_op (cfg, cmp, sp [0], sp [1]); \
529 CHECK_TYPE (cmp); \
530 add_widen_op (cfg, cmp, &sp [0], &sp [1]); \
531 type_from_op (cfg, ins, sp [0], sp [1]); \
532 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
533 GET_BBLOCK (cfg, tblock, target); \
534 link_bblock (cfg, cfg->cbb, tblock); \
535 ins->inst_true_bb = tblock; \
536 if ((next_block)) { \
537 link_bblock (cfg, cfg->cbb, (next_block)); \
538 ins->inst_false_bb = (next_block); \
539 start_new_bblock = 1; \
540 } else { \
541 GET_BBLOCK (cfg, tblock, ip); \
542 link_bblock (cfg, cfg->cbb, tblock); \
543 ins->inst_false_bb = tblock; \
544 start_new_bblock = 2; \
545 } \
546 if (sp != stack_start) { \
547 handle_stack_args (cfg, stack_start, sp - stack_start); \
548 CHECK_UNVERIFIABLE (cfg); \
549 } \
550 MONO_ADD_INS (cfg->cbb, cmp); \
551 MONO_ADD_INS (cfg->cbb, ins); \
552 } while (0)
554 /* *
555 * link_bblock: Links two basic blocks
556 *
557 * links two basic blocks in the control flow graph, the 'from'
558 * argument is the starting block and the 'to' argument is the block
559 * the control flow ends to after 'from'.
560 */
561 static void
563 {
567 #if 0
570 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
571 else
576 else
578 }
579 #endif
586 }
587 }
589 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
592 }
596 }
603 }
604 }
606 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
609 }
613 }
614 }
616 void
618 {
620 }
622 /**
623 * mono_find_block_region:
624 *
625 * We mark each basic block with a region ID. We use that to avoid BB
626 * optimizations when blocks are in different regions.
627 *
628 * Returns:
629 * A region token that encodes where this region is, and information
630 * about the clause owner for this block.
631 *
632 * The region encodes the try/catch/filter clause that owns this block
633 * as well as the type. -1 is a special value that represents a block
634 * that is in none of try/catch/filter.
635 */
636 static int
638 {
645 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
654 else
656 }
657 }
663 }
666 }
668 static gboolean
670 {
677 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FAULT)
682 }
684 }
688 {
700 }
701 }
703 }
705 static void
707 {
715 /* prevent it from being register allocated */
719 }
721 MonoInst *
723 {
725 }
729 {
737 /* prevent it from being register allocated */
743 }
745 /*
746 * Returns the type used in the eval stack when @type is loaded.
747 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
748 */
749 void
751 {
759 }
761 handle_enum:
805 }
821 }
825 }
826 }
828 /*
829 * The following tables are used to quickly validate the IL code in type_from_op ().
830 */
831 static const char
837 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R8},
841 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4}
842 };
844 static const char
845 neg_table [] = {
847 };
849 /* reduce the size of this table */
850 static const char
860 };
862 static const char
864 /* Inv i L p F & O vt r4 */
874 };
876 /* reduce the size of this table */
877 static const char
887 };
889 /*
890 * Tables to map from the non-specific opcode to the matching
891 * type-specific opcode.
892 */
893 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
894 static const guint16
896 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
897 };
899 /* handles from CEE_NEG to CEE_CONV_U8 */
900 static const guint16
902 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
903 };
905 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
906 static const guint16
908 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
909 };
911 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
912 static const guint16
914 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
915 };
917 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
918 static const guint16
920 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
921 };
923 /* handles from CEE_BEQ to CEE_BLT_UN */
924 static const guint16
926 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
927 };
929 /* handles from CEE_CEQ to CEE_CLT_UN */
930 static const guint16
932 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
933 };
935 /*
936 * Sets ins->type (the type on the eval stack) according to the
937 * type of the opcode and the arguments to it.
938 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
939 *
940 * FIXME: this function sets ins->type unconditionally in some cases, but
941 * it should set it to invalid for some types (a conv.x on an object)
942 */
943 static void
945 {
947 /* binops */
953 /* FIXME: check unverifiable args for STACK_MP */
975 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
981 else
986 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
1012 /* unops */
1020 else
1041 }
1074 #if SIZEOF_VOID_P == 8
1076 #else
1078 #endif
1086 }
1159 }
1163 }
1165 static const char
1166 ldind_type [] = {
1167 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1168 };
1170 #if 0
1172 static const char
1175 };
1177 static int
1179 {
1190 }
1191 args++;
1192 }
1213 }
1226 }
1227 /*if (!param_table [args [i].type] [sig->params [i]->type])
1228 return 0;*/
1229 }
1231 }
1232 #endif
1234 /*
1235 * When we need a pointer to the current domain many times in a method, we
1236 * call mono_domain_get() once and we store the result in a local variable.
1237 * This function returns the variable that represents the MonoDomain*.
1238 */
1241 {
1245 }
1247 /*
1248 * The got_var contains the address of the Global Offset Table when AOT
1249 * compiling.
1250 */
1251 MonoInst *
1253 {
1258 }
1260 }
1264 {
1269 /* force the var to be stack allocated */
1271 }
1274 }
1290 }
1292 }
1296 {
1330 else
1335 }
1338 }
1342 {
1376 }
1378 }
1380 /*
1381 * We try to share variables when possible
1382 */
1385 {
1389 /* inlining can result in deeper stacks */
1409 }
1411 }
1413 static void
1415 {
1416 /*
1417 * Don't use this if a generic_context is set, since that means AOT can't
1418 * look up the method using just the image+token.
1419 * table == 0 means this is a reference made from a wrapper.
1420 */
1422 MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1426 }
1427 }
1429 /*
1430 * This function is called to handle items that are left on the evaluation stack
1431 * at basic block boundaries. What happens is that we save the values to local variables
1432 * and we reload them later when first entering the target basic block (with the
1433 * handle_loaded_temps () function).
1434 * A single joint point will use the same variables (stored in the array bb->out_stack or
1435 * bb->in_stack, if the basic block is before or after the joint point).
1436 *
1437 * This function needs to be called _before_ emitting the last instruction of
1438 * the bb (i.e. before emitting a branch).
1439 * If the stack merge fails at a join point, cfg->unverifiable is set.
1440 */
1441 static void
1443 {
1448 gboolean found;
1456 //printf ("bblock %d has out:", bb->block_num);
1460 /* exception handlers are linked, but they should not be considered for stack args */
1463 //printf (" %d", outb->block_num);
1468 }
1469 }
1470 //printf ("\n");
1474 /*
1475 * try to reuse temps already allocated for this purpouse, if they occupy the same
1476 * stack slot and if they are of the same type.
1477 * This won't cause conflicts since if 'local' is used to
1478 * store one of the values in the in_stack of a bblock, then
1479 * the same variable will be used for the same outgoing stack
1480 * slot as well.
1481 * This doesn't work when inlining methods, since the bblocks
1482 * in the inlined methods do not inherit their in_stack from
1483 * the bblock they are inlined to. See bug #58863 for an
1484 * example.
1485 */
1488 else
1490 }
1491 }
1492 }
1496 /* exception handlers are linked, but they should not be considered for stack args */
1503 }
1505 }
1508 }
1518 }
1520 /*
1521 * It is possible that the out bblocks already have in_stack assigned, and
1522 * the in_stacks differ. In this case, we will store to all the different
1523 * in_stacks.
1524 */
1529 /* Find a bblock which has a different in_stack */
1533 /* exception handlers are linked, but they should not be considered for stack args */
1535 bindex++;
1537 }
1545 }
1549 }
1550 bindex ++;
1551 }
1552 }
1553 }
1557 {
1563 MonoJumpInfo ji;
1564 gpointer target;
1565 MonoError error;
1573 }
1575 }
1577 static void
1578 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1579 {
1581 #ifdef COMPRESSED_INTERFACE_BITMAP
1590 #else
1605 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1611 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1612 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1613 }
1614 #endif
1615 }
1617 /*
1618 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1619 * stored in "klass_reg" implements the interface "klass".
1620 */
1621 static void
1622 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1623 {
1624 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1625 }
1627 /*
1628 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1629 * stored in "vtable_reg" implements the interface "klass".
1630 */
1631 static void
1632 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1633 {
1634 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1635 }
1637 /*
1638 * Emit code which checks whenever the interface id of @klass is smaller than
1639 * than the value given by max_iid_reg.
1640 */
1641 static void
1644 {
1649 }
1650 else
1654 else
1656 }
1658 /* Same as above, but obtains max_iid from a vtable */
1659 static void
1662 {
1665 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, max_interface_id));
1667 }
1669 /* Same as above, but obtains max_iid from a klass */
1670 static void
1673 {
1676 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id));
1678 }
1680 static void
1681 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1682 {
1690 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1693 }
1694 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1704 }
1706 }
1708 static void
1709 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1710 {
1712 }
1714 static void
1715 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1716 {
1724 else
1726 }
1728 /*
1729 * Variant of the above that takes a register to the class, not the vtable.
1730 */
1731 static void
1732 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1733 {
1741 else
1743 }
1746 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1747 {
1753 }
1755 }
1759 {
1761 }
1764 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1765 {
1772 }
1774 }
1776 static void
1777 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1779 static void
1780 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1781 {
1787 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank));
1790 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
1791 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
1794 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
1795 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1798 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1805 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1807 }
1810 /* Check that the object is a vector too */
1815 }
1824 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1827 }
1828 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1831 }
1832 }
1834 static void
1835 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1836 {
1838 }
1840 static void
1842 {
1861 #if SIZEOF_REGISTER == 8
1865 #endif
1866 }
1867 }
1873 else
1877 /* This could be optimized further if neccesary */
1882 }
1884 }
1891 }
1896 }
1897 }
1903 }
1908 }
1913 }
1914 }
1916 void
1917 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1918 {
1924 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1928 /* This could be optimized further if neccesary */
1936 }
1937 }
1947 }
1948 }
1957 }
1965 }
1973 }
1974 }
1976 static void
1978 {
1992 }
1993 }
1995 /*
1996 * emit_push_lmf:
1997 *
1998 * Emit IR to push the current LMF onto the LMF stack.
1999 */
2000 static void
2002 {
2003 /*
2004 * Emit IR to push the LMF:
2005 * lmf_addr = <lmf_addr from tls>
2006 * lmf->lmf_addr = lmf_addr
2007 * lmf->prev_lmf = *lmf_addr
2008 * *lmf_addr = lmf
2009 */
2017 /* Load current lmf */
2023 /* Save previous_lmf */
2024 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), lmf_ins->dreg);
2025 /* Set new LMF */
2028 /*
2029 * Store lmf_addr in a variable, so it can be allocated to a global register.
2030 */
2032 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2034 #ifdef HOST_WIN32
2041 EMIT_NEW_BIALU_IMM (cfg, lmf_ins, OP_PADD_IMM, lmf_reg, jit_tls_dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2044 }
2045 #else
2050 #ifdef TARGET_IOS
2053 /* Inline mono_get_lmf_addr () */
2054 /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
2056 /* Load mono_jit_tls_id */
2059 else
2061 /* call pthread_getspecific () */
2063 /* lmf_addr = &jit_tls->lmf */
2064 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, cfg->lmf_addr_var->dreg, jit_tls_ins->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2066 #else
2068 #endif
2069 }
2070 #endif
2077 /* Save previous_lmf */
2079 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
2080 /* Set new lmf */
2082 }
2083 }
2085 /*
2086 * emit_pop_lmf:
2087 *
2088 * Emit IR to pop the current LMF from the LMF stack.
2089 */
2090 static void
2092 {
2103 /* Load previous_lmf */
2105 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2106 /* Set new LMF */
2109 /*
2110 * Emit IR to pop the LMF:
2111 * *(lmf->lmf_addr) = lmf->prev_lmf
2112 */
2113 /* This could be called before emit_push_lmf () */
2115 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2119 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2121 }
2122 }
2124 static void
2126 {
2129 /*
2130 * Avoid instrumenting inlined methods since it can
2131 * distort profiling results.
2132 */
2139 }
2140 }
2142 static int
2144 {
2145 handle_enum:
2174 else
2191 /* gsharedvt */
2195 }
2197 }
2199 //XXX this ignores if t is byref
2200 #define MONO_TYPE_IS_PRIMITIVE_SCALAR(t) ((((((t)->type >= MONO_TYPE_BOOLEAN && (t)->type <= MONO_TYPE_U8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
2202 /*
2203 * target_type_is_incompatible:
2204 * @cfg: MonoCompile context
2205 *
2206 * Check that the item @arg on the evaluation stack can be stored
2207 * in the target type (can be a local, or field, etc).
2208 * The cfg arg can be used to check if we need verification or just
2209 * validity checks.
2210 *
2211 * Returns: non-0 value if arg can't be stored on a target.
2212 */
2213 static int
2215 {
2220 /* FIXME: check that the pointed to types match */
2222 /* This is needed to handle gshared types + ldaddr. We lower the types so we can handle enums and other typedef-like types. */
2223 MonoClass *target_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&mono_class_from_mono_type (target)->byval_arg));
2224 MonoClass *source_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg));
2226 /* if the target is native int& or same type */
2230 /* Both are primitive type byrefs and the source points to a larger type that the destination */
2231 if (MONO_TYPE_IS_PRIMITIVE_SCALAR (&target_class_lowered->byval_arg) && MONO_TYPE_IS_PRIMITIVE_SCALAR (&source_class_lowered->byval_arg) &&
2232 mono_class_instance_size (target_class_lowered) <= mono_class_instance_size (source_class_lowered))
2235 }
2239 }
2255 /* STACK_MP is needed when setting pinned locals */
2262 /*
2263 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
2264 * in native int. (#688008).
2265 */
2276 /* FIXME: check type compatibility */
2312 /* The second cases is needed when doing partial sharing */
2313 if (klass != arg->klass && target_class != arg->klass && target_class != mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg)))
2319 /* FIXME: check type compatibility */
2321 }
2331 }
2335 }
2337 }
2339 /*
2340 * Prepare arguments for passing to a function call.
2341 * Return a non-zero value if the arguments can't be passed to the given
2342 * signature.
2343 * The type checks are not yet complete and some conversions may need
2344 * casts on 32 or 64 bit architectures.
2345 *
2346 * FIXME: implement this using target_type_is_incompatible ()
2347 */
2348 static int
2350 {
2357 args++;
2358 }
2364 }
2366 handle_enum:
2384 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2412 }
2425 /* gsharedvt */
2432 }
2433 }
2435 }
2437 static int
2439 {
2455 }
2458 }
2460 static int
2462 {
2478 }
2481 }
2483 /* Either METHOD or IMT_ARG needs to be set */
2484 static void
2485 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2486 {
2496 }
2498 #ifdef ENABLE_LLVM
2500 #endif
2503 }
2511 }
2514 }
2518 {
2526 }
2528 static int
2530 {
2533 else
2535 }
2537 static int
2539 {
2542 else
2544 }
2546 /*
2547 * check_method_sharing:
2548 *
2549 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2550 */
2551 static void
2552 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2553 {
2564 /*
2565 * Pass vtable iff target method might
2566 * be shared, which means that sharing
2567 * is enabled for its class and its
2568 * context is sharable (and it's not a
2569 * generic method).
2570 */
2571 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2573 }
2584 }
2585 }
2591 }
2596 {
2599 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2601 #endif
2623 //g_assert_not_reached ();
2624 }
2631 /*
2632 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2633 * address of return value to increase optimization opportunities.
2634 * Before vtype decomposition, the dreg of the call ins itself represents the
2635 * fact the call modifies the return value. After decomposition, the call will
2636 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2637 * will be transformed into an LDADDR.
2638 */
2642 /* We reference the call too since call->dreg could change during optimization */
2652 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2654 /*
2655 * If the call has a float argument, we would need to do an r8->r4 conversion using
2656 * an icall, but that cannot be done during the call sequence since it would clobber
2657 * the call registers + the stack. So we do it before emitting the call.
2658 */
2665 else
2676 /* The result will be in an int vreg */
2678 }
2679 }
2680 }
2681 #endif
2685 #ifdef ENABLE_LLVM
2688 else
2690 #else
2692 #endif
2698 }
2700 static void
2702 {
2706 #ifdef ENABLE_LLVM
2708 #endif
2709 }
2712 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2713 {
2719 if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2724 }
2729 }
2733 cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2738 }
2740 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2758 /* Restore the stack so we don't crash when throwing the exception */
2765 }
2771 }
2774 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2777 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2779 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2782 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2784 {
2785 #ifndef DISABLE_REMOTING
2787 #endif
2794 gboolean need_unbox_trampoline;
2805 }
2808 /* Create the real signature */
2809 /* FIXME: Cache these */
2814 }
2818 #ifndef DISABLE_REMOTING
2828 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2831 }
2832 #endif
2837 need_unbox_trampoline = method->klass == mono_defaults.object_class || mono_class_is_interface (method->klass);
2839 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual_, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2841 #ifndef DISABLE_REMOTING
2844 else
2845 #endif
2857 if (!cfg->llvm_only && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2862 /* Make a call to delegate->invoke_impl */
2867 /* We must emit a dummy use here because the delegate trampoline will
2868 replace the 'this' argument with the delegate target making this activation
2869 no longer a root for the delegate.
2870 This is an issue for delegates that target collectible code such as dynamic
2871 methods of GC'able assemblies.
2873 For a test case look into #667921.
2875 FIXME: a dummy use is not the best way to do it as the local register allocator
2876 will put it on a caller save register and spil it around the call.
2877 Ideally, we would either put it on a callee save register or only do the store part.
2878 */
2882 }
2889 /*
2890 * the method is not virtual, we just need to ensure this is not null
2891 * and then we can call the method directly.
2892 */
2893 #ifndef DISABLE_REMOTING
2894 if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2895 /*
2896 * The check above ensures method is not gshared, this is needed since
2897 * gshared methods can't have wrappers.
2898 */
2900 }
2901 #endif
2908 /*
2909 * the method is virtual, but we can statically dispatch since either
2910 * it's class or the method itself are sealed.
2911 * But first we need to ensure it's not a null reference.
2912 */
2918 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2925 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2938 }
2939 }
2944 }
2945 }
2953 }
2955 MonoInst*
2956 mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this_ins)
2957 {
2958 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this_ins, NULL, NULL);
2959 }
2961 MonoInst*
2964 {
2975 }
2977 MonoInst*
2979 {
2985 }
2987 /*
2988 * mono_emit_abs_call:
2989 *
2990 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2991 */
2995 {
2999 /*
3000 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
3001 * handle it.
3002 */
3009 }
3013 {
3014 // FIXME: memory allocation
3018 res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
3025 }
3027 /* Make an indirect call to FSIG passing an additional argument */
3029 emit_extra_arg_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **orig_args, int arg_reg, MonoInst *call_target)
3030 {
3036 /* Make a call with an rgctx/extra arg */
3039 else
3040 args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
3050 }
3052 /* Emit an indirect call to the function descriptor ADDR */
3054 emit_llvmonly_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, MonoInst *addr)
3055 {
3061 /*
3062 * addr points to a <addr, arg> pair, load both of them, and
3063 * make a call to addr, passing arg as an extra arg.
3064 */
3071 }
3073 static gboolean
3075 {
3076 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
3077 #ifdef TARGET_AMD64
3080 #endif
3084 }
3086 MonoInst*
3087 mono_emit_jit_icall_by_info (MonoCompile *cfg, int il_offset, MonoJitICallInfo *info, MonoInst **args)
3088 {
3089 /*
3090 * Call the jit icall without a wrapper if possible.
3091 * The wrapper is needed for the following reasons:
3092 * - to handle exceptions thrown using mono_raise_exceptions () from the
3093 * icall function. The EH code needs the lmf frame pushed by the
3094 * wrapper to be able to unwind back to managed code.
3095 * - to be able to do stack walks for asynchronously suspended
3096 * threads when debugging.
3097 */
3107 }
3109 /*
3110 * Inline the wrapper method, which is basically a call to the C icall, and
3111 * an exception check.
3112 */
3121 }
3122 }
3126 {
3131 /*
3132 * Native code might return non register sized integers
3133 * without initializing the upper bits.
3134 */
3150 }
3159 }
3160 }
3161 }
3164 }
3167 static void
3169 {
3172 args [0] = emit_get_rgctx_method (cfg, mono_method_check_context_used (method), method, MONO_RGCTX_INFO_METHOD);
3173 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cil_method), cil_method, MONO_RGCTX_INFO_METHOD);
3176 }
3180 {
3186 }
3188 }
3190 static void
3191 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
3192 {
3209 }
3210 }
3211 }
3213 static void
3215 {
3217 gpointer card_table_mask;
3230 if (cfg->backend->have_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3246 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3247 * IMM's larger than 32bits.
3248 */
3257 }
3260 }
3262 static gboolean
3263 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3264 {
3271 /*types with references can't have alignment smaller than sizeof(void*) */
3275 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3281 /* We don't unroll more than 5 stores to avoid code bloat. */
3283 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3291 }
3300 /*tmp = dreg*/
3320 /*tmp += sizeof (void*)*/
3324 }
3325 }
3327 /* Those cannot be references since size < sizeof (void*) */
3333 }
3340 }
3347 }
3350 }
3352 /*
3353 * Emit code to copy a valuetype of type @klass whose address is stored in
3354 * @src->dreg to memory whose address is stored at @dest->dreg.
3355 */
3356 void
3357 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3358 {
3370 /*
3371 * This check breaks with spilled vars... need to handle it during verification anyway.
3372 * g_assert (klass && klass == src->klass && klass == dest->klass);
3373 */
3379 }
3383 else
3386 /* if native is true there should be no references in the struct */
3388 /* Avoid barriers when storing to the stack */
3398 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3399 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3407 }
3411 else
3414 }
3415 }
3418 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3425 else
3431 else
3433 }
3434 }
3438 {
3444 }
3446 }
3448 void
3450 {
3453 guint32 align;
3459 /* FIXME: Optimize this for the case when dest is an LDADDR */
3465 bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3471 }
3479 }
3486 }
3487 }
3489 /*
3490 * emit_get_rgctx:
3491 *
3492 * Emit IR to return either the this pointer for instance method,
3493 * or the mrgctx for static methods.
3494 */
3497 {
3530 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3532 }
3540 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this_ins->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3542 }
3543 }
3546 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3547 {
3548 MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
3557 }
3561 {
3565 // FIXME: No fastpath since the slot is not a compile time constant
3570 else
3573 #if 0
3574 /*
3575 * FIXME: This can be called during decompose, which is a problem since it creates
3576 * new bblocks.
3577 * Also, the fastpath doesn't work since the slot number is dynamically allocated.
3578 */
3580 gboolean mrgctx;
3597 }
3607 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, rgctx_reg, rgctx->dreg, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
3608 // FIXME: Avoid this check by allocating the table when the vtable is created etc.
3613 }
3618 /* load ptr to next array */
3620 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
3621 else
3624 /* is the ptr null? */
3626 /* if yes, jump to actual trampoline */
3628 }
3630 /* fetch slot */
3633 /* is the slot null? */
3635 /* if yes, jump to actual trampoline */
3638 /* Fastpath */
3647 /* Slowpath */
3653 else
3664 #endif
3665 }
3667 /*
3668 * emit_rgctx_fetch:
3669 *
3670 * Emit IR to load the value of the rgctx entry ENTRY from the rgctx
3671 * given by RGCTX.
3672 */
3675 {
3678 else
3679 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3680 }
3685 {
3686 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_CLASS, klass, rgctx_type);
3690 }
3695 {
3696 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_SIGNATURE, sig, rgctx_type);
3700 }
3705 {
3710 call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
3714 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_CALL, call_info, rgctx_type);
3718 }
3720 /*
3721 * emit_get_rgctx_virt_method:
3722 *
3723 * Return data for method VIRT_METHOD for a receiver of type KLASS.
3724 */
3728 {
3733 info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
3737 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_VIRT_METHOD, info, rgctx_type);
3741 }
3746 {
3750 entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_METHOD, info, MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO);
3754 }
3756 /*
3757 * emit_get_rgctx_method:
3758 *
3759 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3760 * normal constants, else emit a load from the rgctx.
3761 */
3765 {
3778 }
3780 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_METHODCONST, cmethod, rgctx_type);
3784 }
3785 }
3790 {
3791 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_FIELD, field, rgctx_type);
3795 }
3797 static int
3799 {
3809 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3811 }
3817 new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3819 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3822 }
3832 }
3834 /*
3835 * emit_get_gsharedvt_info:
3836 *
3837 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3838 */
3841 {
3846 /* Load info->entries [idx] */
3848 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3851 }
3854 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3855 {
3857 }
3859 /*
3860 * On return the caller must check @klass for load errors.
3861 */
3862 static void
3864 {
3879 }
3884 /*
3885 * Using an opcode instead of emitting IR here allows the hiding of the call inside the opcode,
3886 * so this doesn't have to clobber any regs and it doesn't break basic blocks.
3887 */
3904 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, bits_reg, vtable_arg->dreg, byte_offset);
3916 }
3917 }
3919 static void
3920 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3921 {
3929 }
3930 }
3932 static void
3934 {
3947 }
3953 }
3956 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3957 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3959 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3970 }
3971 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3975 }
3976 }
3978 static void
3980 {
3981 /* Reset the variables holding the cast details */
3986 /* It is enough to reset the from field */
3987 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3988 }
3989 }
3991 /*
3992 * On return the caller must check @array_class for load errors
3993 */
3994 static void
3996 {
4004 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4010 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4033 }
4034 }
4039 }
4041 /**
4042 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
4043 * generic code is generated.
4044 */
4047 {
4053 /* FIXME: What if the class is shared? We might not
4054 have to get the address of the method from the
4055 RGCTX. */
4057 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4059 cfg->signatures = g_slist_prepend_mempool (cfg->mempool, cfg->signatures, mono_method_signature (method));
4065 }
4078 }
4081 }
4082 }
4086 {
4095 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4096 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4098 /* FIXME: generics */
4101 // Check rank == 0
4105 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4106 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, element_class));
4111 /* This assertion is from the unboxcast insn */
4123 }
4125 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
4131 }
4135 {
4143 /* obj */
4146 /* klass */
4149 /* CASTCLASS */
4159 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4162 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
4165 /* Non-ref case */
4166 /* UNBOX */
4172 /* Ref case */
4175 /* Save the ref to a temporary */
4182 /* Nullable case */
4185 {
4186 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
4190 unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4197 else
4202 }
4206 /* End */
4209 /* LDOBJ */
4213 }
4215 /*
4216 * Returns NULL and set the cfg exception on error.
4217 */
4220 {
4226 MonoRgctxInfoType rgctx_info;
4230 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (klass, for_box, known_instance_size);
4234 else
4245 }
4254 }
4256 }
4259 }
4266 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !mono_class_is_ginst (klass)) {
4267 /* This happens often in argument checking code, eg. throw new FooException... */
4268 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
4274 gboolean pass_lw;
4280 }
4292 }
4299 }
4302 }
4303 }
4306 }
4308 /*
4309 * Returns NULL and set the cfg exception on error.
4310 */
4313 {
4322 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4325 /* FIXME: What if the class is shared? We might not
4326 have to get the method address from the RGCTX. */
4328 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4332 }
4345 }
4348 }
4349 }
4365 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4368 /* Non-ref case */
4372 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4380 /* Ref case */
4383 /* val is a vtype, so has to load the value manually */
4391 /* Nullable case */
4394 {
4396 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
4400 /*
4401 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
4402 * construct that method at JIT time, so have to do things by hand.
4403 */
4404 box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4411 else
4416 }
4428 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4430 }
4431 }
4433 static gboolean
4434 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4435 {
4441 container = mono_class_get_generic_container (mono_class_get_generic_class (klass)->container_class);
4448 }
4452 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4457 }
4459 }
4463 static gboolean
4465 {
4466 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
4470 /*
4471 * An icall is directly callable if it doesn't directly or indirectly call mono_raise_exception ().
4472 * Whitelist a few icalls for now.
4473 */
4483 }
4487 /* No locking needed */
4488 if (cmethod->klass->image == mono_defaults.corlib && g_hash_table_lookup (direct_icall_type_hash, cmethod->klass->name))
4491 }
4493 static gboolean
4495 {
4499 }
4501 }
4503 #define is_complex_isinst(klass) (mono_class_is_interface (klass) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || mono_class_is_sealed (klass) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
4507 {
4510 }
4514 {
4523 }
4525 static int
4527 {
4528 /* Each CASTCLASS_CACHE patch needs a unique index which identifies the call site */
4531 }
4536 {
4544 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4547 }
4551 {
4555 /* obj */
4558 /* klass */
4561 /* inline cache*/
4563 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4565 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
4567 }
4569 /*
4570 * Returns NULL and set the cfg exception on error.
4571 */
4574 {
4586 if (mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4591 /* obj */
4594 /* klass - it's the second element of the cache entry*/
4595 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4597 /* cache */
4601 }
4604 }
4614 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4619 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4621 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && mono_class_is_sealed (klass)) {
4622 /* the remoting code is broken, access the class for now */
4623 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4629 }
4632 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4634 }
4637 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4639 }
4640 }
4647 }
4649 /*
4650 * Returns NULL and set the cfg exception on error.
4651 */
4654 {
4665 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4666 MonoInst *cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
4670 /* klass - it's the second element of the cache entry*/
4671 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4675 }
4678 }
4684 /* Do the assignment at the beginning, so the other assignment can be if converted */
4692 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4696 /* the is_null_bb target simply copies the input register to the output */
4706 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4709 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4710 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
4713 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
4714 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4718 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4728 /* Check that the object is a vector too */
4733 }
4735 /* the is_null_bb target simply copies the input register to the output */
4737 }
4740 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4741 /* the is_null_bb target simply copies the input register to the output */
4746 /* the remoting code is broken, access the class for now */
4747 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4753 }
4756 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4758 }
4762 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4763 /* the is_null_bb target simply copies the input register to the output */
4765 }
4766 }
4767 }
4779 }
4783 {
4784 /* This opcode takes as input an object reference and a class, and returns:
4785 0) if the object is an instance of the class,
4786 1) if the object is not instance of the class,
4787 2) if the object is a proxy whose type cannot be determined */
4790 #ifndef DISABLE_REMOTING
4792 #else
4794 #endif
4798 #ifndef DISABLE_REMOTING
4800 #endif
4805 #ifndef DISABLE_REMOTING
4808 #endif
4814 #ifndef DISABLE_REMOTING
4816 #endif
4820 #ifndef DISABLE_REMOTING
4825 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4828 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4831 #else
4833 #endif
4835 #ifndef DISABLE_REMOTING
4840 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4842 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4843 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4846 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4856 #else
4858 #endif
4859 }
4866 #ifndef DISABLE_REMOTING
4871 #endif
4879 /* FIXME: */
4885 }
4889 {
4890 /* This opcode takes as input an object reference and a class, and returns:
4891 0) if the object is an instance of the class,
4892 1) if the object is a proxy whose type cannot be determined
4893 an InvalidCastException exception is thrown otherwhise*/
4896 #ifndef DISABLE_REMOTING
4898 #else
4900 #endif
4905 #ifndef DISABLE_REMOTING
4908 #endif
4918 #ifndef DISABLE_REMOTING
4929 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4935 #else
4939 #endif
4941 #ifndef DISABLE_REMOTING
4946 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4949 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4950 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4953 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4969 #else
4971 #endif
4972 }
4978 #ifndef DISABLE_REMOTING
4980 #endif
4982 /* FIXME: */
4988 }
4991 handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, MonoInst *enum_flag)
4992 {
4995 gboolean is_i4;
5000 #if SIZEOF_REGISTER == 8
5003 #endif
5009 }
5011 {
5029 }
5032 }
5033 }
5035 /*
5036 * Returns NULL and set the cfg exception on error.
5037 */
5039 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual_)
5040 {
5043 gpointer trampoline;
5052 if (!mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke), context_used ? NULL : method))
5054 }
5060 /* Inline the contents of mono_delegate_ctor */
5062 /* Set target field */
5063 /* Optimize away setting of NULL target */
5065 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
5068 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
5070 }
5071 }
5073 /* Set method field */
5075 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
5077 /*
5078 * To avoid looking up the compiled code belonging to the target method
5079 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
5080 * store it, and we fill it after the method has been compiled.
5081 */
5086 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
5092 code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
5096 }
5100 }
5101 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
5102 }
5115 }
5118 }
5123 del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
5130 trampoline = mono_create_delegate_virtual_trampoline (cfg->domain, klass, context_used ? NULL : method);
5131 else
5132 trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
5134 }
5136 /* Set invoke_impl field */
5138 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
5141 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
5142 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
5145 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
5146 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
5147 }
5151 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
5153 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
5156 }
5160 {
5163 /* Need to register the icall so it gets an icall wrapper */
5168 /* mono_array_new_va () needs a vararg calling convention */
5172 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
5174 }
5176 /*
5177 * handle_constrained_gsharedvt_call:
5178 *
5179 * Handle constrained calls where the receiver is a gsharedvt type.
5180 * Return the instruction representing the call. Set the cfg exception on failure.
5181 */
5183 handle_constrained_gsharedvt_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, MonoClass *constrained_class,
5185 {
5189 /*
5190 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
5191 * 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
5192 * pack the arguments into an array, and do the rest of the work in in an icall.
5193 */
5194 if (((cmethod->klass == mono_defaults.object_class) || mono_class_is_interface (cmethod->klass) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
5195 (MONO_TYPE_IS_VOID (fsig->ret) || MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_IS_REFERENCE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret) || mini_is_gsharedvt_type (fsig->ret)) &&
5196 (fsig->param_count == 0 || (!fsig->hasthis && fsig->param_count == 1) || (fsig->param_count == 1 && (MONO_TYPE_IS_REFERENCE (fsig->params [0]) || fsig->params [0]->byref || mini_is_gsharedvt_type (fsig->params [0]))))) {
5199 /*
5200 * This case handles calls to
5201 * - object:ToString()/Equals()/GetHashCode(),
5202 * - System.IComparable<T>:CompareTo()
5203 * - System.IEquatable<T>:Equals ()
5204 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
5205 */
5209 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
5210 else
5212 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_class), constrained_class, MONO_RGCTX_INFO_KLASS);
5214 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
5216 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
5226 ins = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
5228 /* deref_arg = BOX_TYPE != MONO_GSHAREDVT_BOX_TYPE_VTYPE */
5237 }
5241 }
5250 /* Unbox */
5251 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
5253 /* Load value */
5256 /* ins represents the call result */
5257 }
5260 }
5266 exception_exit:
5268 }
5270 static void
5272 {
5282 /* Add it to the start of the first bblock */
5286 }
5287 else
5292 /*
5293 * Add a dummy use to keep the got_var alive, since real uses might
5294 * only be generated by the back ends.
5295 * Add it to end_bblock, so the variable's lifetime covers the whole
5296 * method.
5297 * It would be better to make the usage of the got var explicit in all
5298 * cases when the backend needs it (i.e. calls, throw etc.), so this
5299 * wouldn't be needed.
5300 */
5303 }
5308 static gboolean
5310 {
5311 MonoMethodHeaderSummary header;
5313 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5316 #endif
5329 /*runtime, icall and pinvoke are checked by summary call*/
5336 /* also consider num_locals? */
5337 /* Do the size check early to avoid creating vtables */
5341 else
5344 }
5345 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
5348 /*
5349 * if we can initialize the class of the method right away, we do,
5350 * otherwise we don't allow inlining if the class needs initialization,
5351 * since it would mean inserting a call to mono_runtime_class_init()
5352 * inside the inlined code
5353 */
5355 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
5361 MonoError error;
5365 }
5366 }
5369 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
5371 /* No vtable created yet */
5376 /* This makes so that inline cannot trigger */
5377 /* .cctors: too many apps depend on them */
5378 /* running with a specific order... */
5381 MonoError error;
5385 }
5386 }
5389 /* No vtable created yet */
5396 }
5398 /*
5399 * If we're compiling for shared code
5400 * the cctor will need to be run at aot method load time, for example,
5401 * or at the end of the compilation of the inlining method.
5402 */
5403 if (mono_class_needs_cctor_run (method->klass, NULL) && !mono_class_is_before_field_init (method->klass))
5405 }
5407 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5409 /* FIXME: */
5415 }
5416 #endif
5422 }
5424 static gboolean
5425 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
5426 {
5431 }
5436 }
5442 /* The initialization is already done before the method is called */
5446 }
5448 MonoInst*
5449 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
5450 {
5452 guint32 size;
5461 }
5467 #if SIZEOF_REGISTER == 8
5468 /* The array reg is 64 bits but the index reg is only 32 */
5470 /* Not needed */
5475 }
5476 #else
5482 }
5483 #endif
5488 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5492 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
5497 }
5498 #endif
5505 /* gsharedvt */
5513 }
5515 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5521 }
5524 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
5525 {
5539 guint32 size;
5547 #if SIZEOF_REGISTER == 8
5548 /* The array reg is 64 bits but the index reg is only 32 */
5550 /* Not needed */
5558 }
5559 #else
5560 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
5562 #endif
5564 /* range checking */
5588 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5595 }
5598 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
5599 {
5611 /* emit_ldelema_2 depends on OP_LMUL */
5612 if (!cfg->backend->emulate_mul_div && rank == 2 && (cfg->opt & MONO_OPT_INTRINS) && !mini_is_gsharedvt_variable_klass (eclass)) {
5614 }
5618 else
5624 }
5626 static MonoBreakPolicy
5628 {
5630 }
5634 /**
5635 * mono_set_break_policy:
5636 * policy_callback: the new callback function
5637 *
5638 * Allow embedders to decide wherther to actually obey breakpoint instructions
5639 * (both break IL instructions and Debugger.Break () method calls), for example
5640 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
5641 * untrusted or semi-trusted code.
5642 *
5643 * @policy_callback will be called every time a break point instruction needs to
5644 * be inserted with the method argument being the method that calls Debugger.Break()
5645 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
5646 * if it wants the breakpoint to not be effective in the given method.
5647 * #MONO_BREAK_POLICY_ALWAYS is the default.
5648 */
5649 void
5651 {
5654 else
5656 }
5658 static gboolean
5671 }
5672 }
5674 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5676 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5677 {
5681 /* the bounds check is already done by the callers */
5691 }
5693 }
5696 static gboolean
5698 {
5700 }
5704 {
5731 // FIXME-VT: OP_ICONST optimization
5738 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
5751 }
5753 }
5754 }
5757 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5758 {
5763 else
5772 }
5773 }
5775 static gboolean
5777 {
5782 return_klass = mono_class_from_mono_type (mini_get_underlying_type (&return_klass->byval_arg));
5787 //Don't allow mixing reference types with value types
5792 }
5798 }
5800 //That are blitable
5804 /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5805 if ((MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5806 (!MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg))) {
5810 }
5812 if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5813 return_klass->byval_arg.type == MONO_TYPE_R4 || return_klass->byval_arg.type == MONO_TYPE_R8) {
5817 }
5822 //We can do it if sizes match
5827 }
5829 //No simple way to handle struct if sizes don't match
5834 }
5836 /*
5837 * Same reg size category.
5838 * A quick note on why we don't require widening here.
5839 * The intrinsic is "R Array.UnsafeMov<S,R> (S s)".
5840 *
5841 * Since the source value comes from a function argument, the JIT will already have
5842 * the value in a VREG and performed any widening needed before (say, when loading from a field).
5843 */
5848 }
5851 }
5855 {
5862 //Valuetypes that are semantically equivalent or numbers than can be widened to
5866 //Arrays of valuetypes that are semantically equivalent
5867 if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (cfg, param_klass->element_class, return_klass->element_class))
5871 }
5874 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5875 {
5876 #ifdef MONO_ARCH_SIMD_INTRINSICS
5883 }
5884 #endif
5887 }
5891 {
5898 }
5901 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5902 {
5906 /* The LLVM backend supports these intrinsics */
5916 }
5924 }
5946 }
5947 }
5956 }
5957 }
5960 }
5963 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5964 {
5972 }
5975 }
5978 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5979 {
5990 #if SIZEOF_REGISTER == 8
5994 /* The array reg is 64 bits but the index reg is only 32 */
5996 }
5997 #else
5999 #endif
6002 #if defined(TARGET_X86) || defined(TARGET_AMD64)
6003 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
6007 #else
6013 #endif
6016 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6018 /* Decompose later to allow more optimizations */
6032 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
6033 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
6037 } else if (!cfg->backend->emulate_mul_div && strcmp (cmethod->name, "InternalGetHashCode") == 0 && fsig->param_count == 1 && !mono_gc_is_moving ()) {
6053 if (strcmp (cmethod->name, "GetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6055 else if (strcmp (cmethod->name, "SetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6058 #ifndef MONO_BIG_ARRAYS
6059 /*
6060 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
6061 * Array methods.
6062 */
6063 else if (((strcmp (cmethod->name, "GetLength") == 0 && fsig->param_count + fsig->hasthis == 2) ||
6078 /* Non-szarray case */
6082 else
6087 /* Szarray case */
6091 else
6099 }
6100 #endif
6115 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6138 }
6143 /*
6144 * To make async stack traces work, icalls which can block should have a wrapper.
6145 * For Monitor.Enter, emit two calls: a fastpath which doesn't have a wrapper, and a slowpath, which does.
6146 */
6151 ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4_fast : (gpointer)mono_monitor_enter_fast, args);
6154 ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4 : (gpointer)mono_monitor_enter, args);
6157 }
6187 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6214 #if SIZEOF_REGISTER == 8
6216 #else
6218 #endif
6230 }
6238 }
6255 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6271 }
6272 }
6278 #if SIZEOF_REGISTER == 8
6279 if (!cfg->llvm_only && strcmp (cmethod->name, "Read") == 0 && fsig->param_count == 1 && (fsig->params [0]->type == MONO_TYPE_I8)) {
6292 /* 64 bit reads are already atomic */
6303 }
6304 }
6305 #endif
6314 }
6315 #if SIZEOF_REGISTER == 8
6318 #endif
6334 }
6342 }
6343 #if SIZEOF_REGISTER == 8
6346 #endif
6362 }
6369 }
6370 #if SIZEOF_REGISTER == 8
6373 #endif
6384 }
6385 }
6390 gboolean is_float = fsig->params [0]->type == MONO_TYPE_R4 || fsig->params [0]->type == MONO_TYPE_R8;
6398 }
6399 #if SIZEOF_REGISTER == 8
6407 }
6408 #else
6412 }
6413 #endif
6414 else
6421 /* TODO: Decompose these opcodes instead of bailing here. */
6431 }
6448 #if SIZEOF_REGISTER == 8
6450 #else
6452 #endif
6462 }
6474 }
6478 }
6483 gboolean is_float = fsig->params [1]->type == MONO_TYPE_R4 || fsig->params [1]->type == MONO_TYPE_R8;
6491 }
6492 #if SIZEOF_REGISTER == 8
6500 }
6501 #else
6505 }
6506 #endif
6507 else
6514 /* TODO: Decompose these opcodes instead of bailing here. */
6531 }
6548 #if SIZEOF_REGISTER == 8
6550 #else
6552 #endif
6564 }
6576 }
6580 }
6588 /* int32 r = CAS (location, value, comparand); */
6597 /* bool result = r == comparand; */
6609 /* *success = result; */
6613 }
6627 gboolean is_ref;
6631 /* t is a byref type, so the reference check is more complicated */
6649 #if SIZEOF_REGISTER == 8
6654 #else
6659 #endif
6666 ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : (is_float ? mono_alloc_freg (cfg) : mono_alloc_ireg (cfg));
6687 #if SIZEOF_REGISTER == 8
6689 #else
6691 #endif
6703 }
6704 }
6705 }
6710 gboolean is_ref;
6730 #if SIZEOF_REGISTER == 8
6735 #else
6740 #endif
6754 }
6755 }
6768 }
6770 }
6775 #ifdef TARGET_WIN32
6777 #else
6779 #endif
6780 }
6785 /* No stack walks are currently available, so implement this as an intrinsic */
6791 }
6796 /* No stack walks are currently available, so implement this as an intrinsic */
6800 /* This returns the declaring generic method */
6809 }
6811 /*
6812 * There is general branchless code for Min/Max, but it does not work for
6813 * all inputs:
6814 * http://everything2.com/?node_id=1051618
6815 */
6816 } else if (cmethod->klass == mono_defaults.systemtype_class && !strcmp (cmethod->name, "op_Equality")) {
6831 ) {
6848 }
6857 // FIXME: Leaks
6861 }
6862 }
6864 #ifdef MONO_ARCH_SIMD_INTRINSICS
6869 }
6870 #endif
6880 }
6883 }
6885 /*
6886 * This entry point could be used later for arbitrary method
6887 * redirection.
6888 */
6892 {
6894 /* managed string allocation support */
6895 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
6901 #ifndef MONO_CROSS_COMPILE
6903 #endif
6909 }
6910 }
6912 }
6914 static void
6916 {
6921 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
6923 /*
6924 * FIXME: We should use *args++ = sp [0], but that would mean the arg
6925 * would be different than the MonoInst's used to represent arguments, and
6926 * the ldelema implementation can't deal with that.
6927 * Solution: When ldelema is used on an inline argument, create a var for
6928 * it, emit ldelema on that var, and emit the saving code below in
6929 * inline_method () if needed.
6930 */
6933 /* This uses cfg->args [i] which is set by the preceeding line */
6936 sp++;
6937 }
6938 }
6940 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
6941 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
6943 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
6944 static gboolean
6946 {
6955 else
6957 }
6965 //return (strncmp_result <= 0);
6969 }
6970 }
6971 #endif
6973 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
6974 static gboolean
6976 {
6986 }
6987 }
6995 //return (strncmp_result <= 0);
6999 }
7000 }
7001 #endif
7003 static void
7005 {
7039 }
7040 }
7042 static void
7044 {
7067 }
7068 }
7070 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
7071 static void
7073 {
7083 else
7085 }
7086 }
7088 /*
7089 * inline_method:
7090 *
7091 * Return the cost of inlining CMETHOD, or zero if it should not be inlined.
7092 */
7093 static int
7094 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
7096 {
7097 MonoError error;
7105 guint prev_real_offset;
7111 guint32 prev_cil_offset_to_bb_len;
7118 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
7121 #endif
7122 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
7125 #endif
7131 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7136 }
7138 /* allocate local variables */
7146 }
7148 }
7150 /*Must verify before creating locals as it can cause the JIT to assert.*/
7154 }
7156 /* allocate space to store the return value */
7159 }
7162 cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
7166 /* allocate start and end blocks */
7167 /* This is needed so if the inline is aborted, we can clean up */
7216 if ((costs >= 0 && costs < 60) || inline_always || (costs >= 0 && (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))) {
7218 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7222 /* always add some code to avoid block split failures */
7229 /*
7230 * Get rid of the begin and end bblocks if possible to aid local
7231 * optimizations.
7232 */
7235 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
7244 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
7247 }
7249 /* There could be a bblock after 'prev', and making 'prev' the current bb could cause problems */
7251 }
7253 /*
7254 * Its possible that the rvar is set in some prev bblock, but not in others.
7255 * (#1835).
7256 */
7267 }
7268 }
7269 }
7272 }
7275 /*
7276 * If the inlined method contains only a throw, then the ret var is not
7277 * set, so set it to a dummy value.
7278 */
7284 }
7292 /* This gets rid of the newly added bblocks */
7294 }
7297 }
7299 /*
7300 * Some of these comments may well be out-of-date.
7301 * Design decisions: we do a single pass over the IL code (and we do bblock
7302 * splitting/merging in the few cases when it's required: a back jump to an IL
7303 * address that was not already seen as bblock starting point).
7304 * Code is validated as we go (full verification is still better left to metadata/verify.c).
7305 * Complex operations are decomposed in simpler ones right away. We need to let the
7306 * arch-specific code peek and poke inside this process somehow (except when the
7307 * optimizations can take advantage of the full semantic info of coarse opcodes).
7308 * All the opcodes of the form opcode.s are 'normalized' to opcode.
7309 * MonoInst->opcode initially is the IL opcode or some simplification of that
7310 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
7311 * opcode with value bigger than OP_LAST.
7312 * At this point the IR can be handed over to an interpreter, a dumb code generator
7313 * or to the optimizing code generator that will translate it to SSA form.
7314 *
7315 * Profiling directed optimizations.
7316 * We may compile by default with few or no optimizations and instrument the code
7317 * or the user may indicate what methods to optimize the most either in a config file
7318 * or through repeated runs where the compiler applies offline the optimizations to
7319 * each method and then decides if it was worth it.
7320 */
7322 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
7323 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
7324 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
7325 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
7326 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
7327 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
7328 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
7329 #define CHECK_TYPELOAD(klass) if (!(klass) || mono_class_has_failure (klass)) TYPE_LOAD_ERROR ((klass))
7331 /* offset from br.s -> br like opcodes */
7332 #define BIG_BRANCH_OFFSET 13
7334 static gboolean
7336 {
7340 }
7342 static int
7343 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
7344 {
7348 guint cli_addr;
7356 UNVERIFIED;
7360 ip++;
7395 guint32 j;
7405 }
7407 }
7414 }
7419 /* Find the start of the bblock containing the throw */
7423 bb_start --;
7424 }
7427 }
7428 }
7430 unverified:
7431 exception_exit:
7434 }
7437 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error)
7438 {
7447 }
7450 }
7453 }
7456 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
7457 {
7458 MonoError error;
7459 MonoMethod *method = mini_get_method_allow_open (m, token, klass, context, cfg ? &cfg->error : &error);
7461 if (method && cfg && !cfg->gshared && mono_class_is_open_constructed_type (&method->klass->byval_arg)) {
7462 mono_error_set_bad_image (&cfg->error, cfg->method->klass->image, "Method with open type while not compiling gshared");
7464 }
7470 }
7474 {
7475 MonoError error;
7483 }
7485 klass = mono_class_get_and_inflate_typespec_checked (method->klass->image, token, context, &error);
7487 }
7491 }
7494 mini_get_signature (MonoMethod *method, guint32 token, MonoGenericContext *context, MonoError *error)
7495 {
7504 }
7507 }
7509 }
7513 {
7519 }
7522 }
7524 static void
7526 {
7532 }
7534 /*
7535 * Return the original method is a wrapper is specified. We can only access
7536 * the custom attributes from the original method.
7537 */
7540 {
7544 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
7548 /* in other cases we need to find the original method */
7550 }
7552 static void
7553 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field)
7554 {
7555 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7556 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
7559 }
7561 static void
7562 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
7563 {
7564 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7565 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
7568 }
7570 /*
7571 * Check that the IL instructions at ip are the array initialization
7572 * sequence and return the pointer to the data and the size.
7573 */
7575 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
7576 {
7577 /*
7578 * newarr[System.Int32]
7579 * dup
7580 * ldtoken field valuetype ...
7581 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
7582 */
7584 MonoError error;
7588 guint32 rva;
7593 MonoClassField *field = mono_field_from_token_checked (method->klass->image, field_token, &dummy_class, NULL, &error);
7599 }
7606 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
7613 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
7614 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
7627 #endif
7630 }
7635 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
7640 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
7641 /* for aot code we do the lookup on load */
7645 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
7648 }
7650 }
7652 }
7654 static void
7656 {
7657 MonoError error;
7663 method_code = g_strdup_printf ("could not parse method body due to %s", mono_error_get_message (&error));
7667 else
7669 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code));
7673 }
7675 static void
7677 {
7682 /* Optimize reg-reg moves away */
7683 /*
7684 * Can't optimize other opcodes, since sp[0] might point to
7685 * the last ins of a decomposed opcode.
7686 */
7690 }
7691 }
7693 /*
7694 * ldloca inhibits many optimizations so try to get rid of it in common
7695 * cases.
7696 */
7699 {
7710 }
7712 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
7713 /* From the INITOBJ case */
7720 }
7721 exception_exit:
7723 }
7726 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp)
7727 {
7734 guint32 slot;
7737 /*
7738 * In llvm-only mode, vtables contain function descriptors instead of
7739 * method addresses/trampolines.
7740 */
7745 else
7754 /*
7755 * The simplest case, a normal virtual call.
7756 */
7763 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7766 /* Load the vtable slot, which contains a function descriptor. */
7775 /* Slow path */
7776 // FIXME: Make the wrapper use the preserveall cconv
7777 // FIXME: Use one icall per slot for small slot numbers ?
7780 /* Make the icall return the vtable slot value to save some code space */
7785 /* Fastpath */
7787 /* Load the address + arg from the vtable slot */
7792 }
7795 /*
7796 * A simple interface call
7797 *
7798 * We make a call through an imt slot to obtain the function descriptor we need to call.
7799 * The imt slot contains a function descriptor for a runtime function + arg.
7800 */
7807 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7810 /*
7811 * The slot is already initialized when the vtable is created so there is no need
7812 * to check it here.
7813 */
7815 /* Load the imt slot, which contains a function descriptor. */
7818 /* Load the address + arg of the imt thunk from the imt slot */
7821 /*
7822 * IMT thunks in llvm-only mode are C functions which take an info argument
7823 * plus the imt method and return the ftndesc to call.
7824 */
7828 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_trampoline, icall_args, thunk_addr_ins, NULL, NULL);
7831 }
7834 /*
7835 * This is similar to the interface case, the vtable slot points to an imt thunk which is
7836 * dynamically extended as more instantiations are discovered.
7837 * This handles generic virtual methods both on classes and interfaces.
7838 */
7850 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7853 else
7856 /* Load the slot, which contains a function descriptor. */
7859 /* These slots are not initialized, so fall back to the slow path until they are initialized */
7860 /* That happens when mono_method_add_generic_virtual_invocation () creates an IMT thunk */
7864 /* Fastpath */
7865 /* Same as with iface calls */
7871 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_trampoline, icall_args, thunk_addr_ins, NULL, NULL);
7873 /*
7874 * Unlike normal iface calls, these imt thunks can return NULL, i.e. when they are passed an instantiation
7875 * they don't know about yet. Fall back to the slowpath in that case.
7876 */
7882 /* Slowpath */
7890 else
7895 /* Common case */
7898 }
7900 /*
7901 * Non-optimized cases
7902 */
7916 else
7919 /*
7920 * Pass the extra argument even if the callee doesn't receive it, most
7921 * calling conventions allow this.
7922 */
7924 }
7926 static gboolean
7928 {
7933 }
7935 }
7937 /*
7938 * is_jit_optimizer_disabled:
7939 *
7940 * Determine whenever M's assembly has a DebuggableAttribute with the
7941 * IsJITOptimizerDisabled flag set.
7942 */
7943 static gboolean
7945 {
7946 MonoError error;
7960 /* Linked away */
7965 }
7977 /* Decode the attribute. See reflection.c */
7982 // FIXME: Support named parameters
7984 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
7986 /* Two boolean arguments */
7987 p ++;
7989 }
7991 }
7998 }
8000 static gboolean
8001 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
8002 {
8003 gboolean supported_tail_call;
8006 supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
8009 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
8010 /* These can point to the current method's stack */
8012 }
8014 /* this might point to the current method's stack */
8025 /* Debugging support */
8026 #if 0
8030 }
8031 #endif
8034 }
8036 /*
8037 * handle_ctor_call:
8038 *
8039 * Handle calls made to ctors from NEWOBJ opcodes.
8040 */
8041 static void
8042 handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used,
8044 {
8064 }
8065 }
8066 }
8068 /* Avoid virtual calls to ctors if possible */
8072 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8074 CHECK_CFG_EXCEPTION;
8086 // FIXME-VT: Clean this up
8090 }
8094 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
8097 // FIXME: Avoid initializing vtable_arg
8101 }
8107 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
8111 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8118 }
8123 }
8124 exception_exit:
8126 }
8128 static void
8130 {
8144 }
8146 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8156 }
8157 #else
8159 #endif
8160 }
8161 }
8163 /*
8164 * mono_method_to_ir:
8165 *
8166 * Translate the .net IL into linear IR.
8167 *
8168 * @start_bblock: if not NULL, the starting basic block, used during inlining.
8169 * @end_bblock: if not NULL, the ending basic block, used during inlining.
8170 * @return_var: if not NULL, the place where the return value is stored, used during inlining.
8171 * @inline_args: if not NULL, contains the arguments to the inline call
8172 * @inline_offset: if not zero, the real offset from the inline call, or zero otherwise.
8173 * @is_virtual_call: whether this method is being called as a result of a call to callvirt
8174 *
8175 * This method is used to turn ECMA IL into Mono's internal Linear IR
8176 * reprensetation. It is used both for entire methods, as well as
8177 * inlining existing methods. In the former case, the @start_bblock,
8178 * @end_bblock, @return_var, @inline_args are all set to NULL, and the
8179 * inline_offset is set to zero.
8180 *
8181 * Returns: the inline cost, or -1 if there was an error processing this method.
8182 */
8183 int
8184 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
8187 {
8188 MonoError error;
8207 guint num_args;
8219 /* serialization and xdomain stuff may need access to private fields and methods */
8227 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
8240 }
8253 /* We could hit a seq point before attaching to the JIT (#8338) */
8255 }
8264 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8265 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);
8270 }
8272 } else if (!method->wrapper_type && !method->dynamic && mono_debug_image_has_debug_info (method->klass->image)) {
8273 /* Methods without line number info like auto-generated property accessors */
8274 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8275 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);
8277 }
8278 }
8280 /*
8281 * Methods without init_locals set could cause asserts in various passes
8282 * (#497220). To work around this, we emit dummy initialization opcodes
8283 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
8284 * on some platforms.
8285 */
8288 else
8295 }
8297 /* SkipVerification is not allowed if core-clr is enabled */
8301 }
8315 }
8323 }
8325 cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
8346 /* ENTRY BLOCK */
8352 /* EXIT BLOCK */
8365 }
8366 /* handle exception clauses */
8379 /*
8380 * Linking the try block with the EH block hinders inlining as we won't be able to
8381 * merge the bblocks from inlining and produce an artificial hole for no good reason.
8382 */
8395 if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FILTER) {
8396 /* finally clauses already have a seq point */
8397 /* seq points for filter clauses are emitted below */
8400 }
8402 /* todo: is a fault block unsafe to optimize? */
8405 }
8407 /*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);
8408 while (p < end) {
8409 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
8410 }*/
8411 /* catch and filter blocks get the exception object on the stack */
8415 /* mostly like handle_stack_args (), but just sets the input args */
8416 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
8423 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
8424 /* The EH code passes in the exception in a register to both JITted and LLVM compiled code */
8429 }
8430 #else
8433 /*
8434 * Add a dummy use for the exvar so its liveness info will be
8435 * correct.
8436 */
8438 #endif
8443 }
8451 /* The filter block shares the exvar with the handler block */
8455 }
8456 }
8462 /*
8463 * In shared generic code with catch
8464 * clauses containing type variables
8465 * the exception handling code has to
8466 * be able to get to the rgctx.
8467 * Therefore we have to make sure that
8468 * the vtable/mrgctx argument (for
8469 * static or generic methods) or the
8470 * "this" argument (for non-static
8471 * methods) are live.
8472 */
8481 }
8482 }
8483 }
8489 }
8491 /* FIRST CODE BLOCK */
8504 }
8505 }
8507 /* we use a separate basic block for the initialization code */
8524 info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
8527 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
8531 /* prevent it from being register allocated */
8532 //var->flags |= MONO_INST_VOLATILE;
8535 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
8538 /* Allocate locals */
8540 /* prevent it from being register allocated */
8541 //locals_var->flags |= MONO_INST_VOLATILE;
8545 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
8554 /*
8555 if (init_locals)
8556 ins->flags |= MONO_INST_INIT;
8557 */
8558 }
8561 /* check if this is native code, e.g. an icall or a p/invoke */
8568 /* if this ia a native call then it can only be JITted from platform code */
8574 }
8575 }
8576 }
8577 }
8578 }
8580 CHECK_CFG_EXCEPTION;
8583 UNVERIFIED;
8587 UNVERIFIED;
8588 }
8595 UNVERIFIED;
8596 }
8599 /* We force the vtable variable here for all shared methods
8600 for the possibility that they might show up in a stack
8601 trace where their exact instantiation is needed. */
8608 /* FIXME: Is there a better way to do this?
8609 We need the variable live for the duration
8610 of the whole method. */
8612 }
8613 }
8615 /* add a check for this != NULL to inlined methods */
8622 }
8627 CHECK_CFG_ERROR;
8629 }
8631 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
8632 stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
8639 else
8651 }
8660 }
8671 }
8679 }
8682 }
8683 }
8701 }
8705 }
8706 }
8707 /*
8708 * Sequence points are points where the debugger can place a breakpoint.
8709 * Currently, we generate these automatically at points where the IL
8710 * stack is empty.
8711 */
8712 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
8713 /*
8714 * Make methods interruptable at the beginning, and at the targets of
8715 * backward branches.
8716 * Also, do this at the start of every bblock in methods with clauses too,
8717 * to be able to handle instructions with inprecise control flow like
8718 * throw/endfinally.
8719 * Backward branches are handled at the end of method-to-ir ().
8720 */
8722 gboolean sym_seq_point = sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code);
8724 /* Avoid sequence points on empty IL like .volatile */
8725 // FIXME: Enable this
8726 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
8734 }
8742 /* TODO: Use an increment here */
8743 #if defined(TARGET_X86)
8748 #else
8751 #endif
8752 }
8755 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8760 /*
8761 * The C# compiler uses these nops to notify the JIT that it should
8762 * insert seq points.
8763 */
8766 }
8769 else
8771 ip++;
8779 }
8780 ip++;
8791 ip++;
8802 ip++;
8814 UNVERIFIED;
8819 }
8846 UNVERIFIED;
8869 }
8875 }
8882 UNVERIFIED;
8945 #ifdef TARGET_POWERPC
8946 /* FIXME: Clean this up */
8949 #endif
8951 /* FIXME: we should really allocate this only late in the compilation process */
8971 }
8977 }
8982 #ifdef TARGET_POWERPC
8983 /* FIXME: Clean this up */
8986 #endif
8988 /* FIXME: we should really allocate this only late in the compilation process */
9008 }
9014 }
9019 sp--;
9034 }
9037 ip++;
9040 #ifdef TARGET_X86
9042 /* we need to pop the value from the x86 FP stack */
9044 #endif
9056 UNVERIFIED;
9058 /* FIXME: check the signature matches */
9060 CHECK_CFG_ERROR;
9076 /*
9077 * The code in mono-basic-block.c treats the rest of the code as dead, but we
9078 * have to emit a normal return since llvm expects it.
9079 */
9089 /* Handle tail calls similarly to calls */
9109 /* Prevent arguments from being optimized away */
9116 }
9121 }
9131 //GSHAREDVT_FAILURE (*ip);
9137 CHECK_CFG_ERROR;
9142 /*
9143 * This is a call through a function pointer using a pinvoke
9144 * signature. Have to create a wrapper and call that instead.
9145 * FIXME: This is very slow, need to create a wrapper at JIT time
9146 * instead based on the signature.
9147 */
9152 }
9158 //g_assert (!virtual_ || fsig->hasthis);
9164 /*
9165 * Making generic calls out of gsharedvt methods.
9166 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9167 * patching gshared method addresses into a gsharedvt method.
9168 */
9170 /*
9171 * We pass the address to the gsharedvt trampoline in the rgctx reg
9172 */
9176 /* Not tested */
9180 // FIXME:
9187 }
9189 /* Prevent inlining of methods with indirect calls */
9192 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
9193 MonoJumpInfoType info_type;
9194 gpointer info_data;
9196 /*
9197 * Instead of emitting an indirect call, emit a direct call
9198 * with the contents of the aotconst as the patch info.
9199 */
9206 }
9209 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR_CALL, info_data, fsig, sp);
9216 }
9217 }
9220 calli_end:
9222 /* End of call, INS should contain the result of the call, if any */
9227 }
9229 CHECK_CFG_EXCEPTION;
9235 }
9267 CHECK_CFG_ERROR;
9272 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9277 }
9278 }
9286 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_class, generic_context, &cfg->error);
9287 CHECK_CFG_ERROR;
9288 }
9293 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9294 /*
9295 * This is needed since get_method_constrained can't find
9296 * the method in klass representing a type var.
9297 * The type var is guaranteed to be a reference type in this
9298 * case.
9299 */
9303 cmethod = mono_get_method_constrained_checked (image, token, constrained_class, generic_context, &cil_method, &cfg->error);
9304 CHECK_CFG_ERROR;
9305 }
9306 }
9307 }
9312 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), &cfg->error);
9313 CHECK_CFG_ERROR;
9314 }
9318 }
9324 /* MS.NET seems to silently convert this to a callvirt */
9327 {
9328 /*
9329 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
9330 * converts to a callvirt.
9331 *
9332 * tests/bug-515884.il is an example of this behavior
9333 */
9334 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
9336 if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
9338 }
9346 LOAD_ERROR;
9350 } else if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && icall_is_direct_callable (cfg, cmethod)) {
9357 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
9358 CHECK_CFG_ERROR;
9359 }
9364 /* See code below */
9365 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9370 /*
9371 * We want to extend the try block to cover the call, but we can't do it if the
9372 * call is made directly since its followed by an exception check.
9373 */
9375 }
9376 }
9383 /* Don't support calls made using type arguments for now */
9384 /*
9385 if (cfg->gsharedvt) {
9386 if (mini_is_gsharedvt_signature (fsig))
9387 GSHAREDVT_FAILURE (*ip);
9388 }
9389 */
9397 UNVERIFIED;
9404 //g_assert (!virtual_ || fsig->hasthis);
9408 /*
9409 * We have the `constrained.' prefix opcode.
9410 */
9413 if ((cmethod->klass != mono_defaults.object_class) && constrained_class->valuetype && cmethod->klass->valuetype) {
9414 /* The 'Own method' case below */
9415 } else if (cmethod->klass->image != mono_defaults.corlib && !mono_class_is_interface (cmethod->klass) && !cmethod->klass->valuetype) {
9416 /* 'The type parameter is instantiated as a reference type' case below. */
9418 ins = handle_constrained_gsharedvt_call (cfg, cmethod, fsig, sp, constrained_class, &emit_widen);
9419 CHECK_CFG_EXCEPTION;
9422 }
9423 }
9428 /*
9429 * The receiver is a valuetype, but the exact type is not known at compile time. This means the
9430 * called method is not known at compile time either. The called method could end up being
9431 * one of the methods on the parent classes (object/valuetype/enum), in which case we need
9432 * to box the receiver.
9433 * A simple solution would be to box always and make a normal virtual call, but that would
9434 * be bad performance wise.
9435 */
9437 /*
9438 * The parent classes implement no generic interfaces, so the called method will be a vtype method, so no boxing neccessary.
9439 */
9441 }
9443 if (!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9444 /* The called method is not virtual, i.e. Object:GetType (), the receiver is a vtype, has to box */
9447 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9448 CHECK_CFG_EXCEPTION;
9454 /*
9455 * Determine at runtime whenever the called method is defined on object/valuetype/enum, and emit a boxing call
9456 * if needed.
9457 * FIXME: It is possible to inline the called method in a lot of cases, i.e. for T_INT,
9458 * the no-box case goes to a method in Int32, while the box case goes to a method in Enum.
9459 */
9460 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9465 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);
9466 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, box_type->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
9469 /* Non-ref case */
9474 /* Ref case */
9478 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9490 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9493 }
9494 } else if (constrained_class->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9495 /*
9496 * The type parameter is instantiated as a valuetype,
9497 * but that type doesn't override the method we're
9498 * calling, so we need to box `this'.
9499 */
9502 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9503 CHECK_CFG_EXCEPTION;
9507 /*
9508 * The type parameter is instantiated as a reference
9509 * type. We have a managed pointer on the stack, so
9510 * we need to dereference it here.
9511 */
9517 /* Own method */
9519 /* Interface method */
9533 /* Enum implements some interfaces, so treat this as the first case */
9536 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9537 CHECK_CFG_EXCEPTION;
9538 }
9539 }
9541 }
9543 }
9546 UNVERIFIED;
9548 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
9551 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
9555 }
9558 }
9560 /*
9561 * If the callee is a shared method, then its static cctor
9562 * might not get called after the call was patched.
9563 */
9564 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)) {
9567 }
9577 /* Generic method interface
9578 calls are resolved via a
9579 helper function and don't
9580 need an imt. */
9583 }
9585 /*
9586 * If a shared method calls another
9587 * shared method then the caller must
9588 * have a generic sharing context
9589 * because the magic trampoline
9590 * requires it. FIXME: We shouldn't
9591 * have to force the vtable/mrgctx
9592 * variable here. Instead there
9593 * should be a flag in the cfg to
9594 * request a generic sharing context.
9595 */
9599 }
9609 }
9610 }
9616 /*
9617 * emit_get_rgctx_method () calls mono_class_vtable () so check
9618 * for type load errors before.
9619 */
9622 }
9626 /* !marshalbyref is needed to properly handle generic methods + remoting */
9633 }
9634 }
9641 }
9646 /* Calling virtual generic methods */
9658 /* Prevent inlining of methods that contain indirect calls */
9664 if (cfg->backend->have_generalized_imt_trampoline && cfg->backend->gshared_supported && cmethod->wrapper_type == MONO_WRAPPER_NONE) {
9676 /* FIXME: This should be a managed pointer */
9689 }
9692 }
9694 /*
9695 * Implement a workaround for the inherent races involved in locking:
9696 * Monitor.Enter ()
9697 * try {
9698 * } finally {
9699 * Monitor.Exit ()
9700 * }
9701 * If a thread abort happens between the call to Monitor.Enter () and the start of the
9702 * try block, the Exit () won't be executed, see:
9703 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
9704 * To work around this, we extend such try blocks to include the last x bytes
9705 * of the Monitor.Enter () call.
9706 */
9707 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9711 /*
9712 * Only extend try blocks with a finally, to avoid catching exceptions thrown
9713 * from Monitor.Enter like ArgumentNullException.
9714 */
9716 /* Mark this bblock as needing to be extended */
9718 }
9719 }
9721 /* Conversion to a JIT intrinsic */
9722 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
9726 }
9728 }
9729 CHECK_CFG_ERROR;
9731 /* Inlining */
9733 (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
9740 /* Prevent inlining of methods that call wrappers */
9744 }
9751 /* *sp is already set by inline_method */
9752 sp++;
9754 }
9759 }
9760 }
9762 /* Tail recursion elimination */
9763 if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
9767 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9770 /* keep it simple */
9774 }
9780 }
9790 /* skip the CEE_RET, too */
9795 }
9796 }
9800 /*
9801 * Synchronized wrappers.
9802 * Its hard to determine where to replace a method with its synchronized
9803 * wrapper without causing an infinite recursion. The current solution is
9804 * to add the synchronized wrapper in the trampolines, and to
9805 * change the called method to a dummy wrapper, and resolve that wrapper
9806 * to the real method in mono_jit_compile_method ().
9807 */
9810 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
9812 }
9814 /*
9815 * Making generic calls out of gsharedvt methods.
9816 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9817 * patching gshared method addresses into a gsharedvt method.
9818 */
9819 if (cfg->gsharedvt && (mini_is_gsharedvt_signature (fsig) || cmethod->is_inflated || mono_class_is_ginst (cmethod->klass)) &&
9822 MonoRgctxInfoType info_type;
9825 //if (mono_class_is_interface (cmethod->klass))
9826 //GSHAREDVT_FAILURE (*ip);
9827 // disable for possible remoting calls
9828 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
9831 /* virtual generic call */
9833 /* Same as the virtual generic case above */
9836 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
9839 /* This can happen when we call a fully instantiated iface method */
9843 }
9844 }
9846 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
9851 else
9856 // FIXME: Avoid initializing vtable_arg
9860 }
9862 }
9864 /* Generic sharing */
9866 /*
9867 * Use this if the callee is gsharedvt sharable too, since
9868 * at runtime we might find an instantiation so the call cannot
9869 * be patched (the 'no_patch' code path in mini-trampolines.c).
9870 */
9881 /*
9882 * We are compiling a call to a
9883 * generic method from shared code,
9884 * which means that we have to look up
9885 * the method in the rgctx and do an
9886 * indirect call.
9887 */
9893 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GSHAREDVT_OUT_WRAPPER);
9894 else
9895 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9896 // FIXME: Avoid initializing imt_arg/vtable_arg
9899 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9901 }
9903 }
9905 /* Direct calls to icalls */
9910 /* Inline the wrapper */
9918 /* *sp is already set by inline_method */
9919 sp++;
9921 }
9926 }
9928 /* Array methods */
9942 }
9945 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
9964 }
9968 }
9974 /* Tail prefix / tail call optimization */
9976 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
9977 /* FIXME: runtime generic context pointer for jumps? */
9978 /* FIXME: handle this for generic sharing eventually */
9980 !vtable_arg && !cfg->gshared && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
9986 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9989 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
9992 /* Handle tail calls similarly to normal calls */
10002 /*
10003 * We implement tail calls by storing the actual arguments into the
10004 * argument variables, then emitting a CEE_JMP.
10005 */
10007 /* Prevent argument from being register allocated */
10010 }
10018 // FIXME: Eliminate unreachable epilogs
10020 /*
10021 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
10022 * only reachable from this call.
10023 */
10030 }
10031 }
10033 /*
10034 * Virtual calls in llvm-only mode.
10035 */
10039 }
10041 /* Common call */
10044 ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, virtual_ ? sp [0] : NULL,
10051 // FIXME: Eliminate unreachable epilogs
10053 /*
10054 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
10055 * only reachable from this call.
10056 */
10061 }
10063 call_end:
10065 /* End of call, INS should contain the result of the call, if any */
10071 else
10073 }
10078 /* See mono_emit_method_call_full () */
10080 }
10083 /*
10084 * Clang can convert these calls to tail calls which screw up the stack
10085 * walk. This happens even when the -fno-optimize-sibling-calls
10086 * option is passed to clang.
10087 * Work around this by emitting a dummy call.
10088 */
10090 }
10092 CHECK_CFG_EXCEPTION;
10098 }
10104 }
10107 /* return from inlined method */
10108 /*
10109 * If in_count == 0, that means the ret is unreachable due to
10110 * being preceeded by a throw. In that case, inline_method () will
10111 * handle setting the return value
10112 * (test case: test_0_inline_throw ()).
10113 */
10121 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10122 UNVERIFIED;
10124 //g_assert (returnvar != -1);
10127 }
10138 /*
10139 * Place a seq point here too even through the IL stack is not
10140 * empty, so a step over on
10141 * call <FOO>
10142 * ret
10143 * will work correctly.
10144 */
10147 }
10153 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10154 UNVERIFIED;
10157 }
10158 }
10160 UNVERIFIED;
10162 ip++;
10171 ip++;
10181 }
10199 ip++;
10201 ip++;
10211 ip++;
10222 }
10241 UNVERIFIED;
10242 ip ++;
10246 sp--;
10256 }
10263 #if SIZEOF_REGISTER == 4
10265 /* Convert it to OP_LCOMPARE */
10273 }
10274 #endif
10290 }
10304 ip++;
10322 gboolean use_op_switch;
10330 UNVERIFIED;
10345 }
10348 /*
10349 * Link the current bb with the targets as well, so handle_stack_args
10350 * will set their in_stack correctly.
10351 */
10360 /* Undo the links */
10364 }
10372 table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
10377 #ifdef TARGET_ARM
10378 /* ARM implements SWITCH statements differently */
10379 /* FIXME: Make it use the generic implementation */
10382 #endif
10399 else
10402 #if SIZEOF_REGISTER == 8
10403 /* The upper word might not be zero, and we add it to a 64 bit address later */
10405 #endif
10415 }
10417 /* FIXME: Use load_memindex */
10421 }
10425 }
10453 }
10463 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10465 }
10481 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10483 }
10491 if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !MONO_INS_IS_PCONST_NULL (sp [1]))
10509 /* Use the immediate opcodes if possible */
10518 }
10519 }
10524 ip++;
10549 /* FIXME: Pass opcode to is_inst_imm */
10551 /* Use the immediate opcodes if possible */
10552 if (((sp [1]->opcode == OP_ICONST) || (sp [1]->opcode == OP_I8CONST)) && mono_arch_is_inst_imm (sp [1]->opcode == OP_ICONST ? sp [1]->inst_c0 : sp [1]->inst_l)) {
10557 #if SIZEOF_REGISTER == 8
10559 #else
10562 #endif
10563 }
10564 else
10568 /* Might be followed by an instruction added by add_widen_op */
10571 }
10572 }
10576 ip++;
10593 /* Special case this earlier so we have long constants in the IR */
10598 #if SIZEOF_REGISTER == 8
10601 else
10603 #else
10607 else
10609 #endif
10611 }
10614 }
10615 ip++;
10629 }
10630 ip++;
10642 }
10643 ip++;
10661 CHECK_CFG_EXCEPTION;
10662 ip++;
10672 ip++;
10698 }
10713 /* Optimize the common ldobj+stloc combination */
10728 }
10739 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10741 }
10744 }
10746 /* Optimize the ldobj+stobj combination */
10747 /* The reference case ends up being a load+store anyway */
10748 /* Skip this if the operation is volatile. */
10749 if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass) && !(ins_flag & MONO_INST_VOLATILE)) {
10752 sp --;
10759 }
10766 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10768 }
10774 }
10784 }
10791 else
10800 }
10806 CHECK_CFG_ERROR;
10812 /*
10813 * Avoid relocations in AOT and save some space by using a
10814 * version of helper_ldstr specialized to mscorlib.
10815 */
10819 /* Avoid creating the string object */
10823 }
10824 }
10825 else
10830 }
10834 ins->inst_p0 = mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), &cfg->error);
10835 CHECK_CFG_ERROR;
10838 OUT_OF_MEMORY_FAILURE;
10842 }
10843 }
10844 }
10846 sp++;
10852 MonoInst this_ins;
10859 CHECK_CFG_ERROR;
10861 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
10862 CHECK_CFG_ERROR;
10874 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)) {
10877 }
10879 /*
10880 if (cfg->gsharedvt) {
10881 if (mini_is_gsharedvt_variable_signature (sig))
10882 GSHAREDVT_FAILURE (*ip);
10883 }
10884 */
10889 /*
10890 * Generate smaller code for the common newobj <exception> instruction in
10891 * argument checking code.
10892 */
10917 }
10922 }
10924 /* move the args to allow room for 'this' in the first position */
10928 }
10930 /* check_call_signature () requires sp[0] to be set */
10934 UNVERIFIED;
10942 /* Avoid varargs in the common case */
10951 else
10956 /* we simply pass a null pointer */
10958 /* now call the string ctor */
10968 /*
10969 * The code generated by mini_emit_virtual_call () expects
10970 * iargs [0] to be a boxed instance, but luckily the vcall
10971 * will be transformed into a normal call there.
10972 */
10983 /*
10984 * TypeInitializationExceptions thrown from the mono_runtime_class_init
10985 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
10986 * As a workaround, we call class cctors before allocating objects.
10987 */
10988 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
10991 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
10993 }
10997 }
11003 /* Now call the actual ctor */
11005 CHECK_CFG_EXCEPTION;
11006 }
11009 /* Valuetype */
11015 }
11022 }
11032 UNVERIFIED;
11041 CHECK_CFG_EXCEPTION;
11047 }
11077 }
11082 /* LDOBJ */
11086 }
11091 }
11113 }
11116 UNVERIFIED;
11118 UNVERIFIED;
11119 /* frequent check in generic code: box (struct), brtrue */
11121 /*
11122 * Look for:
11123 *
11124 * <push int/long ptr>
11125 * <push int/long>
11126 * box MyFlags
11127 * constrained. MyFlags
11128 * callvirt instace bool class [mscorlib] System.Enum::HasFlag (class [mscorlib] System.Enum)
11129 *
11130 * If we find this sequence and the operand types on box and constrained
11131 * are equal, we can emit a specialized instruction sequence instead of
11132 * the very slow HasFlag () call.
11133 */
11135 /* Cheap checks first. */
11161 }
11162 }
11164 // FIXME: LLVM can't handle the inconsistent bb linking
11179 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11181 }
11187 ip++;
11189 ip++;
11194 ip++;
11200 }
11202 /*
11203 * We need to link both bblocks, since it is needed for handling stack
11204 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
11205 * Branching to only one of them would lead to inconsistencies, so
11206 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
11207 */
11218 }
11227 /* The JIT can't eliminate the iconst+compare */
11231 }
11235 }
11239 CHECK_CFG_EXCEPTION;
11243 }
11266 }
11270 }
11278 #ifndef DISABLE_REMOTING
11280 #endif
11281 guint foffset;
11282 gboolean is_instance;
11285 gboolean is_special_static;
11300 }
11302 UNVERIFIED;
11304 UNVERIFIED;
11308 sp--;
11310 }
11311 }
11318 }
11321 CHECK_CFG_ERROR;
11322 }
11327 /* if the class is Critical then transparent code cannot access it's fields */
11331 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
11332 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
11333 if (mono_security_core_clr_enabled ())
11334 ensure_method_is_allowed_to_access_field (cfg, method, field);
11335 */
11339 /*
11340 * LDFLD etc. is usable on static fields as well, so convert those cases to
11341 * the static case.
11342 */
11356 }
11358 }
11362 /* INSTANCE CASE */
11367 UNVERIFIED;
11368 #ifndef DISABLE_REMOTING
11369 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
11385 CHECK_CFG_EXCEPTION;
11393 }
11395 #endif
11396 {
11402 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11404 }
11412 /* The value is offset by 1 */
11417 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
11421 }
11425 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !MONO_INS_IS_PCONST_NULL (sp [1])) {
11430 /* insert call to write barrier */
11437 }
11438 }
11441 }
11445 }
11447 #ifndef DISABLE_REMOTING
11448 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
11449 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
11457 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
11461 CHECK_CFG_EXCEPTION;
11472 }
11474 #endif
11479 /* Have to compute the address of the variable */
11484 else
11489 }
11495 }
11503 /* The value is offset by 1 */
11508 }
11524 }
11525 }
11531 /* The value is offset by 1 */
11538 }
11543 }
11544 }
11550 }
11552 /* STATIC CASE */
11556 mono_error_set_field_load (&cfg->error, field->parent, field->name, "Using static instructions with literal field");
11557 CHECK_CFG_ERROR;
11558 }
11560 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
11561 * to be called here.
11562 */
11566 }
11576 else
11579 /* Generate IR to compute the field address */
11580 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
11581 /*
11582 * Fast access to TLS data
11583 * Inline version of get_thread_static_data () in
11584 * threads.c.
11585 */
11586 guint32 offset;
11593 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
11598 /* For TLS variables, this will return the TLS offset */
11621 }
11634 }
11639 /*
11640 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
11641 method->klass->name_space, method->klass->name, method->name,
11642 depth, field->offset);
11643 */
11648 /*
11649 * The pointer we're computing here is
11650 *
11651 * super_info.static_data + field->offset
11652 */
11660 /* The value is offset by 1 */
11669 }
11689 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
11691 }
11694 /* This makes so that inline cannot trigger */
11695 /* .cctors: too many apps depend on them */
11696 /* running with a specific order... */
11703 }
11704 }
11705 }
11713 }
11718 }
11719 }
11721 /* Generate IR to do the actual load/store operation */
11724 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11726 }
11745 }
11746 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
11747 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
11753 }
11757 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
11763 sp++;
11767 sp++;
11772 sp++;
11776 sp++;
11781 sp++;
11785 sp++;
11793 sp++;
11803 sp++;
11806 }
11811 sp++;
11819 }
11820 }
11831 }
11832 }
11835 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
11837 }
11842 }
11851 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11853 }
11854 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
11859 /* insert call to write barrier */
11861 }
11867 /*
11868 * Array opcodes
11869 */
11874 guint32 field_token;
11894 }
11901 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
11903 /* vtable */
11906 /* array len */
11911 else
11915 /* Decompose now to avoid problems with references to the domainvar */
11924 /* Decompose later since it is needed by abcrem */
11939 /* Needed so mono_emit_load_get_addr () gets called */
11941 }
11942 }
11949 /*
11950 * we inline/optimize the initialization sequence if possible.
11951 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
11952 * for small sizes open code the memcpy
11953 * ensure the rva field is big enough
11954 */
11955 if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, cfg->cbb, ip + 6) && (len_ins->opcode == OP_ICONST) && (data_ptr = initialize_array_data (method, cfg->compile_aot, ip, klass, len_ins->inst_c0, &data_size, &field_token))) {
11960 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
11962 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
11965 }
11969 }
11972 }
11977 UNVERIFIED;
11983 /* This flag will be inherited by the decomposition */
11988 ip ++;
11996 UNVERIFIED;
12002 /* we need to make sure that this array is exactly the type it needs
12003 * to be for correctness. the wrappers are lax with their usage
12004 * so we need to ignore them here
12005 */
12010 }
12040 }
12041 else
12045 UNVERIFIED;
12050 // FIXME-VT: OP_ICONST optimization
12057 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
12067 }
12071 else
12074 }
12095 }
12096 else
12100 UNVERIFIED;
12106 else
12110 }
12128 }
12132 }
12150 // FIXME:
12153 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12155 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
12163 // FIXME:
12168 }
12169 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
12175 }
12190 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
12198 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
12199 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12200 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12206 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
12207 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12208 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12209 }
12210 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
12218 }
12220 gpointer handle;
12234 }
12237 CHECK_CFG_ERROR;
12238 }
12240 LOAD_ERROR;
12245 /* This case handles ldtoken
12246 of an open type, like for
12247 typeof(Gen<>). */
12250 context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type ((MonoType *)handle));
12255 else
12257 }
12278 }
12299 if (mono_class_get_checked (tclass->image, tclass->type_token, &error) == tclass && !generic_context) {
12300 /* Special case for static synchronized wrappers */
12301 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
12304 /* FIXME: n is not a normal token */
12307 }
12310 }
12312 MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, &cfg->error);
12313 CHECK_CFG_ERROR;
12315 }
12328 MONO_RGCTX_INFO_TYPE);
12337 }
12342 }
12346 }
12347 }
12352 }
12356 UNVERIFIED;
12361 ip++;
12370 /* This can complicate code generation for llvm since the return value might not be defined */
12376 UNVERIFIED;
12377 /* mono_save_seq_point_info () depends on this */
12382 ip++;
12385 /*
12386 * Control will leave the method so empty the stack, otherwise
12387 * the next basic block will start with a nonempty stack.
12388 */
12390 sp--;
12391 }
12403 }
12405 /* empty the stack */
12407 sp--;
12408 }
12410 /*
12411 * If this leave statement is in a catch block, check for a
12412 * pending exception, and rethrow it if necessary.
12413 * We avoid doing this in runtime invoke wrappers, since those are called
12414 * by native code which excepts the wrapper to catch all exceptions.
12415 */
12419 /*
12420 * Use <= in the final comparison to handle clauses with multiple
12421 * leave statements, like in bug #78024.
12422 * The ordering of the exception clauses guarantees that we find the
12423 * innermost clause.
12424 */
12425 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((*ip == CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
12429 /*
12430 MonoInst *load;
12432 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
12433 */
12439 /*
12440 * Currently, we always rethrow the abort exception, despite the
12441 * fact that this is not correct. See thread6.cs for an example.
12442 * But propagating the abort exception is more important than
12443 * getting the sematics right.
12444 */
12450 }
12451 }
12453 #ifdef ENABLE_LLVM
12455 #endif
12474 /*
12475 * Link the finally bblock with the target, since it will
12476 * conceptually branch there.
12477 */
12481 }
12482 }
12484 }
12496 else
12500 }
12502 /*
12503 * Mono specific opcodes
12504 */
12512 gpointer func;
12533 }
12553 }
12559 }
12561 gpointer ptr;
12572 /* Can't embed random pointers into AOT code */
12575 }
12578 gpointer ptr;
12592 }
12595 gpointer ptr;
12605 /*
12606 * This is generated by emit_native_wrapper () to resolve the pinvoke address
12607 * before the call, its not needed when using direct pinvoke.
12608 * This is not an optimization, but its used to avoid looking up pinvokes
12609 * on platforms which don't support dlopen ().
12610 */
12614 }
12619 }
12623 }
12630 // FIXME:
12636 }
12653 }
12666 /*
12667 * Similar to LDOBJ, but instead load the unmanaged
12668 * representation of the vtype to the stack.
12669 */
12678 {
12693 }
12696 /*
12697 * Same as RET, but return the native representation of a vtype
12698 * to the caller.
12699 */
12715 }
12719 UNVERIFIED;
12728 }
12739 else
12744 }
12763 MonoTlsKey key;
12779 }
12780 }
12786 }
12790 /* It would be easier to call a trampoline, but that would put an
12791 * extra frame on the stack, confusing exception handling. So
12792 * implement it inline using an opcode for now.
12793 */
12796 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12797 /* prevent it from being register allocated */
12799 }
12801 /* Has to use a call inst since it local regalloc expects it */
12815 }
12821 }
12837 }
12845 cfg->orig_domain_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12858 /* AOT code is only used in the root domain */
12862 }
12873 }
12875 /* AOT code is only used in the root domain */
12880 /*
12881 * This is called on unattached threads, so it cannot go through the trampoline
12882 * infrastructure. Use an indirect call through a got slot initialized at load time
12883 * instead.
12884 */
12889 }
12897 }
12901 /* Restore the original domain */
12907 }
12913 /*
12914 * This is the same as CEE_CALLI, but passes an additional argument
12915 * to the called method in llvmonly mode.
12916 * This is only used by delegate invoke wrappers to call the
12917 * actual delegate method.
12918 */
12931 CHECK_CFG_ERROR;
12944 /*
12945 * The lowest bit of 'arg' determines whenever the callee uses the gsharedvt
12946 * cconv. This is set by mono_init_delegate ().
12947 */
12961 /* Normal case: callee uses a normal cconv, have to add an out wrapper */
12964 /*
12965 * ADDR points to a gsharedvt-out wrapper, have to pass <callee, arg> as an extra arg.
12966 */
12974 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12979 /* Gsharedvt case: callee uses a gsharedvt cconv, no conversion is needed */
12987 /* Caller uses a normal calling conv */
13001 /* Normal case: callee uses a normal cconv, no conversion is needed */
13004 /* Gsharedvt case: callee uses a gsharedvt cconv, have to add an in wrapper */
13009 /*
13010 * ADDR points to a gsharedvt-in wrapper, have to pass <callee, arg> as an extra arg.
13011 */
13019 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
13026 }
13028 /* Same as CEE_CALLI */
13030 /*
13031 * We pass the address to the gsharedvt trampoline in the rgctx reg
13032 */
13040 }
13041 }
13046 CHECK_CFG_EXCEPTION;
13052 }
13074 }
13076 }
13082 /* somewhat similar to LDTOKEN */
13085 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
13096 }
13109 /*
13110 * The following transforms:
13111 * CEE_CEQ into OP_CEQ
13112 * CEE_CGT into OP_CGT
13113 * CEE_CGT_UN into OP_CGT_UN
13114 * CEE_CLT into OP_CLT
13115 * CEE_CLT_UN into OP_CLT_UN
13116 */
13125 if ((arg1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((arg1->type == STACK_PTR) || (arg1->type == STACK_OBJ) || (arg1->type == STACK_MP))))
13131 else
13139 /*
13140 * The backends expect the fceq opcodes to do the
13141 * comparison too.
13142 */
13146 }
13151 }
13160 CHECK_CFG_ERROR;
13169 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
13175 /*
13176 * Optimize the common case of ldftn+delegate creation
13177 */
13178 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
13179 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13187 LOAD_ERROR;
13197 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
13198 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
13201 }
13202 }
13204 /* FIXME: SGEN support */
13208 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13209 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, FALSE))) {
13210 sp --;
13212 CHECK_CFG_EXCEPTION;
13214 sp ++;
13216 }
13218 }
13219 }
13220 }
13229 }
13237 CHECK_CFG_ERROR;
13246 /*
13247 * Optimize the common case of ldvirtftn+delegate creation
13248 */
13249 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ) && (ip > header->code && ip [-1] == CEE_DUP)) {
13250 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13259 LOAD_ERROR;
13268 /* FIXME: SGEN support */
13272 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13273 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, is_virtual))) {
13276 CHECK_CFG_EXCEPTION;
13278 sp ++;
13280 }
13282 }
13283 }
13284 }
13294 else
13300 }
13327 UNVERIFIED;
13351 }
13357 }
13365 UNVERIFIED;
13376 UNVERIFIED;
13378 /*
13379 * Inlining this into a loop in a parent could lead to
13380 * stack overflows which is different behavior than the
13381 * non-inlined case, thus disable inlining in this case.
13382 */
13388 /* if size != zero */
13392 //size is zero, so result is NULL
13414 }
13422 UNVERIFIED;
13433 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
13436 }
13439 UNVERIFIED;
13442 }
13445 /* FIXME: record alignment? we can assume 1 for now */
13456 /* Can't inline tail calls at this time */
13469 else
13487 /* Skip optimized paths for volatile operations. */
13488 if ((ip [1] == CEE_CPBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
13490 } else if ((ip [1] == CEE_INITBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5) && (sp [1]->opcode == OP_ICONST) && (sp [1]->inst_c0 == 0)) {
13491 /* emit_memset only works when val == 0 */
13499 /*
13500 * FIXME: It's unclear whether we should be emitting both the acquire
13501 * and release barriers for cpblk. It is technically both a load and
13502 * store operation, so it seems like that's the sensible thing to do.
13503 *
13504 * FIXME: We emit full barriers on both sides of the operation for
13505 * simplicity. We should have a separate atomic memcpy method instead.
13506 */
13520 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
13522 }
13525 }
13526 }
13531 }
13538 /* we ignore the no-nullcheck for now since we
13539 * really do it explicitly only when doing callvirt->call
13540 */
13549 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
13552 }
13553 }
13558 UNVERIFIED;
13573 }
13575 guint32 val;
13581 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (method->klass->image) && !generic_context) {
13583 CHECK_CFG_ERROR;
13594 }
13599 }
13608 // FIXME:
13611 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
13613 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
13617 }
13628 UNVERIFIED;
13632 UNVERIFIED;
13633 }
13635 }
13638 UNVERIFIED;
13642 UNVERIFIED;
13643 }
13644 }
13646 UNVERIFIED;
13650 /* This could already be set because of inlining, #693905 */
13658 }
13670 }
13673 }
13675 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
13677 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
13679 #endif
13689 }
13690 }
13693 /* Emit initialization for ref vars */
13694 // FIXME: Avoid duplication initialization for IL locals.
13700 }
13701 }
13706 }
13714 /*
13715 * Make seq points at backward branch targets interruptable.
13716 */
13720 }
13722 /* Add a sequence point for method entry/exit events */
13728 }
13730 /*
13731 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
13732 * the code they refer to was dead (#11880).
13733 */
13736 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
13741 }
13742 }
13743 }
13752 else
13758 }
13761 /* get_most_deep_clause () in mini-llvm.c depends on this for inlined bblocks */
13764 }
13765 }
13770 /* Method is too large */
13772 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Method %s is too complex.", mname));
13774 }
13781 mono_error_exit:
13785 exception_exit:
13789 unverified:
13793 cleanup:
13799 else
13801 }
13803 static int
13805 {
13819 }
13822 }
13824 int
13826 {
13871 #if SIZEOF_REGISTER == 8
13874 #endif
13892 #if defined(TARGET_X86) || defined (TARGET_AMD64)
13897 #endif
13898 #if defined(TARGET_AMD64)
13901 #endif
13912 }
13915 }
13917 static int
13919 {
13945 }
13948 }
13950 static int
13952 {
13971 }
13974 }
13976 int
13978 {
13979 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
13980 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13992 #if SIZEOF_REGISTER == 8
13995 #endif
13996 }
13997 #endif
14000 }
14004 {
14005 #if defined(TARGET_X86)
14037 }
14038 #endif
14040 #if defined(TARGET_AMD64)
14041 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
14092 }
14093 #endif
14096 }
14100 {
14101 #if defined(TARGET_X86) || defined(TARGET_AMD64)
14109 }
14110 #endif
14113 }
14117 {
14118 #ifdef TARGET_X86
14119 /* FIXME: This has sign extension issues */
14120 /*
14121 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14122 return OP_X86_COMPARE_MEMBASE8_IMM;
14123 */
14125 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14137 }
14138 #endif
14140 #ifdef TARGET_AMD64
14141 /* FIXME: This has sign extension issues */
14142 /*
14143 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14144 return OP_X86_COMPARE_MEMBASE8_IMM;
14145 */
14149 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14152 /* FIXME: This only works for 32 bit immediates
14153 case OP_COMPARE_IMM:
14154 case OP_LCOMPARE_IMM:
14155 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
14156 return OP_AMD64_COMPARE_MEMBASE_IMM;
14157 */
14166 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14173 }
14174 #endif
14177 }
14181 {
14182 #ifdef TARGET_X86
14183 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14200 }
14201 #endif
14203 #ifdef TARGET_AMD64
14204 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && cfg->backend->ilp32)) {
14218 }
14219 } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32)) {
14234 }
14235 }
14236 #endif
14239 }
14241 int
14243 {
14245 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
14250 #endif
14251 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
14257 #endif
14258 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
14261 #endif
14264 }
14265 }
14267 /**
14268 * mono_handle_global_vregs:
14269 *
14270 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
14271 * for them.
14272 */
14273 void
14275 {
14280 vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
14282 #ifdef MONO_ARCH_SIMD_INTRINSICS
14285 #endif
14287 /* Find local vregs used in more than one bb */
14299 gint32 prev_bb;
14329 }
14331 #if SIZEOF_REGISTER == 4
14332 /* In the LLVM case, the long opcodes are not decomposed */
14334 /*
14335 * Since some instructions reference the original long vreg,
14336 * and some reference the two component vregs, it is quite hard
14337 * to determine when it needs to be global. So be conservative.
14338 */
14340 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14344 }
14346 /*
14347 * Make the component vregs volatile since the optimizations can
14348 * get confused otherwise.
14349 */
14352 }
14353 #endif
14359 /* 0 is a valid block num */
14362 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
14372 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
14373 else
14377 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14380 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
14388 }
14389 }
14391 /* Flag as having been used in more than one bb */
14393 }
14394 }
14395 }
14396 }
14398 /* If a variable is used in only one bblock, convert it into a local vreg */
14409 #if SIZEOF_REGISTER == 8
14411 #endif
14412 #if !defined(TARGET_X86)
14413 /* Enabling this screws up the fp stack on x86 */
14415 #endif
14419 /*
14420 if (var->type == STACK_VTYPE && cfg->gsharedvt && mini_is_gsharedvt_variable_type (var->inst_vtype))
14421 break;
14422 */
14424 /* Arguments are implicitly global */
14425 /* Putting R4 vars into registers doesn't work currently */
14426 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
14427 if ((var->opcode != OP_ARG) && (var != cfg->ret) && !(var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && (vreg_to_bb [var->dreg] != -1) && (var->klass->byval_arg.type != MONO_TYPE_R4) && !cfg->disable_vreg_to_lvreg && var != cfg->gsharedvt_info_var && var != cfg->gsharedvt_locals_var && var != cfg->lmf_addr_var) {
14428 /*
14429 * Make that the variable's liveness interval doesn't contain a call, since
14430 * that would cause the lvreg to be spilled, making the whole optimization
14431 * useless.
14432 */
14433 /* This is too slow for JIT compilation */
14434 #if 0
14454 }
14455 }
14460 ins_index ++;
14461 }
14465 }
14466 #endif
14472 }
14474 }
14475 }
14477 /*
14478 * Compress the varinfo and vars tables so the liveness computation is faster and
14479 * takes up less space.
14480 */
14492 #if SIZEOF_REGISTER == 4
14494 /* Modify the two component vars too */
14501 }
14502 #endif
14503 }
14504 pos ++;
14505 }
14506 }
14510 }
14512 /*
14513 * mono_allocate_gsharedvt_vars:
14514 *
14515 * Allocate variables with gsharedvt types to entries in the MonoGSharedVtMethodRuntimeInfo.entries array.
14516 * Initialize cfg->gsharedvt_vreg_to_idx with the mapping between vregs and indexes.
14517 */
14518 void
14520 {
14523 cfg->gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
14531 /* Local */
14537 /* Arg */
14540 }
14541 }
14542 }
14543 }
14545 /**
14546 * mono_spill_global_vars:
14547 *
14548 * Generate spill code for variables which are not allocated to registers,
14549 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
14550 * code is generated which could be optimized by the local optimization passes.
14551 */
14552 void
14554 {
14570 /* FIXME: Move this function to mini.c */
14574 #ifdef MONO_ARCH_SIMD_INTRINSICS
14576 #endif
14578 #if SIZEOF_REGISTER == 4
14579 /* Create MonoInsts for longs */
14606 }
14609 }
14610 }
14611 }
14612 #endif
14615 /* registers need liveness info even for !non refs */
14621 }
14622 }
14624 /* FIXME: widening and truncation */
14626 /*
14627 * As an optimization, when a variable allocated to the stack is first loaded into
14628 * an lvreg, we will remember the lvreg and use it the next time instead of loading
14629 * the variable again.
14630 */
14632 vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
14636 /*
14637 * These arrays contain the first and last instructions accessing a given
14638 * variable.
14639 * Since we emit bblocks in the same order we process them here, and we
14640 * don't split live ranges, these will precisely describe the live range of
14641 * the variable, i.e. the instruction range where a valid value can be found
14642 * in the variables location.
14643 * The live range is computed using the liveness info computed by the liveness pass.
14644 * We can't use vmv->range, since that is an abstract live range, and we need
14645 * one which is instruction precise.
14646 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
14647 */
14648 /* FIXME: Only do this if debugging info is requested */
14654 /* Add spill loads/stores */
14661 /* Clear vreg_to_lvreg array */
14679 /*
14680 * We handle LDADDR here as well, since it can only be decomposed
14681 * when variable addresses are known.
14682 */
14687 /* Happens on SPARC/S390 where vtypes are passed by reference */
14692 }
14698 NOT_IMPLEMENTED;
14700 /* gsharedvt arg passed by ref */
14713 /*
14714 * gsharedvt local.
14715 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
14716 */
14723 /* Mark the instruction used to compute the locals var as used */
14726 /* Load the offset */
14729 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
14735 }
14737 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
14738 /* Load the locals area address */
14741 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
14746 }
14747 /* Compute the address */
14762 }
14766 }
14771 }
14773 /*
14774 * Store opcodes have destbasereg in the dreg, but in reality, it is an
14775 * src register.
14776 * FIXME:
14777 */
14791 else
14801 }
14803 /***************/
14804 /* DREG */
14805 /***************/
14807 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
14821 } 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)) {
14822 /*
14823 * Instead of emitting a load+store, use a _membase opcode.
14824 */
14834 }
14837 guint32 lvreg;
14843 /* Invalidate any previous lvreg for this vreg */
14851 }
14855 #if SIZEOF_REGISTER != 8
14857 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));
14859 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));
14862 }
14863 else
14864 #endif
14865 {
14868 /* Try to fuse the store into the instruction itself */
14869 /* FIXME: Add more instructions */
14870 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
14876 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE) || (ins->opcode == OP_RMOVE))) {
14894 // FIXME: The backends expect the base reg to be in inst_basereg
14901 /* printf ("INS: "); mono_print_ins (ins); */
14902 /* Create a store instruction */
14903 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
14905 /* Insert it after the instruction */
14910 /*
14911 * We can't assign ins->dreg to var->dreg here, since the
14912 * sregs could use it. So set a flag, and do it after
14913 * the sregs.
14914 */
14915 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)))
14917 }
14918 }
14919 }
14924 }
14932 }
14933 }
14935 /************/
14936 /* SREGS */
14937 /************/
14948 guint32 load_opcode;
14952 //mono_inst_set_src_registers (ins, sregs);
14956 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14960 /* var->dreg is a hreg */
14963 }
14966 }
14977 /* The variable is already loaded to an lvreg */
14981 //mono_inst_set_src_registers (ins, sregs);
14983 }
14985 /* Try to fuse the load into the instruction */
14989 //mono_inst_set_src_registers (ins, sregs);
14991 } else if ((srcindex == 1) && (op_to_op_src2_membase (cfg, load_opcode, ins->opcode) != -1)) {
14994 //mono_inst_set_src_registers (ins, sregs);
15001 //printf ("%d ", srcindex); mono_print_ins (ins);
15005 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) {
15007 /*
15008 * sreg refers to the value loaded by the load
15009 * emitted below, but we need to use ins->dreg
15010 * since it refers to the store emitted earlier.
15011 */
15013 }
15018 }
15019 }
15022 //mono_inst_set_src_registers (ins, sregs);
15024 #if SIZEOF_REGISTER != 8
15026 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_MS (sreg), var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
15028 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_LS (sreg), var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
15031 }
15032 else
15033 #endif
15034 {
15035 #if SIZEOF_REGISTER == 4
15037 #endif
15041 }
15042 }
15047 }
15049 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
15055 }
15056 }
15057 }
15066 }
15072 }
15075 /* Clear vreg_to_lvreg array */
15082 }
15086 }
15088 /* Extend the live range based on the liveness info */
15094 /* The liveness info is incomplete */
15098 /* Live from at least the first ins of this bb */
15101 }
15104 /* Live at least until the last ins of this bb */
15107 }
15108 }
15109 }
15110 }
15112 /*
15113 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
15114 * by storing the current native offset into MonoMethodVar->live_range_start/end.
15115 */
15116 if (cfg->backend->have_liverange_ops && cfg->compute_precise_live_ranges && cfg->comp_done & MONO_COMP_LIVENESS) {
15126 }
15133 else
15135 }
15136 }
15137 }
15140 /* Nullify if unused */
15143 }
15149 }
15151 static void
15153 {
15161 source = mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, ins->sreg1);
15168 if (!context_used && (mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || klass->is_array_special_interface)) {
15171 else
15173 } else if (!context_used && (mono_class_is_marshalbyref (klass) || mono_class_is_interface (klass))) {
15186 }
15192 else
15194 }
15200 }
15202 void
15204 {
15213 }
15214 }
15215 }
15216 }
15219 /**
15220 * FIXME:
15221 * - use 'iadd' instead of 'int_add'
15222 * - handling ovf opcodes: decompose in method_to_ir.
15223 * - unify iregs/fregs
15224 * -> partly done, the missing parts are:
15225 * - a more complete unification would involve unifying the hregs as well, so
15226 * code wouldn't need if (fp) all over the place. but that would mean the hregs
15227 * would no longer map to the machine hregs, so the code generators would need to
15228 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
15229 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
15230 * fp/non-fp branches speeds it up by about 15%.
15231 * - use sext/zext opcodes instead of shifts
15232 * - add OP_ICALL
15233 * - get rid of TEMPLOADs if possible and use vregs instead
15234 * - clean up usage of OP_P/OP_ opcodes
15235 * - cleanup usage of DUMMY_USE
15236 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
15237 * stack
15238 * - set the stack type and allocate a dreg in the EMIT_NEW macros
15239 * - get rid of all the <foo>2 stuff when the new JIT is ready.
15240 * - make sure handle_stack_args () is called before the branch is emitted
15241 * - when the new IR is done, get rid of all unused stuff
15242 * - COMPARE/BEQ as separate instructions or unify them ?
15243 * - keeping them separate allows specialized compare instructions like
15244 * compare_imm, compare_membase
15245 * - most back ends unify fp compare+branch, fp compare+ceq
15246 * - integrate mono_save_args into inline_method
15247 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
15248 * - handle long shift opts on 32 bit platforms somehow: they require
15249 * 3 sregs (2 for arg1 and 1 for arg2)
15250 * - make byref a 'normal' type.
15251 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
15252 * variable if needed.
15253 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
15254 * like inline_method.
15255 * - remove inlining restrictions
15256 * - fix LNEG and enable cfold of INEG
15257 * - generalize x86 optimizations like ldelema as a peephole optimization
15258 * - add store_mem_imm for amd64
15259 * - optimize the loading of the interruption flag in the managed->native wrappers
15260 * - avoid special handling of OP_NOP in passes
15261 * - move code inserting instructions into one function/macro.
15262 * - try a coalescing phase after liveness analysis
15263 * - add float -> vreg conversion + local optimizations on !x86
15264 * - figure out how to handle decomposed branches during optimizations, ie.
15265 * compare+branch, op_jump_table+op_br etc.
15266 * - promote RuntimeXHandles to vregs
15267 * - vtype cleanups:
15268 * - add a NEW_VARLOADA_VREG macro
15269 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
15270 * accessing vtype fields.
15271 * - get rid of I8CONST on 64 bit platforms
15272 * - dealing with the increase in code size due to branches created during opcode
15273 * decomposition:
15274 * - use extended basic blocks
15275 * - all parts of the JIT
15276 * - handle_global_vregs () && local regalloc
15277 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
15278 * - sources of increase in code size:
15279 * - vtypes
15280 * - long compares
15281 * - isinst and castclass
15282 * - lvregs not allocated to global registers even if used multiple times
15283 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
15284 * meaningful.
15285 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
15286 * - add all micro optimizations from the old JIT
15287 * - put tree optimizations into the deadce pass
15288 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
15289 * specific function.
15290 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
15291 * fcompare + branchCC.
15292 * - create a helper function for allocating a stack slot, taking into account
15293 * MONO_CFG_HAS_SPILLUP.
15294 * - merge r68207.
15295 * - merge the ia64 switch changes.
15296 * - optimize mono_regstate2_alloc_int/float.
15297 * - fix the pessimistic handling of variables accessed in exception handler blocks.
15298 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
15299 * parts of the tree could be separated by other instructions, killing the tree
15300 * arguments, or stores killing loads etc. Also, should we fold loads into other
15301 * instructions if the result of the load is used multiple times ?
15302 * - make the REM_IMM optimization in mini-x86.c arch-independent.
15303 * - LAST MERGE: 108395.
15304 * - when returning vtypes in registers, generate IR and append it to the end of the
15305 * last bb instead of doing it in the epilog.
15306 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
15307 */
15309 /*
15311 NOTES
15312 -----
15314 - When to decompose opcodes:
15315 - earlier: this makes some optimizations hard to implement, since the low level IR
15316 no longer contains the neccessary information. But it is easier to do.
15317 - later: harder to implement, enables more optimizations.
15318 - Branches inside bblocks:
15319 - created when decomposing complex opcodes.
15320 - branches to another bblock: harmless, but not tracked by the branch
15321 optimizations, so need to branch to a label at the start of the bblock.
15322 - branches to inside the same bblock: very problematic, trips up the local
15323 reg allocator. Can be fixed by spitting the current bblock, but that is a
15324 complex operation, since some local vregs can become global vregs etc.
15325 - Local/global vregs:
15326 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
15327 local register allocator.
15328 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
15329 structure, created by mono_create_var (). Assigned to hregs or the stack by
15330 the global register allocator.
15331 - When to do optimizations like alu->alu_imm:
15332 - earlier -> saves work later on since the IR will be smaller/simpler
15333 - later -> can work on more instructions
15334 - Handling of valuetypes:
15335 - When a vtype is pushed on the stack, a new temporary is created, an
15336 instruction computing its address (LDADDR) is emitted and pushed on
15337 the stack. Need to optimize cases when the vtype is used immediately as in
15338 argument passing, stloc etc.
15339 - Instead of the to_end stuff in the old JIT, simply call the function handling
15340 the values on the stack before emitting the last instruction of the bb.
15341 */