| blob | 231270a865c5bfb07b0e0699c658474a6f7e462a |
1 /*
2 * method-to-ir.c: Convert CIL to the JIT internal representation
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002 Ximian, Inc.
9 * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
10 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
11 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
12 */
14 #include <config.h>
16 #ifndef DISABLE_JIT
18 #include <signal.h>
20 #ifdef HAVE_UNISTD_H
21 #include <unistd.h>
22 #endif
24 #include <math.h>
25 #include <string.h>
26 #include <ctype.h>
28 #ifdef HAVE_SYS_TIME_H
29 #include <sys/time.h>
30 #endif
32 #ifdef HAVE_ALLOCA_H
33 #include <alloca.h>
34 #endif
36 #include <mono/utils/memcheck.h>
38 #include <mono/metadata/abi-details.h>
39 #include <mono/metadata/assembly.h>
40 #include <mono/metadata/attrdefs.h>
41 #include <mono/metadata/loader.h>
42 #include <mono/metadata/tabledefs.h>
43 #include <mono/metadata/class.h>
44 #include <mono/metadata/object.h>
45 #include <mono/metadata/exception.h>
46 #include <mono/metadata/opcodes.h>
47 #include <mono/metadata/mono-endian.h>
48 #include <mono/metadata/tokentype.h>
49 #include <mono/metadata/tabledefs.h>
50 #include <mono/metadata/marshal.h>
51 #include <mono/metadata/debug-helpers.h>
52 #include <mono/metadata/mono-debug.h>
53 #include <mono/metadata/mono-debug-debugger.h>
54 #include <mono/metadata/gc-internals.h>
55 #include <mono/metadata/security-manager.h>
56 #include <mono/metadata/threads-types.h>
57 #include <mono/metadata/security-core-clr.h>
58 #include <mono/metadata/profiler-private.h>
59 #include <mono/metadata/profiler.h>
60 #include <mono/metadata/monitor.h>
61 #include <mono/metadata/debug-mono-symfile.h>
62 #include <mono/utils/mono-compiler.h>
63 #include <mono/utils/mono-memory-model.h>
64 #include <mono/utils/mono-error-internals.h>
65 #include <mono/metadata/mono-basic-block.h>
66 #include <mono/metadata/reflection-internals.h>
79 #define BRANCH_COST 10
80 #define INLINE_LENGTH_LIMIT 20
82 /* These have 'cfg' as an implicit argument */
83 #define INLINE_FAILURE(msg) do { \
84 if ((cfg->method != cfg->current_method) && (cfg->current_method->wrapper_type == MONO_WRAPPER_NONE)) { \
85 inline_failure (cfg, msg); \
86 goto exception_exit; \
87 } \
88 } while (0)
89 #define CHECK_CFG_EXCEPTION do {\
90 if (cfg->exception_type != MONO_EXCEPTION_NONE) \
91 goto exception_exit; \
92 } while (0)
93 #define METHOD_ACCESS_FAILURE(method, cmethod) do { \
94 method_access_failure ((cfg), (method), (cmethod)); \
95 goto exception_exit; \
96 } while (0)
97 #define FIELD_ACCESS_FAILURE(method, field) do { \
98 field_access_failure ((cfg), (method), (field)); \
99 goto exception_exit; \
100 } while (0)
101 #define GENERIC_SHARING_FAILURE(opcode) do { \
102 if (cfg->gshared) { \
103 gshared_failure (cfg, opcode, __FILE__, __LINE__); \
104 goto exception_exit; \
105 } \
106 } while (0)
107 #define GSHAREDVT_FAILURE(opcode) do { \
108 if (cfg->gsharedvt) { \
109 gsharedvt_failure (cfg, opcode, __FILE__, __LINE__); \
110 goto exception_exit; \
111 } \
112 } while (0)
113 #define OUT_OF_MEMORY_FAILURE do { \
114 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
116 goto exception_exit; \
117 } while (0)
118 #define DISABLE_AOT(cfg) do { \
119 if ((cfg)->verbose_level >= 2) \
121 (cfg)->disable_aot = TRUE; \
122 } while (0)
123 #define LOAD_ERROR do { \
124 break_on_unverified (); \
125 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD); \
126 goto exception_exit; \
127 } while (0)
129 #define TYPE_LOAD_ERROR(klass) do { \
130 cfg->exception_ptr = klass; \
131 LOAD_ERROR; \
132 } while (0)
134 #define CHECK_CFG_ERROR do {\
135 if (!mono_error_ok (&cfg->error)) { \
136 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR); \
137 goto mono_error_exit; \
138 } \
139 } while (0)
141 /* Determine whenever 'ins' represents a load of the 'this' argument */
142 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
150 MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
152 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
155 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp);
157 /* helper methods signatures */
163 /* type loading helpers */
164 static GENERATE_GET_CLASS_WITH_CACHE (runtime_helpers, System.Runtime.CompilerServices, RuntimeHelpers)
165 static GENERATE_TRY_GET_CLASS_WITH_CACHE (debuggable_attribute, System.Diagnostics, DebuggableAttribute)
167 /*
168 * Instruction metadata
169 */
170 #ifdef MINI_OP
171 #undef MINI_OP
172 #endif
173 #ifdef MINI_OP3
174 #undef MINI_OP3
175 #endif
177 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
183 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == SIZEOF_VOID_P
184 #define LREG IREG
185 #else
187 #endif
188 /* keep in sync with the enum in mini.h */
189 const char
190 ins_info[] = {
192 };
193 #undef MINI_OP
194 #undef MINI_OP3
196 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
197 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
198 /*
199 * This should contain the index of the last sreg + 1. This is not the same
200 * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
201 */
204 };
205 #undef MINI_OP
206 #undef MINI_OP3
208 #define MONO_INIT_VARINFO(vi,id) do { \
209 (vi)->range.first_use.pos.bid = 0xffff; \
210 (vi)->reg = -1; \
211 (vi)->idx = (id); \
212 } while (0)
214 guint32
216 {
218 }
220 guint32
222 {
224 }
226 guint32
228 {
230 }
232 guint32
234 {
236 }
238 guint32
240 {
242 }
244 /*
245 * mono_alloc_ireg_ref:
246 *
247 * Allocate an IREG, and mark it as holding a GC ref.
248 */
249 guint32
251 {
253 }
255 /*
256 * mono_alloc_ireg_mp:
257 *
258 * Allocate an IREG, and mark it as holding a managed pointer.
259 */
260 guint32
262 {
264 }
266 /*
267 * mono_alloc_ireg_copy:
268 *
269 * Allocate an IREG with the same GC type as VREG.
270 */
271 guint32
273 {
278 else
280 }
282 guint
284 {
289 handle_enum:
313 #if SIZEOF_REGISTER == 8
315 #else
317 #endif
326 }
340 else
344 }
346 }
348 void
350 {
363 }
365 void
367 {
371 }
375 {
378 }
382 {
386 mono_error_set_generic_error (&cfg->error, "System", "MethodAccessException", "Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname);
389 }
393 {
397 mono_error_set_generic_error (&cfg->error, "System", "FieldAccessException", "Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);
400 }
404 {
408 }
412 {
414 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);
416 }
420 {
421 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);
425 }
427 /*
428 * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
429 * foo<T> (int i) { ldarg.0; box T; }
430 */
431 #define UNVERIFIED do { \
432 if (cfg->gsharedvt) { \
433 if (cfg->verbose_level > 2) \
435 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
436 goto exception_exit; \
437 } \
438 break_on_unverified (); \
439 goto unverified; \
440 } while (0)
442 #define GET_BBLOCK(cfg,tblock,ip) do { \
443 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
444 if (!(tblock)) { \
445 if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
446 NEW_BBLOCK (cfg, (tblock)); \
447 (tblock)->cil_code = (ip); \
448 ADD_BBLOCK (cfg, (tblock)); \
449 } \
450 } while (0)
452 #if defined(TARGET_X86) || defined(TARGET_AMD64)
453 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
454 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
455 (dest)->dreg = alloc_ireg_mp ((cfg)); \
456 (dest)->sreg1 = (sr1); \
457 (dest)->sreg2 = (sr2); \
458 (dest)->inst_imm = (imm); \
459 (dest)->backend.shift_amount = (shift); \
460 MONO_ADD_INS ((cfg)->cbb, (dest)); \
461 } while (0)
462 #endif
464 /* Emit conversions so both operands of a binary opcode are of the same type */
465 static void
467 {
476 /* Mixing r4/r8 is allowed by the spec */
484 }
492 }
493 }
495 #if SIZEOF_REGISTER == 8
496 /* FIXME: Need to add many more cases */
503 }
504 #endif
505 }
507 #define ADD_BINOP(op) do { \
508 MONO_INST_NEW (cfg, ins, (op)); \
509 sp -= 2; \
510 ins->sreg1 = sp [0]->dreg; \
511 ins->sreg2 = sp [1]->dreg; \
512 type_from_op (cfg, ins, sp [0], sp [1]); \
513 CHECK_TYPE (ins); \
515 add_widen_op (cfg, ins, &sp [0], &sp [1]); \
516 ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
517 MONO_ADD_INS ((cfg)->cbb, (ins)); \
518 *sp++ = mono_decompose_opcode ((cfg), (ins)); \
519 } while (0)
521 #define ADD_UNOP(op) do { \
522 MONO_INST_NEW (cfg, ins, (op)); \
523 sp--; \
524 ins->sreg1 = sp [0]->dreg; \
525 type_from_op (cfg, ins, sp [0], NULL); \
526 CHECK_TYPE (ins); \
527 (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
528 MONO_ADD_INS ((cfg)->cbb, (ins)); \
529 *sp++ = mono_decompose_opcode (cfg, ins); \
530 } while (0)
532 #define ADD_BINCOND(next_block) do { \
533 MonoInst *cmp; \
534 sp -= 2; \
535 MONO_INST_NEW(cfg, cmp, OP_COMPARE); \
536 cmp->sreg1 = sp [0]->dreg; \
537 cmp->sreg2 = sp [1]->dreg; \
538 type_from_op (cfg, cmp, sp [0], sp [1]); \
539 CHECK_TYPE (cmp); \
540 add_widen_op (cfg, cmp, &sp [0], &sp [1]); \
541 type_from_op (cfg, ins, sp [0], sp [1]); \
542 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2); \
543 GET_BBLOCK (cfg, tblock, target); \
544 link_bblock (cfg, cfg->cbb, tblock); \
545 ins->inst_true_bb = tblock; \
546 if ((next_block)) { \
547 link_bblock (cfg, cfg->cbb, (next_block)); \
548 ins->inst_false_bb = (next_block); \
549 start_new_bblock = 1; \
550 } else { \
551 GET_BBLOCK (cfg, tblock, ip); \
552 link_bblock (cfg, cfg->cbb, tblock); \
553 ins->inst_false_bb = tblock; \
554 start_new_bblock = 2; \
555 } \
556 if (sp != stack_start) { \
557 handle_stack_args (cfg, stack_start, sp - stack_start); \
558 CHECK_UNVERIFIABLE (cfg); \
559 } \
560 MONO_ADD_INS (cfg->cbb, cmp); \
561 MONO_ADD_INS (cfg->cbb, ins); \
562 } while (0)
564 /* *
565 * link_bblock: Links two basic blocks
566 *
567 * links two basic blocks in the control flow graph, the 'from'
568 * argument is the starting block and the 'to' argument is the block
569 * the control flow ends to after 'from'.
570 */
571 static void
573 {
577 #if 0
580 printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
581 else
586 else
588 }
589 #endif
596 }
597 }
599 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
602 }
606 }
613 }
614 }
616 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
619 }
623 }
624 }
626 void
628 {
630 }
632 /**
633 * mono_find_block_region:
634 *
635 * We mark each basic block with a region ID. We use that to avoid BB
636 * optimizations when blocks are in different regions.
637 *
638 * Returns:
639 * A region token that encodes where this region is, and information
640 * about the clause owner for this block.
641 *
642 * The region encodes the try/catch/filter clause that owns this block
643 * as well as the type. -1 is a special value that represents a block
644 * that is in none of try/catch/filter.
645 */
646 static int
648 {
655 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
664 else
666 }
667 }
673 }
676 }
680 {
692 }
693 }
695 }
697 static void
699 {
707 /* prevent it from being register allocated */
711 }
713 MonoInst *
715 {
717 }
721 {
729 /* prevent it from being register allocated */
735 }
737 /*
738 * Returns the type used in the eval stack when @type is loaded.
739 * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
740 */
741 void
743 {
751 }
753 handle_enum:
797 }
813 }
817 }
818 }
820 /*
821 * The following tables are used to quickly validate the IL code in type_from_op ().
822 */
823 static const char
829 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R8},
833 {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4}
834 };
836 static const char
837 neg_table [] = {
839 };
841 /* reduce the size of this table */
842 static const char
852 };
854 static const char
856 /* Inv i L p F & O vt r4 */
866 };
868 /* reduce the size of this table */
869 static const char
879 };
881 /*
882 * Tables to map from the non-specific opcode to the matching
883 * type-specific opcode.
884 */
885 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
886 static const guint16
888 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
889 };
891 /* handles from CEE_NEG to CEE_CONV_U8 */
892 static const guint16
894 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
895 };
897 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
898 static const guint16
900 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
901 };
903 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
904 static const guint16
906 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
907 };
909 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
910 static const guint16
912 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
913 };
915 /* handles from CEE_BEQ to CEE_BLT_UN */
916 static const guint16
918 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
919 };
921 /* handles from CEE_CEQ to CEE_CLT_UN */
922 static const guint16
924 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
925 };
927 /*
928 * Sets ins->type (the type on the eval stack) according to the
929 * type of the opcode and the arguments to it.
930 * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
931 *
932 * FIXME: this function sets ins->type unconditionally in some cases, but
933 * it should set it to invalid for some types (a conv.x on an object)
934 */
935 static void
937 {
939 /* binops */
945 /* FIXME: check unverifiable args for STACK_MP */
967 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
973 else
978 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
1004 /* unops */
1012 else
1033 }
1066 #if SIZEOF_VOID_P == 8
1068 #else
1070 #endif
1078 }
1151 }
1155 }
1157 static const char
1158 ldind_type [] = {
1159 STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1160 };
1162 #if 0
1164 static const char
1167 };
1169 static int
1171 {
1182 }
1183 args++;
1184 }
1205 }
1218 }
1219 /*if (!param_table [args [i].type] [sig->params [i]->type])
1220 return 0;*/
1221 }
1223 }
1224 #endif
1226 /*
1227 * When we need a pointer to the current domain many times in a method, we
1228 * call mono_domain_get() once and we store the result in a local variable.
1229 * This function returns the variable that represents the MonoDomain*.
1230 */
1233 {
1237 }
1239 /*
1240 * The got_var contains the address of the Global Offset Table when AOT
1241 * compiling.
1242 */
1243 MonoInst *
1245 {
1250 }
1252 }
1256 {
1261 /* force the var to be stack allocated */
1263 }
1266 }
1282 }
1284 }
1288 {
1322 else
1327 }
1330 }
1334 {
1368 }
1370 }
1372 /*
1373 * We try to share variables when possible
1374 */
1377 {
1381 /* inlining can result in deeper stacks */
1401 }
1403 }
1405 static void
1407 {
1408 /*
1409 * Don't use this if a generic_context is set, since that means AOT can't
1410 * look up the method using just the image+token.
1411 * table == 0 means this is a reference made from a wrapper.
1412 */
1414 MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1418 }
1419 }
1421 /*
1422 * This function is called to handle items that are left on the evaluation stack
1423 * at basic block boundaries. What happens is that we save the values to local variables
1424 * and we reload them later when first entering the target basic block (with the
1425 * handle_loaded_temps () function).
1426 * A single joint point will use the same variables (stored in the array bb->out_stack or
1427 * bb->in_stack, if the basic block is before or after the joint point).
1428 *
1429 * This function needs to be called _before_ emitting the last instruction of
1430 * the bb (i.e. before emitting a branch).
1431 * If the stack merge fails at a join point, cfg->unverifiable is set.
1432 */
1433 static void
1435 {
1440 gboolean found;
1448 //printf ("bblock %d has out:", bb->block_num);
1452 /* exception handlers are linked, but they should not be considered for stack args */
1455 //printf (" %d", outb->block_num);
1460 }
1461 }
1462 //printf ("\n");
1466 /*
1467 * try to reuse temps already allocated for this purpouse, if they occupy the same
1468 * stack slot and if they are of the same type.
1469 * This won't cause conflicts since if 'local' is used to
1470 * store one of the values in the in_stack of a bblock, then
1471 * the same variable will be used for the same outgoing stack
1472 * slot as well.
1473 * This doesn't work when inlining methods, since the bblocks
1474 * in the inlined methods do not inherit their in_stack from
1475 * the bblock they are inlined to. See bug #58863 for an
1476 * example.
1477 */
1480 else
1482 }
1483 }
1484 }
1488 /* exception handlers are linked, but they should not be considered for stack args */
1495 }
1497 }
1500 }
1510 }
1512 /*
1513 * It is possible that the out bblocks already have in_stack assigned, and
1514 * the in_stacks differ. In this case, we will store to all the different
1515 * in_stacks.
1516 */
1521 /* Find a bblock which has a different in_stack */
1525 /* exception handlers are linked, but they should not be considered for stack args */
1527 bindex++;
1529 }
1537 }
1541 }
1542 bindex ++;
1543 }
1544 }
1545 }
1549 {
1555 MonoJumpInfo ji;
1556 gpointer target;
1557 MonoError error;
1565 }
1567 }
1569 static void
1570 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1571 {
1573 #ifdef COMPRESSED_INTERFACE_BITMAP
1582 #else
1597 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1603 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1604 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1605 }
1606 #endif
1607 }
1609 /*
1610 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1611 * stored in "klass_reg" implements the interface "klass".
1612 */
1613 static void
1614 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1615 {
1616 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1617 }
1619 /*
1620 * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1621 * stored in "vtable_reg" implements the interface "klass".
1622 */
1623 static void
1624 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1625 {
1626 mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1627 }
1629 /*
1630 * Emit code which checks whenever the interface id of @klass is smaller than
1631 * than the value given by max_iid_reg.
1632 */
1633 static void
1636 {
1641 }
1642 else
1646 else
1648 }
1650 /* Same as above, but obtains max_iid from a vtable */
1651 static void
1654 {
1657 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, max_interface_id));
1659 }
1661 /* Same as above, but obtains max_iid from a klass */
1662 static void
1665 {
1668 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id));
1670 }
1672 static void
1673 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1674 {
1682 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1685 }
1686 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1696 }
1698 }
1700 static void
1701 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1702 {
1704 }
1706 static void
1707 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1708 {
1716 else
1718 }
1720 /*
1721 * Variant of the above that takes a register to the class, not the vtable.
1722 */
1723 static void
1724 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1725 {
1733 else
1735 }
1738 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1739 {
1745 }
1747 }
1751 {
1753 }
1756 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1757 {
1764 }
1766 }
1768 static void
1769 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1771 static void
1772 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1773 {
1779 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank));
1782 // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
1783 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
1786 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
1787 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1790 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1797 // Pass -1 as obj_reg to skip the check below for arrays of arrays
1799 }
1802 /* Check that the object is a vector too */
1807 }
1816 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1819 }
1820 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1823 }
1824 }
1826 static void
1827 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1828 {
1830 }
1832 static void
1834 {
1853 #if SIZEOF_REGISTER == 8
1857 #endif
1858 }
1859 }
1865 else
1869 /* This could be optimized further if neccesary */
1874 }
1876 }
1883 }
1888 }
1889 }
1895 }
1900 }
1905 }
1906 }
1908 void
1909 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1910 {
1916 /*FIXME arbitrary hack to avoid unbound code expansion.*/
1920 /* This could be optimized further if neccesary */
1928 }
1929 }
1939 }
1940 }
1949 }
1957 }
1965 }
1966 }
1968 static void
1970 {
1984 }
1985 }
1987 /*
1988 * emit_push_lmf:
1989 *
1990 * Emit IR to push the current LMF onto the LMF stack.
1991 */
1992 static void
1994 {
1995 /*
1996 * Emit IR to push the LMF:
1997 * lmf_addr = <lmf_addr from tls>
1998 * lmf->lmf_addr = lmf_addr
1999 * lmf->prev_lmf = *lmf_addr
2000 * *lmf_addr = lmf
2001 */
2009 /* Load current lmf */
2015 /* Save previous_lmf */
2016 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), lmf_ins->dreg);
2017 /* Set new LMF */
2020 /*
2021 * Store lmf_addr in a variable, so it can be allocated to a global register.
2022 */
2024 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2026 #ifdef HOST_WIN32
2033 EMIT_NEW_BIALU_IMM (cfg, lmf_ins, OP_PADD_IMM, lmf_reg, jit_tls_dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2036 }
2037 #else
2042 #ifdef TARGET_IOS
2045 /* Inline mono_get_lmf_addr () */
2046 /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
2048 /* Load mono_jit_tls_id */
2051 else
2053 /* call pthread_getspecific () */
2055 /* lmf_addr = &jit_tls->lmf */
2056 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, cfg->lmf_addr_var->dreg, jit_tls_ins->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2058 #else
2060 #endif
2061 }
2062 #endif
2069 /* Save previous_lmf */
2071 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
2072 /* Set new lmf */
2074 }
2075 }
2077 /*
2078 * emit_pop_lmf:
2079 *
2080 * Emit IR to pop the current LMF from the LMF stack.
2081 */
2082 static void
2084 {
2095 /* Load previous_lmf */
2097 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2098 /* Set new LMF */
2101 /*
2102 * Emit IR to pop the LMF:
2103 * *(lmf->lmf_addr) = lmf->prev_lmf
2104 */
2105 /* This could be called before emit_push_lmf () */
2107 cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2111 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2113 }
2114 }
2116 static void
2118 {
2121 /*
2122 * Avoid instrumenting inlined methods since it can
2123 * distort profiling results.
2124 */
2131 }
2132 }
2134 static int
2136 {
2137 handle_enum:
2166 else
2183 /* gsharedvt */
2187 }
2189 }
2191 //XXX this ignores if t is byref
2192 #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)))))
2194 /*
2195 * target_type_is_incompatible:
2196 * @cfg: MonoCompile context
2197 *
2198 * Check that the item @arg on the evaluation stack can be stored
2199 * in the target type (can be a local, or field, etc).
2200 * The cfg arg can be used to check if we need verification or just
2201 * validity checks.
2202 *
2203 * Returns: non-0 value if arg can't be stored on a target.
2204 */
2205 static int
2207 {
2212 /* FIXME: check that the pointed to types match */
2215 /* This is needed to handle gshared types + ldaddr. We lower the types so we can handle enums and other typedef-like types. */
2216 MonoClass *target_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&mono_class_from_mono_type (target)->byval_arg));
2217 MonoClass *source_class_lowered = mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg));
2219 /* if the target is native int& or same type */
2223 /* Both are primitive type byrefs and the source points to a larger type that the destination */
2224 if (MONO_TYPE_IS_PRIMITIVE_SCALAR (&target_class_lowered->byval_arg) && MONO_TYPE_IS_PRIMITIVE_SCALAR (&source_class_lowered->byval_arg) &&
2225 mono_class_instance_size (target_class_lowered) <= mono_class_instance_size (source_class_lowered))
2228 }
2232 }
2248 /* STACK_MP is needed when setting pinned locals */
2255 /*
2256 * Some opcodes like ldloca returns 'transient pointers' which can be stored in
2257 * in native int. (#688008).
2258 */
2269 /* FIXME: check type compatibility */
2305 /* The second cases is needed when doing partial sharing */
2306 if (klass != arg->klass && target_class != arg->klass && target_class != mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg)))
2312 /* FIXME: check type compatibility */
2314 }
2324 }
2328 }
2330 }
2332 /*
2333 * Prepare arguments for passing to a function call.
2334 * Return a non-zero value if the arguments can't be passed to the given
2335 * signature.
2336 * The type checks are not yet complete and some conversions may need
2337 * casts on 32 or 64 bit architectures.
2338 *
2339 * FIXME: implement this using target_type_is_incompatible ()
2340 */
2341 static int
2343 {
2350 args++;
2351 }
2357 }
2359 handle_enum:
2377 if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2405 }
2418 /* gsharedvt */
2425 }
2426 }
2428 }
2430 static int
2432 {
2448 }
2451 }
2453 static int
2455 {
2471 }
2474 }
2476 /* Either METHOD or IMT_ARG needs to be set */
2477 static void
2478 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2479 {
2489 }
2491 #ifdef ENABLE_LLVM
2493 #endif
2496 }
2504 }
2507 }
2511 {
2519 }
2521 static int
2523 {
2526 else
2528 }
2530 static int
2532 {
2535 else
2537 }
2539 /*
2540 * check_method_sharing:
2541 *
2542 * Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2543 */
2544 static void
2545 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2546 {
2557 /*
2558 * Pass vtable iff target method might
2559 * be shared, which means that sharing
2560 * is enabled for its class and its
2561 * context is sharable (and it's not a
2562 * generic method).
2563 */
2564 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2566 }
2577 }
2578 }
2584 }
2589 {
2592 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2594 #endif
2616 //g_assert_not_reached ();
2617 }
2624 /*
2625 * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2626 * address of return value to increase optimization opportunities.
2627 * Before vtype decomposition, the dreg of the call ins itself represents the
2628 * fact the call modifies the return value. After decomposition, the call will
2629 * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2630 * will be transformed into an LDADDR.
2631 */
2635 /* We reference the call too since call->dreg could change during optimization */
2645 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2647 /*
2648 * If the call has a float argument, we would need to do an r8->r4 conversion using
2649 * an icall, but that cannot be done during the call sequence since it would clobber
2650 * the call registers + the stack. So we do it before emitting the call.
2651 */
2658 else
2669 /* The result will be in an int vreg */
2671 }
2672 }
2673 }
2674 #endif
2678 #ifdef ENABLE_LLVM
2681 else
2683 #else
2685 #endif
2691 }
2693 static void
2695 {
2699 #ifdef ENABLE_LLVM
2701 #endif
2702 }
2705 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2706 {
2712 if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2717 }
2722 }
2726 cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2731 }
2733 call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2751 /* Restore the stack so we don't crash when throwing the exception */
2758 }
2764 }
2767 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2770 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2772 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2775 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2777 {
2778 #ifndef DISABLE_REMOTING
2780 #endif
2787 gboolean need_unbox_trampoline;
2798 }
2801 /* Create the real signature */
2802 /* FIXME: Cache these */
2807 }
2811 #ifndef DISABLE_REMOTING
2821 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2824 }
2825 #endif
2830 need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
2832 call = mono_emit_call_args (cfg, sig, args, FALSE, virtual_, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2834 #ifndef DISABLE_REMOTING
2837 else
2838 #endif
2850 if (!cfg->llvm_only && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2855 /* Make a call to delegate->invoke_impl */
2860 /* We must emit a dummy use here because the delegate trampoline will
2861 replace the 'this' argument with the delegate target making this activation
2862 no longer a root for the delegate.
2863 This is an issue for delegates that target collectible code such as dynamic
2864 methods of GC'able assemblies.
2866 For a test case look into #667921.
2868 FIXME: a dummy use is not the best way to do it as the local register allocator
2869 will put it on a caller save register and spil it around the call.
2870 Ideally, we would either put it on a callee save register or only do the store part.
2871 */
2875 }
2882 /*
2883 * the method is not virtual, we just need to ensure this is not null
2884 * and then we can call the method directly.
2885 */
2886 #ifndef DISABLE_REMOTING
2887 if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2888 /*
2889 * The check above ensures method is not gshared, this is needed since
2890 * gshared methods can't have wrappers.
2891 */
2893 }
2894 #endif
2901 /*
2902 * the method is virtual, but we can statically dispatch since either
2903 * it's class or the method itself are sealed.
2904 * But first we need to ensure it's not a null reference.
2905 */
2911 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2918 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2931 }
2932 }
2937 }
2938 }
2946 }
2948 MonoInst*
2949 mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this_ins)
2950 {
2951 return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this_ins, NULL, NULL);
2952 }
2954 MonoInst*
2957 {
2968 }
2970 MonoInst*
2972 {
2978 }
2980 /*
2981 * mono_emit_abs_call:
2982 *
2983 * Emit a call to the runtime function described by PATCH_TYPE and DATA.
2984 */
2988 {
2992 /*
2993 * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2994 * handle it.
2995 */
3002 }
3006 {
3007 // FIXME: memory allocation
3011 res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
3018 }
3020 /* Make an indirect call to FSIG passing an additional argument */
3022 emit_extra_arg_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **orig_args, int arg_reg, MonoInst *call_target)
3023 {
3029 /* Make a call with an rgctx/extra arg */
3032 else
3033 args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
3043 }
3045 /* Emit an indirect call to the function descriptor ADDR */
3047 emit_llvmonly_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, MonoInst *addr)
3048 {
3054 /*
3055 * addr points to a <addr, arg> pair, load both of them, and
3056 * make a call to addr, passing arg as an extra arg.
3057 */
3064 }
3066 static gboolean
3068 {
3069 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
3070 #ifdef TARGET_AMD64
3073 #endif
3077 }
3079 MonoInst*
3080 mono_emit_jit_icall_by_info (MonoCompile *cfg, int il_offset, MonoJitICallInfo *info, MonoInst **args)
3081 {
3082 /*
3083 * Call the jit icall without a wrapper if possible.
3084 * The wrapper is needed for the following reasons:
3085 * - to handle exceptions thrown using mono_raise_exceptions () from the
3086 * icall function. The EH code needs the lmf frame pushed by the
3087 * wrapper to be able to unwind back to managed code.
3088 * - to be able to do stack walks for asynchronously suspended
3089 * threads when debugging.
3090 */
3100 }
3102 /*
3103 * Inline the wrapper method, which is basically a call to the C icall, and
3104 * an exception check.
3105 */
3114 }
3115 }
3119 {
3124 /*
3125 * Native code might return non register sized integers
3126 * without initializing the upper bits.
3127 */
3143 }
3152 }
3153 }
3154 }
3157 }
3161 {
3167 }
3169 }
3171 static void
3172 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
3173 {
3190 }
3191 }
3192 }
3194 static void
3196 {
3198 gpointer card_table_mask;
3211 if (cfg->backend->have_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3227 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3228 * IMM's larger than 32bits.
3229 */
3238 }
3241 }
3243 static gboolean
3244 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3245 {
3252 /*types with references can't have alignment smaller than sizeof(void*) */
3256 /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3262 /* We don't unroll more than 5 stores to avoid code bloat. */
3264 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3272 }
3281 /*tmp = dreg*/
3301 /*tmp += sizeof (void*)*/
3305 }
3306 }
3308 /* Those cannot be references since size < sizeof (void*) */
3314 }
3321 }
3328 }
3331 }
3333 /*
3334 * Emit code to copy a valuetype of type @klass whose address is stored in
3335 * @src->dreg to memory whose address is stored at @dest->dreg.
3336 */
3337 void
3338 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3339 {
3351 /*
3352 * This check breaks with spilled vars... need to handle it during verification anyway.
3353 * g_assert (klass && klass == src->klass && klass == dest->klass);
3354 */
3360 }
3364 else
3367 /* if native is true there should be no references in the struct */
3369 /* Avoid barriers when storing to the stack */
3379 /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3380 if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3388 }
3392 else
3395 }
3396 }
3399 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3406 else
3412 else
3414 }
3415 }
3419 {
3425 }
3427 }
3429 void
3431 {
3434 guint32 align;
3440 /* FIXME: Optimize this for the case when dest is an LDADDR */
3446 bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3452 }
3460 }
3467 }
3468 }
3470 /*
3471 * emit_get_rgctx:
3472 *
3473 * Emit IR to return either the this pointer for instance method,
3474 * or the mrgctx for static methods.
3475 */
3478 {
3511 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3513 }
3521 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this_ins->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3523 }
3524 }
3527 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3528 {
3529 MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
3538 }
3542 {
3546 // FIXME: No fastpath since the slot is not a compile time constant
3551 else
3554 #if 0
3555 /*
3556 * FIXME: This can be called during decompose, which is a problem since it creates
3557 * new bblocks.
3558 * Also, the fastpath doesn't work since the slot number is dynamically allocated.
3559 */
3561 gboolean mrgctx;
3578 }
3588 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, rgctx_reg, rgctx->dreg, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
3589 // FIXME: Avoid this check by allocating the table when the vtable is created etc.
3594 }
3599 /* load ptr to next array */
3601 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
3602 else
3605 /* is the ptr null? */
3607 /* if yes, jump to actual trampoline */
3609 }
3611 /* fetch slot */
3614 /* is the slot null? */
3616 /* if yes, jump to actual trampoline */
3619 /* Fastpath */
3628 /* Slowpath */
3634 else
3645 #endif
3646 }
3648 /*
3649 * emit_rgctx_fetch:
3650 *
3651 * Emit IR to load the value of the rgctx entry ENTRY from the rgctx
3652 * given by RGCTX.
3653 */
3656 {
3659 else
3660 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3661 }
3666 {
3667 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);
3671 }
3676 {
3677 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);
3681 }
3686 {
3691 call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
3695 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);
3699 }
3701 /*
3702 * emit_get_rgctx_virt_method:
3703 *
3704 * Return data for method VIRT_METHOD for a receiver of type KLASS.
3705 */
3709 {
3714 info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
3718 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);
3722 }
3727 {
3731 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);
3735 }
3737 /*
3738 * emit_get_rgctx_method:
3739 *
3740 * Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3741 * normal constants, else emit a load from the rgctx.
3742 */
3746 {
3759 }
3761 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);
3765 }
3766 }
3771 {
3772 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);
3776 }
3778 static int
3780 {
3790 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3792 }
3798 new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3800 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3803 }
3813 }
3815 /*
3816 * emit_get_gsharedvt_info:
3817 *
3818 * This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3819 */
3822 {
3827 /* Load info->entries [idx] */
3829 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3832 }
3835 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3836 {
3838 }
3840 /*
3841 * On return the caller must check @klass for load errors.
3842 */
3843 static void
3845 {
3860 }
3865 /*
3866 * Using an opcode instead of emitting IR here allows the hiding of the call inside the opcode,
3867 * so this doesn't have to clobber any regs and it doesn't break basic blocks.
3868 */
3885 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, bits_reg, vtable_arg->dreg, byte_offset);
3897 }
3898 }
3900 static void
3901 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3902 {
3910 }
3911 }
3913 static void
3915 {
3928 }
3934 }
3937 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3938 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3940 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3951 }
3952 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3956 }
3957 }
3959 static void
3961 {
3962 /* Reset the variables holding the cast details */
3967 /* It is enough to reset the from field */
3968 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3969 }
3970 }
3972 /*
3973 * On return the caller must check @array_class for load errors
3974 */
3975 static void
3977 {
3985 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3991 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4014 }
4015 }
4020 }
4022 /**
4023 * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
4024 * generic code is generated.
4025 */
4028 {
4034 /* FIXME: What if the class is shared? We might not
4035 have to get the address of the method from the
4036 RGCTX. */
4038 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4045 }
4058 }
4061 }
4062 }
4066 {
4075 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4076 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4078 /* FIXME: generics */
4081 // Check rank == 0
4085 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4086 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, element_class));
4091 /* This assertion is from the unboxcast insn */
4103 }
4105 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
4111 }
4115 {
4123 /* obj */
4126 /* klass */
4129 /* CASTCLASS */
4139 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4142 /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
4145 /* Non-ref case */
4146 /* UNBOX */
4152 /* Ref case */
4155 /* Save the ref to a temporary */
4162 /* Nullable case */
4165 {
4166 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
4170 unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4177 else
4182 }
4186 /* End */
4189 /* LDOBJ */
4193 }
4195 /*
4196 * Returns NULL and set the cfg exception on error.
4197 */
4200 {
4206 MonoRgctxInfoType rgctx_info;
4210 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (klass, for_box, known_instance_size);
4214 else
4225 }
4234 }
4236 }
4239 }
4246 } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
4247 /* This happens often in argument checking code, eg. throw new FooException... */
4248 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
4254 gboolean pass_lw;
4260 }
4272 }
4279 }
4282 }
4283 }
4286 }
4288 /*
4289 * Returns NULL and set the cfg exception on error.
4290 */
4293 {
4302 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4305 /* FIXME: What if the class is shared? We might not
4306 have to get the method address from the RGCTX. */
4308 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4312 }
4325 }
4328 }
4329 }
4345 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4348 /* Non-ref case */
4352 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4360 /* Ref case */
4363 /* val is a vtype, so has to load the value manually */
4371 /* Nullable case */
4374 {
4376 MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
4380 /*
4381 * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
4382 * construct that method at JIT time, so have to do things by hand.
4383 */
4384 box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4391 else
4396 }
4408 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4410 }
4411 }
4413 static gboolean
4414 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4415 {
4428 }
4432 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4437 }
4439 }
4443 static gboolean
4445 {
4446 /* LLVM on amd64 can't handle calls to non-32 bit addresses */
4450 /*
4451 * An icall is directly callable if it doesn't directly or indirectly call mono_raise_exception ().
4452 * Whitelist a few icalls for now.
4453 */
4463 }
4467 /* No locking needed */
4468 if (cmethod->klass->image == mono_defaults.corlib && g_hash_table_lookup (direct_icall_type_hash, cmethod->klass->name))
4471 }
4473 #define is_complex_isinst(klass) ((klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
4477 {
4488 }
4490 static int
4492 {
4493 /* Each CASTCLASS_CACHE patch needs a unique index which identifies the call site */
4496 }
4500 {
4504 /* obj */
4507 /* klass */
4510 /* inline cache*/
4512 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4514 /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
4516 }
4518 /*
4519 * Returns NULL and set the cfg exception on error.
4520 */
4522 handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, guint8 *ip, int *inline_costs)
4523 {
4532 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
4536 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
4548 CHECK_CFG_EXCEPTION;
4556 }
4561 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4566 /* obj */
4569 /* klass - it's the second element of the cache entry*/
4570 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4572 /* cache */
4576 }
4579 }
4589 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4594 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4596 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4597 /* the remoting code is broken, access the class for now */
4598 if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4604 }
4607 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4609 }
4612 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4614 }
4615 }
4623 exception_exit:
4625 }
4627 /*
4628 * Returns NULL and set the cfg exception on error.
4629 */
4632 {
4643 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4649 /* obj */
4652 /* klass - it's the second element of the cache entry*/
4653 EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4655 /* cache */
4659 }
4662 }
4668 /* Do the assignment at the beginning, so the other assignment can be if converted */
4676 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4680 /* the is_null_bb target simply copies the input register to the output */
4690 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4693 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4694 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
4697 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
4698 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4702 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4712 /* Check that the object is a vector too */
4717 }
4719 /* the is_null_bb target simply copies the input register to the output */
4721 }
4724 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4725 /* the is_null_bb target simply copies the input register to the output */
4728 if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4730 /* the remoting code is broken, access the class for now */
4731 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4737 }
4740 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4742 }
4746 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4747 /* the is_null_bb target simply copies the input register to the output */
4749 }
4750 }
4751 }
4763 }
4767 {
4768 /* This opcode takes as input an object reference and a class, and returns:
4769 0) if the object is an instance of the class,
4770 1) if the object is not instance of the class,
4771 2) if the object is a proxy whose type cannot be determined */
4774 #ifndef DISABLE_REMOTING
4776 #else
4778 #endif
4782 #ifndef DISABLE_REMOTING
4784 #endif
4789 #ifndef DISABLE_REMOTING
4792 #endif
4798 #ifndef DISABLE_REMOTING
4800 #endif
4804 #ifndef DISABLE_REMOTING
4809 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4812 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4815 #else
4817 #endif
4819 #ifndef DISABLE_REMOTING
4824 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4826 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4827 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4830 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4840 #else
4842 #endif
4843 }
4850 #ifndef DISABLE_REMOTING
4855 #endif
4863 /* FIXME: */
4869 }
4873 {
4874 /* This opcode takes as input an object reference and a class, and returns:
4875 0) if the object is an instance of the class,
4876 1) if the object is a proxy whose type cannot be determined
4877 an InvalidCastException exception is thrown otherwhise*/
4880 #ifndef DISABLE_REMOTING
4882 #else
4884 #endif
4889 #ifndef DISABLE_REMOTING
4892 #endif
4902 #ifndef DISABLE_REMOTING
4913 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4919 #else
4923 #endif
4925 #ifndef DISABLE_REMOTING
4930 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4933 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4934 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4937 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4953 #else
4955 #endif
4956 }
4962 #ifndef DISABLE_REMOTING
4964 #endif
4966 /* FIXME: */
4972 }
4975 handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, MonoInst *enum_flag)
4976 {
4979 gboolean is_i4;
4984 #if SIZEOF_REGISTER == 8
4987 #endif
4993 }
4995 {
5013 }
5016 }
5017 }
5019 /*
5020 * Returns NULL and set the cfg exception on error.
5021 */
5023 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual_)
5024 {
5027 gpointer trampoline;
5036 if (!mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke), context_used ? NULL : method))
5038 }
5044 /* Inline the contents of mono_delegate_ctor */
5046 /* Set target field */
5047 /* Optimize away setting of NULL target */
5049 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
5052 EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
5054 }
5055 }
5057 /* Set method field */
5059 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
5061 /*
5062 * To avoid looking up the compiled code belonging to the target method
5063 * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
5064 * store it, and we fill it after the method has been compiled.
5065 */
5070 code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
5076 code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
5080 }
5084 }
5085 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
5086 }
5099 }
5102 }
5107 del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
5114 trampoline = mono_create_delegate_virtual_trampoline (cfg->domain, klass, context_used ? NULL : method);
5115 else
5116 trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
5118 }
5120 /* Set invoke_impl field */
5122 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
5125 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
5126 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
5129 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
5130 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
5131 }
5135 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
5137 /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
5140 }
5144 {
5147 /* Need to register the icall so it gets an icall wrapper */
5152 /* mono_array_new_va () needs a vararg calling convention */
5156 /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
5158 }
5160 /*
5161 * handle_constrained_gsharedvt_call:
5162 *
5163 * Handle constrained calls where the receiver is a gsharedvt type.
5164 * Return the instruction representing the call. Set the cfg exception on failure.
5165 */
5167 handle_constrained_gsharedvt_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, MonoClass *constrained_class,
5169 {
5173 /*
5174 * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
5175 * 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
5176 * pack the arguments into an array, and do the rest of the work in in an icall.
5177 */
5178 if (((cmethod->klass == mono_defaults.object_class) || (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
5179 (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)) &&
5180 (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]))))) {
5183 /*
5184 * This case handles calls to
5185 * - object:ToString()/Equals()/GetHashCode(),
5186 * - System.IComparable<T>:CompareTo()
5187 * - System.IEquatable<T>:Equals ()
5188 * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
5189 */
5193 args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
5194 else
5196 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_class), constrained_class, MONO_RGCTX_INFO_KLASS);
5198 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
5200 /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
5210 ins = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
5212 /* deref_arg = BOX_TYPE != MONO_GSHAREDVT_BOX_TYPE_VTYPE */
5221 }
5225 }
5234 /* Unbox */
5235 NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
5237 /* Load value */
5240 /* ins represents the call result */
5241 }
5244 }
5250 exception_exit:
5252 }
5254 static void
5256 {
5266 /* Add it to the start of the first bblock */
5270 }
5271 else
5276 /*
5277 * Add a dummy use to keep the got_var alive, since real uses might
5278 * only be generated by the back ends.
5279 * Add it to end_bblock, so the variable's lifetime covers the whole
5280 * method.
5281 * It would be better to make the usage of the got var explicit in all
5282 * cases when the backend needs it (i.e. calls, throw etc.), so this
5283 * wouldn't be needed.
5284 */
5287 }
5292 static gboolean
5294 {
5295 MonoMethodHeaderSummary header;
5297 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5300 #endif
5313 /*runtime, icall and pinvoke are checked by summary call*/
5320 /* also consider num_locals? */
5321 /* Do the size check early to avoid creating vtables */
5325 else
5328 }
5329 if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
5332 /*
5333 * if we can initialize the class of the method right away, we do,
5334 * otherwise we don't allow inlining if the class needs initialization,
5335 * since it would mean inserting a call to mono_runtime_class_init()
5336 * inside the inlined code
5337 */
5339 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
5345 MonoError error;
5349 }
5350 }
5353 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
5355 /* No vtable created yet */
5360 /* This makes so that inline cannot trigger */
5361 /* .cctors: too many apps depend on them */
5362 /* running with a specific order... */
5365 MonoError error;
5369 }
5370 }
5373 /* No vtable created yet */
5380 }
5382 /*
5383 * If we're compiling for shared code
5384 * the cctor will need to be run at aot method load time, for example,
5385 * or at the end of the compilation of the inlining method.
5386 */
5387 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
5389 }
5391 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5393 /* FIXME: */
5399 }
5400 #endif
5406 }
5408 static gboolean
5409 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
5410 {
5415 }
5420 }
5426 /* The initialization is already done before the method is called */
5430 }
5433 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
5434 {
5436 guint32 size;
5445 }
5451 #if SIZEOF_REGISTER == 8
5452 /* The array reg is 64 bits but the index reg is only 32 */
5454 /* Not needed */
5459 }
5460 #else
5466 }
5467 #endif
5472 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5476 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
5481 }
5482 #endif
5489 /* gsharedvt */
5497 }
5499 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5505 }
5508 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
5509 {
5523 guint32 size;
5531 #if SIZEOF_REGISTER == 8
5532 /* The array reg is 64 bits but the index reg is only 32 */
5534 /* Not needed */
5542 }
5543 #else
5544 // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
5546 #endif
5548 /* range checking */
5572 NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5579 }
5582 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
5583 {
5595 /* emit_ldelema_2 depends on OP_LMUL */
5596 if (!cfg->backend->emulate_mul_div && rank == 2 && (cfg->opt & MONO_OPT_INTRINS) && !mini_is_gsharedvt_variable_klass (eclass)) {
5598 }
5602 else
5608 }
5610 static MonoBreakPolicy
5612 {
5614 }
5618 /**
5619 * mono_set_break_policy:
5620 * policy_callback: the new callback function
5621 *
5622 * Allow embedders to decide wherther to actually obey breakpoint instructions
5623 * (both break IL instructions and Debugger.Break () method calls), for example
5624 * to not allow an app to be aborted by a perfectly valid IL opcode when executing
5625 * untrusted or semi-trusted code.
5626 *
5627 * @policy_callback will be called every time a break point instruction needs to
5628 * be inserted with the method argument being the method that calls Debugger.Break()
5629 * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
5630 * if it wants the breakpoint to not be effective in the given method.
5631 * #MONO_BREAK_POLICY_ALWAYS is the default.
5632 */
5633 void
5635 {
5638 else
5640 }
5642 static gboolean
5655 }
5656 }
5658 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5660 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5661 {
5665 /* the bounds check is already done by the callers */
5675 }
5677 }
5680 static gboolean
5682 {
5684 }
5688 {
5715 // FIXME-VT: OP_ICONST optimization
5722 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
5735 }
5737 }
5738 }
5741 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5742 {
5747 else
5756 }
5757 }
5759 static gboolean
5761 {
5766 return_klass = mono_class_from_mono_type (mini_get_underlying_type (&return_klass->byval_arg));
5771 //Don't allow mixing reference types with value types
5776 }
5782 }
5784 //That are blitable
5788 /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5789 if ((MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5790 (!MONO_TYPE_ISSTRUCT (¶m_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg))) {
5794 }
5796 if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5797 return_klass->byval_arg.type == MONO_TYPE_R4 || return_klass->byval_arg.type == MONO_TYPE_R8) {
5801 }
5806 //We can do it if sizes match
5811 }
5813 //No simple way to handle struct if sizes don't match
5818 }
5820 /*
5821 * Same reg size category.
5822 * A quick note on why we don't require widening here.
5823 * The intrinsic is "R Array.UnsafeMov<S,R> (S s)".
5824 *
5825 * Since the source value comes from a function argument, the JIT will already have
5826 * the value in a VREG and performed any widening needed before (say, when loading from a field).
5827 */
5832 }
5835 }
5839 {
5846 //Valuetypes that are semantically equivalent or numbers than can be widened to
5850 //Arrays of valuetypes that are semantically equivalent
5851 if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (cfg, param_klass->element_class, return_klass->element_class))
5855 }
5858 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5859 {
5860 #ifdef MONO_ARCH_SIMD_INTRINSICS
5867 }
5868 #endif
5871 }
5875 {
5882 }
5885 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5886 {
5890 /* The LLVM backend supports these intrinsics */
5900 }
5908 }
5930 }
5931 }
5940 }
5941 }
5944 }
5947 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5948 {
5956 }
5959 }
5962 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5963 {
5974 #if SIZEOF_REGISTER == 8
5978 /* The array reg is 64 bits but the index reg is only 32 */
5980 }
5981 #else
5983 #endif
5986 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5987 EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
5991 #else
5997 #endif
6000 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6002 /* Decompose later to allow more optimizations */
6016 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
6017 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
6021 } else if (!cfg->backend->emulate_mul_div && strcmp (cmethod->name, "InternalGetHashCode") == 0 && fsig->param_count == 1 && !mono_gc_is_moving ()) {
6037 if (strcmp (cmethod->name, "GetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6039 else if (strcmp (cmethod->name, "SetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6042 #ifndef MONO_BIG_ARRAYS
6043 /*
6044 * This is an inline version of GetLength/GetLowerBound(0) used frequently in
6045 * Array methods.
6046 */
6047 else if (((strcmp (cmethod->name, "GetLength") == 0 && fsig->param_count + fsig->hasthis == 2) ||
6062 /* Non-szarray case */
6066 else
6071 /* Szarray case */
6075 else
6083 }
6084 #endif
6099 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6122 /*
6123 * To make async stack traces work, icalls which can block should have a wrapper.
6124 * For Monitor.Enter, emit two calls: a fastpath which doesn't have a wrapper, and a slowpath, which does.
6125 */
6136 }
6166 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6193 #if SIZEOF_REGISTER == 8
6195 #else
6197 #endif
6209 }
6217 }
6234 else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6250 }
6251 }
6257 #if SIZEOF_REGISTER == 8
6258 if (!cfg->llvm_only && strcmp (cmethod->name, "Read") == 0 && fsig->param_count == 1 && (fsig->params [0]->type == MONO_TYPE_I8)) {
6271 /* 64 bit reads are already atomic */
6282 }
6283 }
6284 #endif
6293 }
6294 #if SIZEOF_REGISTER == 8
6297 #endif
6313 }
6321 }
6322 #if SIZEOF_REGISTER == 8
6325 #endif
6341 }
6348 }
6349 #if SIZEOF_REGISTER == 8
6352 #endif
6363 }
6364 }
6369 gboolean is_float = fsig->params [0]->type == MONO_TYPE_R4 || fsig->params [0]->type == MONO_TYPE_R8;
6377 }
6378 #if SIZEOF_REGISTER == 8
6386 }
6387 #else
6391 }
6392 #endif
6393 else
6400 /* TODO: Decompose these opcodes instead of bailing here. */
6410 }
6427 #if SIZEOF_REGISTER == 8
6429 #else
6431 #endif
6441 }
6453 }
6457 }
6462 gboolean is_float = fsig->params [1]->type == MONO_TYPE_R4 || fsig->params [1]->type == MONO_TYPE_R8;
6470 }
6471 #if SIZEOF_REGISTER == 8
6479 }
6480 #else
6484 }
6485 #endif
6486 else
6493 /* TODO: Decompose these opcodes instead of bailing here. */
6510 }
6527 #if SIZEOF_REGISTER == 8
6529 #else
6531 #endif
6543 }
6555 }
6559 }
6567 /* int32 r = CAS (location, value, comparand); */
6576 /* bool result = r == comparand; */
6588 /* *success = result; */
6592 }
6606 gboolean is_ref;
6610 /* t is a byref type, so the reference check is more complicated */
6628 #if SIZEOF_REGISTER == 8
6633 #else
6638 #endif
6645 ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : (is_float ? mono_alloc_freg (cfg) : mono_alloc_ireg (cfg));
6666 #if SIZEOF_REGISTER == 8
6668 #else
6670 #endif
6682 }
6683 }
6684 }
6689 gboolean is_ref;
6709 #if SIZEOF_REGISTER == 8
6714 #else
6719 #endif
6733 }
6734 }
6747 }
6749 }
6754 #ifdef TARGET_WIN32
6756 #else
6758 #endif
6759 }
6764 /* No stack walks are currently available, so implement this as an intrinsic */
6770 }
6775 /* No stack walks are currently available, so implement this as an intrinsic */
6779 /* This returns the declaring generic method */
6788 }
6790 /*
6791 * There is general branchless code for Min/Max, but it does not work for
6792 * all inputs:
6793 * http://everything2.com/?node_id=1051618
6794 */
6802 ) {
6811 // FIXME: llvmonly
6824 }
6828 // FIXME: Ugly
6829 s = mono_ldstr_checked (cfg->domain, ji->image, mono_metadata_token_index (ji->token), &cfg->error);
6833 // FIXME: Leaks
6837 }
6838 }
6840 #ifdef MONO_ARCH_SIMD_INTRINSICS
6845 }
6846 #endif
6856 }
6859 }
6861 /*
6862 * This entry point could be used later for arbitrary method
6863 * redirection.
6864 */
6868 {
6870 /* managed string allocation support */
6871 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
6877 #ifndef MONO_CROSS_COMPILE
6879 #endif
6885 }
6886 }
6888 }
6890 static void
6892 {
6897 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
6899 /*
6900 * FIXME: We should use *args++ = sp [0], but that would mean the arg
6901 * would be different than the MonoInst's used to represent arguments, and
6902 * the ldelema implementation can't deal with that.
6903 * Solution: When ldelema is used on an inline argument, create a var for
6904 * it, emit ldelema on that var, and emit the saving code below in
6905 * inline_method () if needed.
6906 */
6909 /* This uses cfg->args [i] which is set by the preceeding line */
6912 sp++;
6913 }
6914 }
6916 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
6917 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
6919 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
6920 static gboolean
6922 {
6931 else
6933 }
6941 //return (strncmp_result <= 0);
6945 }
6946 }
6947 #endif
6949 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
6950 static gboolean
6952 {
6962 }
6963 }
6971 //return (strncmp_result <= 0);
6975 }
6976 }
6977 #endif
6979 static void
6981 {
7015 }
7016 }
7018 static void
7020 {
7043 }
7044 }
7046 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
7047 static void
7049 {
7059 else
7061 }
7062 }
7064 /*
7065 * inline_method:
7066 *
7067 * Return the cost of inlining CMETHOD.
7068 */
7069 static int
7070 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
7072 {
7073 MonoError error;
7081 guint prev_real_offset;
7086 guint32 prev_cil_offset_to_bb_len;
7093 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
7096 #endif
7097 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
7100 #endif
7106 printf ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7111 }
7113 /* allocate local variables */
7121 }
7123 }
7125 /*Must verify before creating locals as it can cause the JIT to assert.*/
7129 }
7131 /* allocate space to store the return value */
7134 }
7137 cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
7141 /* allocate start and end blocks */
7142 /* This is needed so if the inline is aborted, we can clean up */
7189 if ((costs >= 0 && costs < 60) || inline_always || (costs >= 0 && (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))) {
7191 printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7195 /* always add some code to avoid block split failures */
7202 /*
7203 * Get rid of the begin and end bblocks if possible to aid local
7204 * optimizations.
7205 */
7208 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
7217 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
7220 }
7222 /* There could be a bblock after 'prev', and making 'prev' the current bb could cause problems */
7224 }
7226 /*
7227 * Its possible that the rvar is set in some prev bblock, but not in others.
7228 * (#1835).
7229 */
7240 }
7241 }
7242 }
7245 }
7248 /*
7249 * If the inlined method contains only a throw, then the ret var is not
7250 * set, so set it to a dummy value.
7251 */
7257 }
7265 /* This gets rid of the newly added bblocks */
7267 }
7270 }
7272 /*
7273 * Some of these comments may well be out-of-date.
7274 * Design decisions: we do a single pass over the IL code (and we do bblock
7275 * splitting/merging in the few cases when it's required: a back jump to an IL
7276 * address that was not already seen as bblock starting point).
7277 * Code is validated as we go (full verification is still better left to metadata/verify.c).
7278 * Complex operations are decomposed in simpler ones right away. We need to let the
7279 * arch-specific code peek and poke inside this process somehow (except when the
7280 * optimizations can take advantage of the full semantic info of coarse opcodes).
7281 * All the opcodes of the form opcode.s are 'normalized' to opcode.
7282 * MonoInst->opcode initially is the IL opcode or some simplification of that
7283 * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
7284 * opcode with value bigger than OP_LAST.
7285 * At this point the IR can be handed over to an interpreter, a dumb code generator
7286 * or to the optimizing code generator that will translate it to SSA form.
7287 *
7288 * Profiling directed optimizations.
7289 * We may compile by default with few or no optimizations and instrument the code
7290 * or the user may indicate what methods to optimize the most either in a config file
7291 * or through repeated runs where the compiler applies offline the optimizations to
7292 * each method and then decides if it was worth it.
7293 */
7295 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
7296 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
7297 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
7298 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
7299 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
7300 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
7301 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
7302 #define CHECK_TYPELOAD(klass) if (!(klass) || mono_class_has_failure (klass)) TYPE_LOAD_ERROR ((klass))
7304 /* offset from br.s -> br like opcodes */
7305 #define BIG_BRANCH_OFFSET 13
7307 static gboolean
7309 {
7313 }
7315 static int
7316 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
7317 {
7321 guint cli_addr;
7329 UNVERIFIED;
7333 ip++;
7368 guint32 j;
7378 }
7380 }
7387 }
7392 /* Find the start of the bblock containing the throw */
7396 bb_start --;
7397 }
7400 }
7401 }
7403 unverified:
7404 exception_exit:
7407 }
7410 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error)
7411 {
7420 }
7423 }
7426 }
7429 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
7430 {
7431 MonoError error;
7432 MonoMethod *method = mini_get_method_allow_open (m, token, klass, context, cfg ? &cfg->error : &error);
7434 if (method && cfg && !cfg->gshared && mono_class_is_open_constructed_type (&method->klass->byval_arg)) {
7435 mono_error_set_bad_image (&cfg->error, cfg->method->klass->image, "Method with open type while not compiling gshared");
7437 }
7443 }
7447 {
7448 MonoError error;
7456 }
7458 klass = mono_class_get_and_inflate_typespec_checked (method->klass->image, token, context, &error);
7460 }
7464 }
7467 mini_get_signature (MonoMethod *method, guint32 token, MonoGenericContext *context, MonoError *error)
7468 {
7477 }
7480 }
7482 }
7486 {
7492 }
7495 }
7497 static void
7499 {
7505 }
7507 /*
7508 * Return the original method is a wrapper is specified. We can only access
7509 * the custom attributes from the original method.
7510 */
7513 {
7517 /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
7521 /* in other cases we need to find the original method */
7523 }
7525 static void
7526 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field)
7527 {
7528 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7529 MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
7532 }
7534 static void
7535 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
7536 {
7537 /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7538 MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
7541 }
7543 /*
7544 * Check that the IL instructions at ip are the array initialization
7545 * sequence and return the pointer to the data and the size.
7546 */
7548 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
7549 {
7550 /*
7551 * newarr[System.Int32]
7552 * dup
7553 * ldtoken field valuetype ...
7554 * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
7555 */
7557 MonoError error;
7561 guint32 rva;
7566 MonoClassField *field = mono_field_from_token_checked (method->klass->image, field_token, &dummy_class, NULL, &error);
7572 }
7579 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
7586 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
7587 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
7600 #endif
7603 }
7608 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
7613 /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
7614 /* for aot code we do the lookup on load */
7618 /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
7621 }
7623 }
7625 }
7627 static void
7629 {
7630 MonoError error;
7636 method_code = g_strdup_printf ("could not parse method body due to %s", mono_error_get_message (&error));
7640 else
7642 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code));
7646 }
7648 static void
7650 {
7655 /* Optimize reg-reg moves away */
7656 /*
7657 * Can't optimize other opcodes, since sp[0] might point to
7658 * the last ins of a decomposed opcode.
7659 */
7663 }
7664 }
7666 /*
7667 * ldloca inhibits many optimizations so try to get rid of it in common
7668 * cases.
7669 */
7672 {
7683 }
7685 if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
7686 /* From the INITOBJ case */
7693 }
7694 exception_exit:
7696 }
7699 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp)
7700 {
7707 guint32 slot;
7710 /*
7711 * In llvm-only mode, vtables contain function descriptors instead of
7712 * method addresses/trampolines.
7713 */
7718 else
7727 /*
7728 * The simplest case, a normal virtual call.
7729 */
7736 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7739 /* Load the vtable slot, which contains a function descriptor. */
7748 /* Slow path */
7749 // FIXME: Make the wrapper use the preserveall cconv
7750 // FIXME: Use one icall per slot for small slot numbers ?
7753 /* Make the icall return the vtable slot value to save some code space */
7758 /* Fastpath */
7760 /* Load the address + arg from the vtable slot */
7765 }
7768 /*
7769 * A simple interface call
7770 *
7771 * We make a call through an imt slot to obtain the function descriptor we need to call.
7772 * The imt slot contains a function descriptor for a runtime function + arg.
7773 */
7780 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7783 /*
7784 * The slot is already initialized when the vtable is created so there is no need
7785 * to check it here.
7786 */
7788 /* Load the imt slot, which contains a function descriptor. */
7791 /* Load the address + arg of the imt thunk from the imt slot */
7794 /*
7795 * IMT thunks in llvm-only mode are C functions which take an info argument
7796 * plus the imt method and return the ftndesc to call.
7797 */
7801 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_thunk, icall_args, thunk_addr_ins, NULL, NULL);
7804 }
7807 /*
7808 * This is similar to the interface case, the vtable slot points to an imt thunk which is
7809 * dynamically extended as more instantiations are discovered.
7810 * This handles generic virtual methods both on classes and interfaces.
7811 */
7823 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7826 else
7829 /* Load the slot, which contains a function descriptor. */
7832 /* These slots are not initialized, so fall back to the slow path until they are initialized */
7833 /* That happens when mono_method_add_generic_virtual_invocation () creates an IMT thunk */
7837 /* Fastpath */
7838 /* Same as with iface calls */
7844 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_thunk, icall_args, thunk_addr_ins, NULL, NULL);
7846 /*
7847 * Unlike normal iface calls, these imt thunks can return NULL, i.e. when they are passed an instantiation
7848 * they don't know about yet. Fall back to the slowpath in that case.
7849 */
7855 /* Slowpath */
7863 else
7868 /* Common case */
7871 }
7873 /*
7874 * Non-optimized cases
7875 */
7889 else
7892 /*
7893 * Pass the extra argument even if the callee doesn't receive it, most
7894 * calling conventions allow this.
7895 */
7897 }
7899 static gboolean
7901 {
7906 }
7908 }
7910 /*
7911 * is_jit_optimizer_disabled:
7912 *
7913 * Determine whenever M's assembly has a DebuggableAttribute with the
7914 * IsJITOptimizerDisabled flag set.
7915 */
7916 static gboolean
7918 {
7919 MonoError error;
7933 /* Linked away */
7938 }
7950 /* Decode the attribute. See reflection.c */
7955 // FIXME: Support named parameters
7957 if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
7959 /* Two boolean arguments */
7960 p ++;
7962 }
7964 }
7971 }
7973 static gboolean
7974 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
7975 {
7976 gboolean supported_tail_call;
7979 supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
7982 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
7983 /* These can point to the current method's stack */
7985 }
7987 /* this might point to the current method's stack */
7998 /* Debugging support */
7999 #if 0
8003 }
8004 #endif
8007 }
8009 /*
8010 * handle_ctor_call:
8011 *
8012 * Handle calls made to ctors from NEWOBJ opcodes.
8013 */
8014 static void
8015 handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used,
8017 {
8037 }
8038 }
8039 }
8041 /* Avoid virtual calls to ctors if possible */
8045 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8047 CHECK_CFG_EXCEPTION;
8059 // FIXME-VT: Clean this up
8063 }
8067 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
8070 // FIXME: Avoid initializing vtable_arg
8074 }
8080 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
8084 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8091 }
8096 }
8097 exception_exit:
8099 }
8101 static void
8103 {
8117 }
8119 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8129 }
8130 #else
8132 #endif
8133 }
8134 }
8136 /*
8137 * mono_method_to_ir:
8138 *
8139 * Translate the .net IL into linear IR.
8140 */
8141 int
8142 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
8145 {
8146 MonoError error;
8165 guint num_args;
8177 /* serialization and xdomain stuff may need access to private fields and methods */
8185 /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
8196 }
8208 /* We could hit a seq point before attaching to the JIT (#8338) */
8210 }
8219 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8220 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);
8225 }
8227 } else if (!method->wrapper_type && !method->dynamic && mono_debug_image_has_debug_info (method->klass->image)) {
8228 /* Methods without line number info like auto-generated property accessors */
8229 seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8230 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);
8232 }
8233 }
8235 /*
8236 * Methods without init_locals set could cause asserts in various passes
8237 * (#497220). To work around this, we emit dummy initialization opcodes
8238 * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
8239 * on some platforms.
8240 */
8243 else
8250 }
8252 /* SkipVerification is not allowed if core-clr is enabled */
8256 }
8270 }
8278 }
8280 cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
8301 /* ENTRY BLOCK */
8307 /* EXIT BLOCK */
8320 }
8321 /* handle exception clauses */
8334 /*
8335 * Linking the try block with the EH block hinders inlining as we won't be able to
8336 * merge the bblocks from inlining and produce an artificial hole for no good reason.
8337 */
8350 if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FILTER) {
8351 /* finally clauses already have a seq point */
8352 /* seq points for filter clauses are emitted below */
8355 }
8357 /* todo: is a fault block unsafe to optimize? */
8360 }
8362 /*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);
8363 while (p < end) {
8364 printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
8365 }*/
8366 /* catch and filter blocks get the exception object on the stack */
8370 /* mostly like handle_stack_args (), but just sets the input args */
8371 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
8378 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
8379 /* The EH code passes in the exception in a register to both JITted and LLVM compiled code */
8384 }
8385 #else
8388 /*
8389 * Add a dummy use for the exvar so its liveness info will be
8390 * correct.
8391 */
8393 #endif
8398 }
8406 /* The filter block shares the exvar with the handler block */
8410 }
8411 }
8417 /*
8418 * In shared generic code with catch
8419 * clauses containing type variables
8420 * the exception handling code has to
8421 * be able to get to the rgctx.
8422 * Therefore we have to make sure that
8423 * the vtable/mrgctx argument (for
8424 * static or generic methods) or the
8425 * "this" argument (for non-static
8426 * methods) are live.
8427 */
8436 }
8437 }
8438 }
8444 }
8446 /* FIRST CODE BLOCK */
8459 }
8460 }
8462 /* we use a separate basic block for the initialization code */
8478 info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
8481 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
8485 /* prevent it from being register allocated */
8486 //var->flags |= MONO_INST_VOLATILE;
8489 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
8492 /* Allocate locals */
8494 /* prevent it from being register allocated */
8495 //locals_var->flags |= MONO_INST_VOLATILE;
8499 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
8508 /*
8509 if (init_locals)
8510 ins->flags |= MONO_INST_INIT;
8511 */
8512 }
8515 /* check if this is native code, e.g. an icall or a p/invoke */
8522 /* if this ia a native call then it can only be JITted from platform code */
8528 }
8529 }
8530 }
8531 }
8532 }
8534 CHECK_CFG_EXCEPTION;
8537 UNVERIFIED;
8541 UNVERIFIED;
8542 }
8549 UNVERIFIED;
8550 }
8553 /* We force the vtable variable here for all shared methods
8554 for the possibility that they might show up in a stack
8555 trace where their exact instantiation is needed. */
8562 /* FIXME: Is there a better way to do this?
8563 We need the variable live for the duration
8564 of the whole method. */
8566 }
8567 }
8569 /* add a check for this != NULL to inlined methods */
8576 }
8581 CHECK_CFG_ERROR;
8583 }
8585 /* we use a spare stack slot in SWITCH and NEWOBJ and others */
8586 stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
8593 else
8605 }
8614 }
8625 }
8633 }
8636 }
8637 }
8655 }
8659 }
8660 }
8661 /*
8662 * Sequence points are points where the debugger can place a breakpoint.
8663 * Currently, we generate these automatically at points where the IL
8664 * stack is empty.
8665 */
8666 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
8667 /*
8668 * Make methods interruptable at the beginning, and at the targets of
8669 * backward branches.
8670 * Also, do this at the start of every bblock in methods with clauses too,
8671 * to be able to handle instructions with inprecise control flow like
8672 * throw/endfinally.
8673 * Backward branches are handled at the end of method-to-ir ().
8674 */
8676 gboolean sym_seq_point = sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code);
8678 /* Avoid sequence points on empty IL like .volatile */
8679 // FIXME: Enable this
8680 //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
8688 }
8696 /* TODO: Use an increment here */
8697 #if defined(TARGET_X86)
8702 #else
8705 #endif
8706 }
8709 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8714 /*
8715 * The C# compiler uses these nops to notify the JIT that it should
8716 * insert seq points.
8717 */
8720 }
8723 else
8725 ip++;
8733 }
8734 ip++;
8745 ip++;
8756 ip++;
8768 UNVERIFIED;
8773 }
8800 UNVERIFIED;
8823 }
8829 }
8836 UNVERIFIED;
8899 #ifdef TARGET_POWERPC
8900 /* FIXME: Clean this up */
8903 #endif
8905 /* FIXME: we should really allocate this only late in the compilation process */
8925 }
8931 }
8936 #ifdef TARGET_POWERPC
8937 /* FIXME: Clean this up */
8940 #endif
8942 /* FIXME: we should really allocate this only late in the compilation process */
8962 }
8968 }
8973 sp--;
8988 }
8991 ip++;
8994 #ifdef TARGET_X86
8996 /* we need to pop the value from the x86 FP stack */
8998 #endif
9010 UNVERIFIED;
9012 /* FIXME: check the signature matches */
9014 CHECK_CFG_ERROR;
9030 /*
9031 * The code in mono-basic-block.c treats the rest of the code as dead, but we
9032 * have to emit a normal return since llvm expects it.
9033 */
9043 /* Handle tail calls similarly to calls */
9060 /* Prevent arguments from being optimized away */
9067 }
9072 }
9082 //GSHAREDVT_FAILURE (*ip);
9088 CHECK_CFG_ERROR;
9093 /*
9094 * This is a call through a function pointer using a pinvoke
9095 * signature. Have to create a wrapper and call that instead.
9096 * FIXME: This is very slow, need to create a wrapper at JIT time
9097 * instead based on the signature.
9098 */
9103 }
9109 //g_assert (!virtual_ || fsig->hasthis);
9115 /*
9116 * Making generic calls out of gsharedvt methods.
9117 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9118 * patching gshared method addresses into a gsharedvt method.
9119 */
9121 /*
9122 * We pass the address to the gsharedvt trampoline in the rgctx reg
9123 */
9127 /* Not tested */
9131 // FIXME:
9138 }
9140 /* Prevent inlining of methods with indirect calls */
9143 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
9144 MonoJumpInfoType info_type;
9145 gpointer info_data;
9147 /*
9148 * Instead of emitting an indirect call, emit a direct call
9149 * with the contents of the aotconst as the patch info.
9150 */
9157 }
9160 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR_CALL, info_data, fsig, sp);
9167 }
9168 }
9171 calli_end:
9173 /* End of call, INS should contain the result of the call, if any */
9178 }
9180 CHECK_CFG_EXCEPTION;
9186 }
9218 CHECK_CFG_ERROR;
9223 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9228 }
9229 }
9237 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_class, generic_context, &cfg->error);
9238 CHECK_CFG_ERROR;
9239 }
9244 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9245 /*
9246 * This is needed since get_method_constrained can't find
9247 * the method in klass representing a type var.
9248 * The type var is guaranteed to be a reference type in this
9249 * case.
9250 */
9254 cmethod = mono_get_method_constrained_checked (image, token, constrained_class, generic_context, &cil_method, &cfg->error);
9255 CHECK_CFG_ERROR;
9256 }
9257 }
9258 }
9263 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), &cfg->error);
9264 CHECK_CFG_ERROR;
9265 }
9269 }
9275 /* MS.NET seems to silently convert this to a callvirt */
9278 {
9279 /*
9280 * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
9281 * converts to a callvirt.
9282 *
9283 * tests/bug-515884.il is an example of this behavior
9284 */
9285 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
9287 if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
9289 }
9297 LOAD_ERROR;
9301 } else if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && icall_is_direct_callable (cfg, cmethod)) {
9308 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
9309 CHECK_CFG_ERROR;
9310 }
9315 /* See code below */
9316 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9321 /*
9322 * We want to extend the try block to cover the call, but we can't do it if the
9323 * call is made directly since its followed by an exception check.
9324 */
9326 }
9327 }
9334 /* Don't support calls made using type arguments for now */
9335 /*
9336 if (cfg->gsharedvt) {
9337 if (mini_is_gsharedvt_signature (fsig))
9338 GSHAREDVT_FAILURE (*ip);
9339 }
9340 */
9348 UNVERIFIED;
9355 //g_assert (!virtual_ || fsig->hasthis);
9359 /*
9360 * We have the `constrained.' prefix opcode.
9361 */
9364 if ((cmethod->klass != mono_defaults.object_class) && constrained_class->valuetype && cmethod->klass->valuetype) {
9365 /* The 'Own method' case below */
9366 } else if (cmethod->klass->image != mono_defaults.corlib && !(cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) && !cmethod->klass->valuetype) {
9367 /* 'The type parameter is instantiated as a reference type' case below. */
9369 ins = handle_constrained_gsharedvt_call (cfg, cmethod, fsig, sp, constrained_class, &emit_widen);
9370 CHECK_CFG_EXCEPTION;
9373 }
9374 }
9379 /*
9380 * The receiver is a valuetype, but the exact type is not known at compile time. This means the
9381 * called method is not known at compile time either. The called method could end up being
9382 * one of the methods on the parent classes (object/valuetype/enum), in which case we need
9383 * to box the receiver.
9384 * A simple solution would be to box always and make a normal virtual call, but that would
9385 * be bad performance wise.
9386 */
9388 /*
9389 * The parent classes implement no generic interfaces, so the called method will be a vtype method, so no boxing neccessary.
9390 */
9392 }
9394 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)) {
9395 /* The called method is not virtual, i.e. Object:GetType (), the receiver is a vtype, has to box */
9398 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9399 CHECK_CFG_EXCEPTION;
9405 /*
9406 * Determine at runtime whenever the called method is defined on object/valuetype/enum, and emit a boxing call
9407 * if needed.
9408 * FIXME: It is possible to inline the called method in a lot of cases, i.e. for T_INT,
9409 * the no-box case goes to a method in Int32, while the box case goes to a method in Enum.
9410 */
9411 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9416 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);
9417 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, box_type->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
9420 /* Non-ref case */
9425 /* Ref case */
9429 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9441 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9444 }
9445 } else if (constrained_class->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9446 /*
9447 * The type parameter is instantiated as a valuetype,
9448 * but that type doesn't override the method we're
9449 * calling, so we need to box `this'.
9450 */
9453 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9454 CHECK_CFG_EXCEPTION;
9458 /*
9459 * The type parameter is instantiated as a reference
9460 * type. We have a managed pointer on the stack, so
9461 * we need to dereference it here.
9462 */
9468 /* Own method */
9470 /* Interface method */
9484 /* Enum implements some interfaces, so treat this as the first case */
9487 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9488 CHECK_CFG_EXCEPTION;
9489 }
9490 }
9492 }
9494 }
9497 UNVERIFIED;
9499 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
9502 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
9506 }
9509 }
9511 /*
9512 * If the callee is a shared method, then its static cctor
9513 * might not get called after the call was patched.
9514 */
9515 if (cfg->gshared && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
9518 }
9528 /* Generic method interface
9529 calls are resolved via a
9530 helper function and don't
9531 need an imt. */
9534 }
9536 /*
9537 * If a shared method calls another
9538 * shared method then the caller must
9539 * have a generic sharing context
9540 * because the magic trampoline
9541 * requires it. FIXME: We shouldn't
9542 * have to force the vtable/mrgctx
9543 * variable here. Instead there
9544 * should be a flag in the cfg to
9545 * request a generic sharing context.
9546 */
9550 }
9560 }
9561 }
9567 /*
9568 * emit_get_rgctx_method () calls mono_class_vtable () so check
9569 * for type load errors before.
9570 */
9573 }
9577 /* !marshalbyref is needed to properly handle generic methods + remoting */
9584 }
9585 }
9592 }
9597 /* Calling virtual generic methods */
9609 /* Prevent inlining of methods that contain indirect calls */
9615 if (cfg->backend->have_generalized_imt_thunk && cfg->backend->gshared_supported && cmethod->wrapper_type == MONO_WRAPPER_NONE) {
9627 /* FIXME: This should be a managed pointer */
9640 }
9643 }
9645 /*
9646 * Implement a workaround for the inherent races involved in locking:
9647 * Monitor.Enter ()
9648 * try {
9649 * } finally {
9650 * Monitor.Exit ()
9651 * }
9652 * If a thread abort happens between the call to Monitor.Enter () and the start of the
9653 * try block, the Exit () won't be executed, see:
9654 * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
9655 * To work around this, we extend such try blocks to include the last x bytes
9656 * of the Monitor.Enter () call.
9657 */
9658 if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9662 /*
9663 * Only extend try blocks with a finally, to avoid catching exceptions thrown
9664 * from Monitor.Enter like ArgumentNullException.
9665 */
9667 /* Mark this bblock as needing to be extended */
9669 }
9670 }
9672 /* Conversion to a JIT intrinsic */
9673 if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
9677 }
9679 }
9680 CHECK_CFG_ERROR;
9682 /* Inlining */
9684 (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
9691 /* Prevent inlining of methods that call wrappers */
9695 }
9702 /* *sp is already set by inline_method */
9703 sp++;
9705 }
9710 }
9711 }
9713 /* Tail recursion elimination */
9714 if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
9718 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9721 /* keep it simple */
9725 }
9737 /* skip the CEE_RET, too */
9742 }
9743 }
9747 /*
9748 * Making generic calls out of gsharedvt methods.
9749 * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9750 * patching gshared method addresses into a gsharedvt method.
9751 */
9752 if (cfg->gsharedvt && (mini_is_gsharedvt_signature (fsig) || cmethod->is_inflated || cmethod->klass->generic_class) &&
9755 MonoRgctxInfoType info_type;
9758 //if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
9759 //GSHAREDVT_FAILURE (*ip);
9760 // disable for possible remoting calls
9761 if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
9764 /* virtual generic call */
9766 /* Same as the virtual generic case above */
9769 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
9772 /* This can happen when we call a fully instantiated iface method */
9776 }
9777 }
9779 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
9784 else
9789 // FIXME: Avoid initializing vtable_arg
9793 }
9795 }
9797 /* Generic sharing */
9799 /*
9800 * Use this if the callee is gsharedvt sharable too, since
9801 * at runtime we might find an instantiation so the call cannot
9802 * be patched (the 'no_patch' code path in mini-trampolines.c).
9803 */
9814 /*
9815 * We are compiling a call to a
9816 * generic method from shared code,
9817 * which means that we have to look up
9818 * the method in the rgctx and do an
9819 * indirect call.
9820 */
9826 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GSHAREDVT_OUT_WRAPPER);
9827 else
9828 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9829 // FIXME: Avoid initializing imt_arg/vtable_arg
9832 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9834 }
9836 }
9838 /* Direct calls to icalls */
9843 /* Inline the wrapper */
9851 /* *sp is already set by inline_method */
9852 sp++;
9854 }
9859 }
9861 /* Array methods */
9875 }
9878 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
9879 if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
9897 }
9901 }
9907 /* Tail prefix / tail call optimization */
9909 /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
9910 /* FIXME: runtime generic context pointer for jumps? */
9911 /* FIXME: handle this for generic sharing eventually */
9913 !vtable_arg && !cfg->gshared && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
9919 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9922 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
9925 /* Handle tail calls similarly to normal calls */
9935 /*
9936 * We implement tail calls by storing the actual arguments into the
9937 * argument variables, then emitting a CEE_JMP.
9938 */
9940 /* Prevent argument from being register allocated */
9943 }
9951 // FIXME: Eliminate unreachable epilogs
9953 /*
9954 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
9955 * only reachable from this call.
9956 */
9963 }
9964 }
9966 /*
9967 * Synchronized wrappers.
9968 * Its hard to determine where to replace a method with its synchronized
9969 * wrapper without causing an infinite recursion. The current solution is
9970 * to add the synchronized wrapper in the trampolines, and to
9971 * change the called method to a dummy wrapper, and resolve that wrapper
9972 * to the real method in mono_jit_compile_method ().
9973 */
9976 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
9978 }
9980 /*
9981 * Virtual calls in llvm-only mode.
9982 */
9986 }
9988 /* Common call */
9997 // FIXME: Eliminate unreachable epilogs
9999 /*
10000 * OP_TAILCALL has no return value, so skip the CEE_RET if it is
10001 * only reachable from this call.
10002 */
10007 }
10009 call_end:
10011 /* End of call, INS should contain the result of the call, if any */
10017 else
10019 }
10024 /* See mono_emit_method_call_full () */
10026 }
10028 CHECK_CFG_EXCEPTION;
10034 }
10040 }
10043 /* return from inlined method */
10044 /*
10045 * If in_count == 0, that means the ret is unreachable due to
10046 * being preceeded by a throw. In that case, inline_method () will
10047 * handle setting the return value
10048 * (test case: test_0_inline_throw ()).
10049 */
10057 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10058 UNVERIFIED;
10060 //g_assert (returnvar != -1);
10063 }
10074 /*
10075 * Place a seq point here too even through the IL stack is not
10076 * empty, so a step over on
10077 * call <FOO>
10078 * ret
10079 * will work correctly.
10080 */
10083 }
10089 if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10090 UNVERIFIED;
10093 }
10094 }
10096 UNVERIFIED;
10098 ip++;
10107 ip++;
10117 }
10135 ip++;
10137 ip++;
10147 ip++;
10158 }
10177 UNVERIFIED;
10178 ip ++;
10182 sp--;
10192 }
10199 #if SIZEOF_REGISTER == 4
10201 /* Convert it to OP_LCOMPARE */
10209 }
10210 #endif
10226 }
10240 ip++;
10258 gboolean use_op_switch;
10266 UNVERIFIED;
10281 }
10284 /*
10285 * Link the current bb with the targets as well, so handle_stack_args
10286 * will set their in_stack correctly.
10287 */
10296 /* Undo the links */
10300 }
10308 table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
10313 #ifdef TARGET_ARM
10314 /* ARM implements SWITCH statements differently */
10315 /* FIXME: Make it use the generic implementation */
10318 #endif
10335 else
10338 #if SIZEOF_REGISTER == 8
10339 /* The upper word might not be zero, and we add it to a 64 bit address later */
10341 #endif
10351 }
10353 /* FIXME: Use load_memindex */
10357 }
10361 }
10389 }
10399 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10401 }
10417 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10419 }
10427 if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0)))
10445 /* Use the immediate opcodes if possible */
10454 }
10455 }
10460 ip++;
10485 /* FIXME: Pass opcode to is_inst_imm */
10487 /* Use the immediate opcodes if possible */
10488 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)) {
10493 #if SIZEOF_REGISTER == 8
10495 #else
10498 #endif
10499 }
10500 else
10504 /* Might be followed by an instruction added by add_widen_op */
10507 }
10508 }
10512 ip++;
10529 /* Special case this earlier so we have long constants in the IR */
10534 #if SIZEOF_REGISTER == 8
10537 else
10539 #else
10543 else
10545 #endif
10547 }
10550 }
10551 ip++;
10565 }
10566 ip++;
10578 }
10579 ip++;
10597 CHECK_CFG_EXCEPTION;
10598 ip++;
10608 ip++;
10634 }
10649 /* Optimize the common ldobj+stloc combination */
10664 }
10675 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10677 }
10680 }
10682 /* Optimize the ldobj+stobj combination */
10683 /* The reference case ends up being a load+store anyway */
10684 /* Skip this if the operation is volatile. */
10685 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)) {
10688 sp --;
10695 }
10702 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10704 }
10710 }
10720 }
10727 else
10736 }
10742 CHECK_CFG_ERROR;
10748 /*
10749 * Avoid relocations in AOT and save some space by using a
10750 * version of helper_ldstr specialized to mscorlib.
10751 */
10755 /* Avoid creating the string object */
10759 }
10760 }
10761 else
10766 }
10770 ins->inst_p0 = mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), &cfg->error);
10771 CHECK_CFG_ERROR;
10774 OUT_OF_MEMORY_FAILURE;
10778 }
10779 }
10780 }
10782 sp++;
10788 MonoInst this_ins;
10795 CHECK_CFG_ERROR;
10797 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
10798 CHECK_CFG_ERROR;
10810 if (cfg->gshared && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
10813 }
10815 /*
10816 if (cfg->gsharedvt) {
10817 if (mini_is_gsharedvt_variable_signature (sig))
10818 GSHAREDVT_FAILURE (*ip);
10819 }
10820 */
10825 /*
10826 * Generate smaller code for the common newobj <exception> instruction in
10827 * argument checking code.
10828 */
10853 }
10858 }
10860 /* move the args to allow room for 'this' in the first position */
10864 }
10866 /* check_call_signature () requires sp[0] to be set */
10870 UNVERIFIED;
10878 /* Avoid varargs in the common case */
10887 else
10892 /* we simply pass a null pointer */
10894 /* now call the string ctor */
10904 /*
10905 * The code generated by mini_emit_virtual_call () expects
10906 * iargs [0] to be a boxed instance, but luckily the vcall
10907 * will be transformed into a normal call there.
10908 */
10919 /*
10920 * TypeInitializationExceptions thrown from the mono_runtime_class_init
10921 * call in mono_jit_runtime_invoke () can abort the finalizer thread.
10922 * As a workaround, we call class cctors before allocating objects.
10923 */
10924 if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
10927 printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
10929 }
10933 }
10939 /* Now call the actual ctor */
10941 CHECK_CFG_EXCEPTION;
10942 }
10945 /* Valuetype */
10951 }
10958 }
10967 UNVERIFIED;
10970 CHECK_CFG_EXCEPTION;
10983 UNVERIFIED;
10987 if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
10992 /* obj */
10995 /* klass */
10998 /* inline cache*/
11000 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
11005 } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
11015 CHECK_CFG_EXCEPTION;
11024 }
11027 CHECK_CFG_EXCEPTION;
11030 }
11032 }
11052 CHECK_CFG_EXCEPTION;
11057 /* LDOBJ */
11061 }
11066 }
11088 }
11091 UNVERIFIED;
11093 UNVERIFIED;
11094 /* frequent check in generic code: box (struct), brtrue */
11096 /*
11097 * Look for:
11098 *
11099 * <push int/long ptr>
11100 * <push int/long>
11101 * box MyFlags
11102 * constrained. MyFlags
11103 * callvirt instace bool class [mscorlib] System.Enum::HasFlag (class [mscorlib] System.Enum)
11104 *
11105 * If we find this sequence and the operand types on box and constrained
11106 * are equal, we can emit a specialized instruction sequence instead of
11107 * the very slow HasFlag () call.
11108 */
11110 /* Cheap checks first. */
11136 }
11137 }
11139 // FIXME: LLVM can't handle the inconsistent bb linking
11154 printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11156 }
11162 ip++;
11164 ip++;
11169 ip++;
11175 }
11177 /*
11178 * We need to link both bblocks, since it is needed for handling stack
11179 * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
11180 * Branching to only one of them would lead to inconsistencies, so
11181 * generate an ICONST+BRTRUE, the branch opts will get rid of them.
11182 */
11193 }
11202 /* The JIT can't eliminate the iconst+compare */
11206 }
11210 }
11214 CHECK_CFG_EXCEPTION;
11218 }
11241 }
11245 }
11253 #ifndef DISABLE_REMOTING
11255 #endif
11256 guint foffset;
11257 gboolean is_instance;
11260 gboolean is_special_static;
11275 }
11277 UNVERIFIED;
11279 UNVERIFIED;
11283 sp--;
11285 }
11286 }
11293 }
11296 CHECK_CFG_ERROR;
11297 }
11302 /* if the class is Critical then transparent code cannot access it's fields */
11306 /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
11307 any visible *instance* field (in fact there's a single case for a static field in Marshal) XXX
11308 if (mono_security_core_clr_enabled ())
11309 ensure_method_is_allowed_to_access_field (cfg, method, field);
11310 */
11314 /*
11315 * LDFLD etc. is usable on static fields as well, so convert those cases to
11316 * the static case.
11317 */
11331 }
11333 }
11337 /* INSTANCE CASE */
11342 UNVERIFIED;
11343 #ifndef DISABLE_REMOTING
11344 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
11360 CHECK_CFG_EXCEPTION;
11368 }
11370 #endif
11371 {
11382 /* The value is offset by 1 */
11387 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
11391 }
11395 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
11400 /* insert call to write barrier */
11407 }
11408 }
11411 }
11415 }
11417 #ifndef DISABLE_REMOTING
11418 if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
11419 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
11427 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
11431 CHECK_CFG_EXCEPTION;
11442 }
11444 #endif
11449 /* Have to compute the address of the variable */
11454 else
11459 }
11465 }
11473 /* The value is offset by 1 */
11478 }
11491 /* The value is offset by 1 */
11498 }
11503 }
11504 }
11510 }
11512 /* STATIC CASE */
11516 mono_error_set_field_load (&cfg->error, field->parent, field->name, "Using static instructions with literal field");
11517 CHECK_CFG_ERROR;
11518 }
11520 /* The special_static_fields field is init'd in mono_class_vtable, so it needs
11521 * to be called here.
11522 */
11526 }
11536 else
11539 /* Generate IR to compute the field address */
11540 if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
11541 /*
11542 * Fast access to TLS data
11543 * Inline version of get_thread_static_data () in
11544 * threads.c.
11545 */
11546 guint32 offset;
11553 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
11558 /* For TLS variables, this will return the TLS offset */
11581 }
11594 }
11599 /*
11600 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
11601 method->klass->name_space, method->klass->name, method->name,
11602 depth, field->offset);
11603 */
11608 /*
11609 * The pointer we're computing here is
11610 *
11611 * super_info.static_data + field->offset
11612 */
11620 /* The value is offset by 1 */
11629 }
11649 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
11651 }
11654 /* This makes so that inline cannot trigger */
11655 /* .cctors: too many apps depend on them */
11656 /* running with a specific order... */
11663 }
11664 }
11665 }
11673 }
11678 }
11679 }
11681 /* Generate IR to do the actual load/store operation */
11684 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11686 }
11705 }
11706 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
11707 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
11713 }
11717 /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
11723 sp++;
11727 sp++;
11732 sp++;
11736 sp++;
11741 sp++;
11745 sp++;
11753 sp++;
11763 sp++;
11766 }
11771 sp++;
11779 }
11780 }
11791 }
11792 }
11795 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
11797 }
11802 }
11811 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11813 }
11814 /* FIXME: should check item at sp [1] is compatible with the type of the store. */
11819 /* insert call to write barrier */
11821 }
11827 /*
11828 * Array opcodes
11829 */
11834 guint32 field_token;
11854 }
11861 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
11863 /* vtable */
11866 /* array len */
11871 else
11875 /* Decompose now to avoid problems with references to the domainvar */
11884 /* Decompose later since it is needed by abcrem */
11899 /* Needed so mono_emit_load_get_addr () gets called */
11901 }
11902 }
11909 /*
11910 * we inline/optimize the initialization sequence if possible.
11911 * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
11912 * for small sizes open code the memcpy
11913 * ensure the rva field is big enough
11914 */
11915 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))) {
11920 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
11922 EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
11925 }
11929 }
11932 }
11937 UNVERIFIED;
11943 /* This flag will be inherited by the decomposition */
11948 ip ++;
11956 UNVERIFIED;
11962 /* we need to make sure that this array is exactly the type it needs
11963 * to be for correctness. the wrappers are lax with their usage
11964 * so we need to ignore them here
11965 */
11970 }
12000 }
12001 else
12005 UNVERIFIED;
12010 // FIXME-VT: OP_ICONST optimization
12017 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
12027 }
12031 else
12034 }
12055 }
12056 else
12060 UNVERIFIED;
12066 else
12070 }
12088 }
12092 }
12110 // FIXME:
12113 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12115 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
12123 // FIXME:
12128 }
12129 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
12135 }
12150 loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
12158 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
12159 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12160 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12166 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
12167 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12168 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12170 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
12171 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), klass);
12172 }
12173 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
12181 }
12183 gpointer handle;
12197 }
12200 CHECK_CFG_ERROR;
12201 }
12203 LOAD_ERROR;
12208 /* This case handles ldtoken
12209 of an open type, like for
12210 typeof(Gen<>). */
12213 context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type ((MonoType *)handle));
12218 else
12220 }
12241 }
12262 if (mono_class_get_checked (tclass->image, tclass->type_token, &error) == tclass && !generic_context) {
12263 /* Special case for static synchronized wrappers */
12264 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
12267 /* FIXME: n is not a normal token */
12270 }
12273 }
12275 MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, &cfg->error);
12276 CHECK_CFG_ERROR;
12278 }
12291 MONO_RGCTX_INFO_TYPE);
12300 }
12305 }
12309 }
12310 }
12315 }
12321 ip++;
12330 /* This can complicate code generation for llvm since the return value might not be defined */
12335 /* mono_save_seq_point_info () depends on this */
12340 ip++;
12343 /*
12344 * Control will leave the method so empty the stack, otherwise
12345 * the next basic block will start with a nonempty stack.
12346 */
12348 sp--;
12349 }
12361 }
12363 /* empty the stack */
12365 sp--;
12366 }
12368 /*
12369 * If this leave statement is in a catch block, check for a
12370 * pending exception, and rethrow it if necessary.
12371 * We avoid doing this in runtime invoke wrappers, since those are called
12372 * by native code which excepts the wrapper to catch all exceptions.
12373 */
12377 /*
12378 * Use <= in the final comparison to handle clauses with multiple
12379 * leave statements, like in bug #78024.
12380 * The ordering of the exception clauses guarantees that we find the
12381 * innermost clause.
12382 */
12383 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) {
12387 /*
12388 MonoInst *load;
12390 NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
12391 */
12397 /*
12398 * Currently, we always rethrow the abort exception, despite the
12399 * fact that this is not correct. See thread6.cs for an example.
12400 * But propagating the abort exception is more important than
12401 * getting the sematics right.
12402 */
12408 }
12409 }
12411 #ifdef ENABLE_LLVM
12413 #endif
12432 /*
12433 * Link the finally bblock with the target, since it will
12434 * conceptually branch there.
12435 */
12439 }
12440 }
12442 }
12454 else
12458 }
12460 /*
12461 * Mono specific opcodes
12462 */
12470 gpointer func;
12491 }
12511 }
12517 }
12519 gpointer ptr;
12530 /* Can't embed random pointers into AOT code */
12533 }
12536 gpointer ptr;
12550 }
12553 gpointer ptr;
12567 }
12571 }
12578 // FIXME:
12584 }
12601 }
12614 /*
12615 * Similar to LDOBJ, but instead load the unmanaged
12616 * representation of the vtype to the stack.
12617 */
12626 {
12641 }
12644 /*
12645 * Same as RET, but return the native representation of a vtype
12646 * to the caller.
12647 */
12663 }
12667 UNVERIFIED;
12676 }
12687 else
12692 }
12711 MonoTlsKey key;
12727 }
12728 }
12734 }
12738 /* It would be easier to call a trampoline, but that would put an
12739 * extra frame on the stack, confusing exception handling. So
12740 * implement it inline using an opcode for now.
12741 */
12744 cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12745 /* prevent it from being register allocated */
12747 }
12749 /* Has to use a call inst since it local regalloc expects it */
12763 }
12769 }
12775 cfg->attach_cookie = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12776 cfg->attach_dummy = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12779 /* AOT code is only used in the root domain */
12796 /* AOT code is only used in the root domain */
12800 }
12811 }
12813 /* AOT code is only used in the root domain */
12821 }
12825 }
12829 /* Restore the original domain */
12836 }
12842 /*
12843 * This is the same as CEE_CALLI, but passes an additional argument
12844 * to the called method in llvmonly mode.
12845 * This is only used by delegate invoke wrappers to call the
12846 * actual delegate method.
12847 */
12860 CHECK_CFG_ERROR;
12873 /*
12874 * The lowest bit of 'arg' determines whenever the callee uses the gsharedvt
12875 * cconv. This is set by mono_init_delegate ().
12876 */
12890 /* Normal case: callee uses a normal cconv, have to add an out wrapper */
12893 /*
12894 * ADDR points to a gsharedvt-out wrapper, have to pass <callee, arg> as an extra arg.
12895 */
12903 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12908 /* Gsharedvt case: callee uses a gsharedvt cconv, no conversion is needed */
12916 /* Caller uses a normal calling conv */
12930 /* Normal case: callee uses a normal cconv, no conversion is needed */
12933 /* Gsharedvt case: callee uses a gsharedvt cconv, have to add an in wrapper */
12938 /*
12939 * ADDR points to a gsharedvt-in wrapper, have to pass <callee, arg> as an extra arg.
12940 */
12948 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12955 }
12957 /* Same as CEE_CALLI */
12959 /*
12960 * We pass the address to the gsharedvt trampoline in the rgctx reg
12961 */
12969 }
12970 }
12975 CHECK_CFG_EXCEPTION;
12981 }
12985 }
12987 }
12993 /* somewhat similar to LDTOKEN */
12996 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
13007 }
13020 /*
13021 * The following transforms:
13022 * CEE_CEQ into OP_CEQ
13023 * CEE_CGT into OP_CGT
13024 * CEE_CGT_UN into OP_CGT_UN
13025 * CEE_CLT into OP_CLT
13026 * CEE_CLT_UN into OP_CLT_UN
13027 */
13036 if ((arg1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((arg1->type == STACK_PTR) || (arg1->type == STACK_OBJ) || (arg1->type == STACK_MP))))
13042 else
13050 /*
13051 * The backends expect the fceq opcodes to do the
13052 * comparison too.
13053 */
13057 }
13062 }
13071 CHECK_CFG_ERROR;
13080 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
13086 /*
13087 * Optimize the common case of ldftn+delegate creation
13088 */
13089 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
13090 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13098 LOAD_ERROR;
13108 /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
13109 if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
13112 }
13113 }
13115 /* FIXME: SGEN support */
13119 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));
13120 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, FALSE))) {
13121 sp --;
13123 CHECK_CFG_EXCEPTION;
13125 sp ++;
13127 }
13129 }
13130 }
13131 }
13140 }
13148 CHECK_CFG_ERROR;
13157 /*
13158 * Optimize the common case of ldvirtftn+delegate creation
13159 */
13160 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)) {
13161 MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13170 LOAD_ERROR;
13179 /* FIXME: SGEN support */
13183 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));
13184 if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, is_virtual))) {
13187 CHECK_CFG_EXCEPTION;
13189 sp ++;
13191 }
13193 }
13194 }
13195 }
13205 else
13211 }
13238 UNVERIFIED;
13262 }
13268 }
13276 UNVERIFIED;
13285 UNVERIFIED;
13287 /*
13288 * Inlining this into a loop in a parent could lead to
13289 * stack overflows which is different behavior than the
13290 * non-inlined case, thus disable inlining in this case.
13291 */
13314 UNVERIFIED;
13325 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
13328 }
13331 UNVERIFIED;
13334 }
13337 /* FIXME: record alignment? we can assume 1 for now */
13348 /* Can't inline tail calls at this time */
13361 else
13379 /* Skip optimized paths for volatile operations. */
13380 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)) {
13382 } 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)) {
13383 /* emit_memset only works when val == 0 */
13391 /*
13392 * FIXME: It's unclear whether we should be emitting both the acquire
13393 * and release barriers for cpblk. It is technically both a load and
13394 * store operation, so it seems like that's the sensible thing to do.
13395 *
13396 * FIXME: We emit full barriers on both sides of the operation for
13397 * simplicity. We should have a separate atomic memcpy method instead.
13398 */
13412 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
13414 }
13417 }
13418 }
13423 }
13430 /* we ignore the no-nullcheck for now since we
13431 * really do it explicitly only when doing callvirt->call
13432 */
13441 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
13444 }
13445 }
13450 UNVERIFIED;
13465 }
13467 guint32 val;
13473 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (method->klass->image) && !generic_context) {
13475 CHECK_CFG_ERROR;
13486 }
13491 }
13500 // FIXME:
13503 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
13505 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
13509 }
13520 UNVERIFIED;
13524 UNVERIFIED;
13525 }
13527 }
13530 UNVERIFIED;
13534 UNVERIFIED;
13535 }
13536 }
13538 UNVERIFIED;
13542 /* This could already be set because of inlining, #693905 */
13550 }
13562 }
13565 }
13567 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
13569 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
13571 #endif
13581 }
13582 }
13585 /* Emit initialization for ref vars */
13586 // FIXME: Avoid duplication initialization for IL locals.
13592 }
13593 }
13598 }
13606 /*
13607 * Make seq points at backward branch targets interruptable.
13608 */
13612 }
13614 /* Add a sequence point for method entry/exit events */
13620 }
13622 /*
13623 * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
13624 * the code they refer to was dead (#11880).
13625 */
13628 if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
13633 }
13634 }
13635 }
13647 }
13650 /* get_most_deep_clause () in mini-llvm.c depends on this for inlined bblocks */
13653 }
13654 }
13659 /* Method is too large */
13661 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Method %s is too complex.", mname));
13663 }
13670 mono_error_exit:
13674 exception_exit:
13678 unverified:
13682 cleanup:
13689 else
13691 }
13693 static int
13695 {
13709 }
13712 }
13714 int
13716 {
13761 #if SIZEOF_REGISTER == 8
13764 #endif
13782 #if defined(TARGET_X86) || defined (TARGET_AMD64)
13787 #endif
13788 #if defined(TARGET_AMD64)
13791 #endif
13802 }
13805 }
13807 static int
13809 {
13835 }
13838 }
13840 static int
13842 {
13861 }
13864 }
13866 int
13868 {
13869 // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
13870 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13882 #if SIZEOF_REGISTER == 8
13885 #endif
13886 }
13887 #endif
13890 }
13894 {
13895 #if defined(TARGET_X86)
13927 }
13928 #endif
13930 #if defined(TARGET_AMD64)
13931 if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
13982 }
13983 #endif
13986 }
13990 {
13991 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13999 }
14000 #endif
14003 }
14007 {
14008 #ifdef TARGET_X86
14009 /* FIXME: This has sign extension issues */
14010 /*
14011 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14012 return OP_X86_COMPARE_MEMBASE8_IMM;
14013 */
14015 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14027 }
14028 #endif
14030 #ifdef TARGET_AMD64
14031 /* FIXME: This has sign extension issues */
14032 /*
14033 if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14034 return OP_X86_COMPARE_MEMBASE8_IMM;
14035 */
14039 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14042 /* FIXME: This only works for 32 bit immediates
14043 case OP_COMPARE_IMM:
14044 case OP_LCOMPARE_IMM:
14045 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
14046 return OP_AMD64_COMPARE_MEMBASE_IMM;
14047 */
14056 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14063 }
14064 #endif
14067 }
14071 {
14072 #ifdef TARGET_X86
14073 if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14090 }
14091 #endif
14093 #ifdef TARGET_AMD64
14094 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && cfg->backend->ilp32)) {
14108 }
14109 } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32)) {
14124 }
14125 }
14126 #endif
14129 }
14131 int
14133 {
14135 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
14140 #endif
14141 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
14147 #endif
14148 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
14151 #endif
14154 }
14155 }
14157 /**
14158 * mono_handle_global_vregs:
14159 *
14160 * Make vregs used in more than one bblock 'global', i.e. allocate a variable
14161 * for them.
14162 */
14163 void
14165 {
14170 vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
14172 #ifdef MONO_ARCH_SIMD_INTRINSICS
14175 #endif
14177 /* Find local vregs used in more than one bb */
14189 gint32 prev_bb;
14219 }
14221 #if SIZEOF_REGISTER == 4
14222 /* In the LLVM case, the long opcodes are not decomposed */
14224 /*
14225 * Since some instructions reference the original long vreg,
14226 * and some reference the two component vregs, it is quite hard
14227 * to determine when it needs to be global. So be conservative.
14228 */
14230 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14234 }
14236 /*
14237 * Make the component vregs volatile since the optimizations can
14238 * get confused otherwise.
14239 */
14242 }
14243 #endif
14249 /* 0 is a valid block num */
14252 if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
14262 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
14263 else
14267 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14270 mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
14277 }
14278 }
14280 /* Flag as having been used in more than one bb */
14282 }
14283 }
14284 }
14285 }
14287 /* If a variable is used in only one bblock, convert it into a local vreg */
14298 #if SIZEOF_REGISTER == 8
14300 #endif
14301 #if !defined(TARGET_X86)
14302 /* Enabling this screws up the fp stack on x86 */
14304 #endif
14308 /*
14309 if (var->type == STACK_VTYPE && cfg->gsharedvt && mini_is_gsharedvt_variable_type (var->inst_vtype))
14310 break;
14311 */
14313 /* Arguments are implicitly global */
14314 /* Putting R4 vars into registers doesn't work currently */
14315 /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
14316 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) {
14317 /*
14318 * Make that the variable's liveness interval doesn't contain a call, since
14319 * that would cause the lvreg to be spilled, making the whole optimization
14320 * useless.
14321 */
14322 /* This is too slow for JIT compilation */
14323 #if 0
14343 }
14344 }
14349 ins_index ++;
14350 }
14354 }
14355 #endif
14361 }
14363 }
14364 }
14366 /*
14367 * Compress the varinfo and vars tables so the liveness computation is faster and
14368 * takes up less space.
14369 */
14381 #if SIZEOF_REGISTER == 4
14383 /* Modify the two component vars too */
14390 }
14391 #endif
14392 }
14393 pos ++;
14394 }
14395 }
14399 }
14401 /*
14402 * mono_allocate_gsharedvt_vars:
14403 *
14404 * Allocate variables with gsharedvt types to entries in the MonoGSharedVtMethodRuntimeInfo.entries array.
14405 * Initialize cfg->gsharedvt_vreg_to_idx with the mapping between vregs and indexes.
14406 */
14407 void
14409 {
14412 cfg->gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
14420 /* Local */
14426 /* Arg */
14429 }
14430 }
14431 }
14432 }
14434 /**
14435 * mono_spill_global_vars:
14436 *
14437 * Generate spill code for variables which are not allocated to registers,
14438 * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
14439 * code is generated which could be optimized by the local optimization passes.
14440 */
14441 void
14443 {
14459 /* FIXME: Move this function to mini.c */
14463 #ifdef MONO_ARCH_SIMD_INTRINSICS
14465 #endif
14467 #if SIZEOF_REGISTER == 4
14468 /* Create MonoInsts for longs */
14495 }
14498 }
14499 }
14500 }
14501 #endif
14504 /* registers need liveness info even for !non refs */
14510 }
14511 }
14513 /* FIXME: widening and truncation */
14515 /*
14516 * As an optimization, when a variable allocated to the stack is first loaded into
14517 * an lvreg, we will remember the lvreg and use it the next time instead of loading
14518 * the variable again.
14519 */
14521 vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
14525 /*
14526 * These arrays contain the first and last instructions accessing a given
14527 * variable.
14528 * Since we emit bblocks in the same order we process them here, and we
14529 * don't split live ranges, these will precisely describe the live range of
14530 * the variable, i.e. the instruction range where a valid value can be found
14531 * in the variables location.
14532 * The live range is computed using the liveness info computed by the liveness pass.
14533 * We can't use vmv->range, since that is an abstract live range, and we need
14534 * one which is instruction precise.
14535 * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
14536 */
14537 /* FIXME: Only do this if debugging info is requested */
14543 /* Add spill loads/stores */
14550 /* Clear vreg_to_lvreg array */
14568 /*
14569 * We handle LDADDR here as well, since it can only be decomposed
14570 * when variable addresses are known.
14571 */
14576 /* Happens on SPARC/S390 where vtypes are passed by reference */
14581 }
14587 NOT_IMPLEMENTED;
14589 /* gsharedvt arg passed by ref */
14602 /*
14603 * gsharedvt local.
14604 * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
14605 */
14612 /* Mark the instruction used to compute the locals var as used */
14615 /* Load the offset */
14618 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
14624 }
14626 NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
14627 /* Load the locals area address */
14630 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
14635 }
14636 /* Compute the address */
14651 }
14655 }
14660 }
14662 /*
14663 * Store opcodes have destbasereg in the dreg, but in reality, it is an
14664 * src register.
14665 * FIXME:
14666 */
14680 else
14690 }
14692 /***************/
14693 /* DREG */
14694 /***************/
14696 g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
14710 } 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)) {
14711 /*
14712 * Instead of emitting a load+store, use a _membase opcode.
14713 */
14723 }
14726 guint32 lvreg;
14732 /* Invalidate any previous lvreg for this vreg */
14740 }
14744 #if SIZEOF_REGISTER != 8
14746 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));
14748 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));
14751 }
14752 else
14753 #endif
14754 {
14757 /* Try to fuse the store into the instruction itself */
14758 /* FIXME: Add more instructions */
14759 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
14765 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE) || (ins->opcode == OP_RMOVE))) {
14783 // FIXME: The backends expect the base reg to be in inst_basereg
14790 /* printf ("INS: "); mono_print_ins (ins); */
14791 /* Create a store instruction */
14792 NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
14794 /* Insert it after the instruction */
14799 /*
14800 * We can't assign ins->dreg to var->dreg here, since the
14801 * sregs could use it. So set a flag, and do it after
14802 * the sregs.
14803 */
14804 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)))
14806 }
14807 }
14808 }
14813 }
14821 }
14822 }
14824 /************/
14825 /* SREGS */
14826 /************/
14837 guint32 load_opcode;
14841 //mono_inst_set_src_registers (ins, sregs);
14845 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14849 /* var->dreg is a hreg */
14852 }
14855 }
14866 /* The variable is already loaded to an lvreg */
14870 //mono_inst_set_src_registers (ins, sregs);
14872 }
14874 /* Try to fuse the load into the instruction */
14878 //mono_inst_set_src_registers (ins, sregs);
14880 } else if ((srcindex == 1) && (op_to_op_src2_membase (cfg, load_opcode, ins->opcode) != -1)) {
14883 //mono_inst_set_src_registers (ins, sregs);
14890 //printf ("%d ", srcindex); mono_print_ins (ins);
14894 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) {
14896 /*
14897 * sreg refers to the value loaded by the load
14898 * emitted below, but we need to use ins->dreg
14899 * since it refers to the store emitted earlier.
14900 */
14902 }
14907 }
14908 }
14911 //mono_inst_set_src_registers (ins, sregs);
14913 #if SIZEOF_REGISTER != 8
14915 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_MS (sreg), var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
14917 NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_LS (sreg), var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
14920 }
14921 else
14922 #endif
14923 {
14924 #if SIZEOF_REGISTER == 4
14926 #endif
14930 }
14931 }
14936 }
14938 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14944 }
14945 }
14946 }
14955 }
14961 }
14964 /* Clear vreg_to_lvreg array */
14971 }
14975 }
14977 /* Extend the live range based on the liveness info */
14983 /* The liveness info is incomplete */
14987 /* Live from at least the first ins of this bb */
14990 }
14993 /* Live at least until the last ins of this bb */
14996 }
14997 }
14998 }
14999 }
15001 /*
15002 * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
15003 * by storing the current native offset into MonoMethodVar->live_range_start/end.
15004 */
15005 if (cfg->backend->have_liverange_ops && cfg->compute_precise_live_ranges && cfg->comp_done & MONO_COMP_LIVENESS) {
15015 }
15022 else
15024 }
15025 }
15026 }
15029 /* Nullify if unused */
15032 }
15038 }
15040 /**
15041 * FIXME:
15042 * - use 'iadd' instead of 'int_add'
15043 * - handling ovf opcodes: decompose in method_to_ir.
15044 * - unify iregs/fregs
15045 * -> partly done, the missing parts are:
15046 * - a more complete unification would involve unifying the hregs as well, so
15047 * code wouldn't need if (fp) all over the place. but that would mean the hregs
15048 * would no longer map to the machine hregs, so the code generators would need to
15049 * be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
15050 * wouldn't work any more. Duplicating the code in mono_local_regalloc () into
15051 * fp/non-fp branches speeds it up by about 15%.
15052 * - use sext/zext opcodes instead of shifts
15053 * - add OP_ICALL
15054 * - get rid of TEMPLOADs if possible and use vregs instead
15055 * - clean up usage of OP_P/OP_ opcodes
15056 * - cleanup usage of DUMMY_USE
15057 * - cleanup the setting of ins->type for MonoInst's which are pushed on the
15058 * stack
15059 * - set the stack type and allocate a dreg in the EMIT_NEW macros
15060 * - get rid of all the <foo>2 stuff when the new JIT is ready.
15061 * - make sure handle_stack_args () is called before the branch is emitted
15062 * - when the new IR is done, get rid of all unused stuff
15063 * - COMPARE/BEQ as separate instructions or unify them ?
15064 * - keeping them separate allows specialized compare instructions like
15065 * compare_imm, compare_membase
15066 * - most back ends unify fp compare+branch, fp compare+ceq
15067 * - integrate mono_save_args into inline_method
15068 * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
15069 * - handle long shift opts on 32 bit platforms somehow: they require
15070 * 3 sregs (2 for arg1 and 1 for arg2)
15071 * - make byref a 'normal' type.
15072 * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
15073 * variable if needed.
15074 * - do not start a new IL level bblock when cfg->cbb is changed by a function call
15075 * like inline_method.
15076 * - remove inlining restrictions
15077 * - fix LNEG and enable cfold of INEG
15078 * - generalize x86 optimizations like ldelema as a peephole optimization
15079 * - add store_mem_imm for amd64
15080 * - optimize the loading of the interruption flag in the managed->native wrappers
15081 * - avoid special handling of OP_NOP in passes
15082 * - move code inserting instructions into one function/macro.
15083 * - try a coalescing phase after liveness analysis
15084 * - add float -> vreg conversion + local optimizations on !x86
15085 * - figure out how to handle decomposed branches during optimizations, ie.
15086 * compare+branch, op_jump_table+op_br etc.
15087 * - promote RuntimeXHandles to vregs
15088 * - vtype cleanups:
15089 * - add a NEW_VARLOADA_VREG macro
15090 * - the vtype optimizations are blocked by the LDADDR opcodes generated for
15091 * accessing vtype fields.
15092 * - get rid of I8CONST on 64 bit platforms
15093 * - dealing with the increase in code size due to branches created during opcode
15094 * decomposition:
15095 * - use extended basic blocks
15096 * - all parts of the JIT
15097 * - handle_global_vregs () && local regalloc
15098 * - avoid introducing global vregs during decomposition, like 'vtable' in isinst
15099 * - sources of increase in code size:
15100 * - vtypes
15101 * - long compares
15102 * - isinst and castclass
15103 * - lvregs not allocated to global registers even if used multiple times
15104 * - call cctors outside the JIT, to make -v output more readable and JIT timings more
15105 * meaningful.
15106 * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
15107 * - add all micro optimizations from the old JIT
15108 * - put tree optimizations into the deadce pass
15109 * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
15110 * specific function.
15111 * - unify the float comparison opcodes with the other comparison opcodes, i.e.
15112 * fcompare + branchCC.
15113 * - create a helper function for allocating a stack slot, taking into account
15114 * MONO_CFG_HAS_SPILLUP.
15115 * - merge r68207.
15116 * - merge the ia64 switch changes.
15117 * - optimize mono_regstate2_alloc_int/float.
15118 * - fix the pessimistic handling of variables accessed in exception handler blocks.
15119 * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
15120 * parts of the tree could be separated by other instructions, killing the tree
15121 * arguments, or stores killing loads etc. Also, should we fold loads into other
15122 * instructions if the result of the load is used multiple times ?
15123 * - make the REM_IMM optimization in mini-x86.c arch-independent.
15124 * - LAST MERGE: 108395.
15125 * - when returning vtypes in registers, generate IR and append it to the end of the
15126 * last bb instead of doing it in the epilog.
15127 * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
15128 */
15130 /*
15132 NOTES
15133 -----
15135 - When to decompose opcodes:
15136 - earlier: this makes some optimizations hard to implement, since the low level IR
15137 no longer contains the neccessary information. But it is easier to do.
15138 - later: harder to implement, enables more optimizations.
15139 - Branches inside bblocks:
15140 - created when decomposing complex opcodes.
15141 - branches to another bblock: harmless, but not tracked by the branch
15142 optimizations, so need to branch to a label at the start of the bblock.
15143 - branches to inside the same bblock: very problematic, trips up the local
15144 reg allocator. Can be fixed by spitting the current bblock, but that is a
15145 complex operation, since some local vregs can become global vregs etc.
15146 - Local/global vregs:
15147 - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
15148 local register allocator.
15149 - global vregs: used in more than one bblock. Have an associated MonoMethodVar
15150 structure, created by mono_create_var (). Assigned to hregs or the stack by
15151 the global register allocator.
15152 - When to do optimizations like alu->alu_imm:
15153 - earlier -> saves work later on since the IR will be smaller/simpler
15154 - later -> can work on more instructions
15155 - Handling of valuetypes:
15156 - When a vtype is pushed on the stack, a new temporary is created, an
15157 instruction computing its address (LDADDR) is emitted and pushed on
15158 the stack. Need to optimize cases when the vtype is used immediately as in
15159 argument passing, stloc etc.
15160 - Instead of the to_end stuff in the old JIT, simply call the function handling
15161 the values on the stack before emitting the last instruction of the bb.
15162 */