?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-11-23 Zoltan Varga <vargaz@gmail.com>
[mono-project.git] / mono / mini / mini.h
blobd08cc0e93a66b716f4390ed12c322cbb8be5318d
1 #ifndef __MONO_MINI_H__
2 #define __MONO_MINI_H__
3
4 #include "config.h"
5 #include <glib.h>
6 #include <signal.h>
7 #include <mono/metadata/loader.h>
8 #include <mono/metadata/mempool.h>
9 #include <mono/utils/monobitset.h>
10 #include <mono/metadata/class.h>
11 #include <mono/metadata/object.h>
12 #include <mono/metadata/opcodes.h>
13 #include <mono/metadata/tabledefs.h>
14 #include <mono/metadata/domain-internals.h>
15 #include "mono/metadata/class-internals.h"
16 #include "mono/metadata/object-internals.h"
17 #include <mono/metadata/profiler-private.h>
18 #include <mono/metadata/debug-helpers.h>
19 #include <mono/utils/mono-compiler.h>
20
21 #define MONO_BREAKPOINT_ARRAY_SIZE 64
22
23 /* C type matching the size of a machine register. Not always the same as 'int' */
24 /* Note that member 'p' of MonoInst must be the same type, as OP_PCONST is defined
25 * as one of the OP_ICONST types, so inst_c0 must be the same as inst_p0
26 */
27 #if SIZEOF_REGISTER == 4
28 typedef gint32 mgreg_t;
29 #elif SIZEOF_REGISTER == 8
30 typedef gint64 mgreg_t;
31 #endif
32
33 #include "mini-arch.h"
34 #include "regalloc.h"
35 #include "declsec.h"
36 #include "unwind.h"
37
38 #ifndef G_LIKELY
39 #define G_LIKELY(a) (a)
40 #define G_UNLIKELY(a) (a)
41 #endif
42
43 #ifndef G_MAXINT32
44 #define G_MAXINT32 2147483647
45 #endif
46
47 #ifndef G_MININT32
48 #define G_MININT32 (-G_MAXINT32 - 1)
49 #endif
50
51 #if DISABLE_LOGGING
52 #define MINI_DEBUG(level,limit,code)
53 #else
54 #define MINI_DEBUG(level,limit,code) do {if (G_UNLIKELY ((level) >= (limit))) code} while (0)
55 #endif
56
57 #if !defined(DISABLE_TASKLETS) && defined(MONO_ARCH_SUPPORT_TASKLETS) && defined(__GNUC__)
58 #define MONO_SUPPORT_TASKLETS 1
59 #endif
60
61 #if ENABLE_LLVM
62 #define COMPILE_LLVM(cfg) ((cfg)->compile_llvm)
63 #define LLVM_ENABLED TRUE
64 #else
65 #define COMPILE_LLVM(cfg) (0)
66 #define LLVM_ENABLED FALSE
67 #endif
68
69 #define NOT_IMPLEMENTED do { g_assert_not_reached (); } while (0)
70
71 /* for 32 bit systems */
72 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
73 #define MINI_LS_WORD_IDX 0
74 #define MINI_MS_WORD_IDX 1
75 #else
76 #define MINI_LS_WORD_IDX 1
77 #define MINI_MS_WORD_IDX 0
78 #endif
79 #define MINI_LS_WORD_OFFSET (MINI_LS_WORD_IDX * 4)
80 #define MINI_MS_WORD_OFFSET (MINI_MS_WORD_IDX * 4)
81 #define inst_ls_word data.op[MINI_LS_WORD_IDX].const_val
82 #define inst_ms_word data.op[MINI_MS_WORD_IDX].const_val
83
84 #define MONO_FAKE_IMT_METHOD ((MonoMethod*)GINT_TO_POINTER(-1))
85 #define MONO_FAKE_VTABLE_METHOD ((MonoMethod*)GINT_TO_POINTER(-2))
86
87 #ifndef DISABLE_AOT
88 #define MONO_USE_AOT_COMPILER
89 #endif
90
91 /* Version number of the AOT file format */
92 #define MONO_AOT_FILE_VERSION "59"
93
94 //TODO: This is x86/amd64 specific.
95 #define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6))
96
97 /* Constants used to encode different types of methods in AOT */
98 enum {
99 MONO_AOT_METHODREF_MIN = 240,
100 /* Method encoded using its name */
101 MONO_AOT_METHODREF_WRAPPER_NAME = 250,
102 /* Runtime provided methods on arrays */
103 MONO_AOT_METHODREF_ARRAY = 251,
104 MONO_AOT_METHODREF_NO_AOT_TRAMPOLINE = 252,
105 /* Wrappers */
106 MONO_AOT_METHODREF_WRAPPER = 253,
107 /* Methods on generic instances */
108 MONO_AOT_METHODREF_GINST = 254,
109 /* Methods resolve using a METHODSPEC token */
110 MONO_AOT_METHODREF_METHODSPEC = 255,
111 };
112
113 /* Trampolines which we have a lot of */
114 typedef enum {
115 MONO_AOT_TRAMP_SPECIFIC = 0,
116 MONO_AOT_TRAMP_STATIC_RGCTX = 1,
117 MONO_AOT_TRAMP_IMT_THUNK = 2,
118 MONO_AOT_TRAMP_NUM = 3
119 } MonoAotTrampoline;
120
121 /* This structure is stored in the AOT file */
122 typedef struct MonoAotFileInfo
123 {
124 guint32 plt_got_offset_base;
125 guint32 got_size;
126 guint32 plt_size;
127 guint32 nmethods;
128
129 guint32 num_trampolines [MONO_AOT_TRAMP_NUM];
130 guint32 trampoline_got_offset_base [MONO_AOT_TRAMP_NUM];
131 guint32 trampoline_size [MONO_AOT_TRAMP_NUM];
132 } MonoAotFileInfo;
133
134 /* Per-domain information maintained by the JIT */
135 typedef struct
136 {
137 /* Maps MonoMethod's to a GSList of GOT slot addresses pointing to its code */
138 GHashTable *jump_target_got_slot_hash;
139 GHashTable *jump_target_hash;
140 /* Maps methods/klasses to the address of the given type of trampoline */
141 GHashTable *class_init_trampoline_hash;
142 GHashTable *jump_trampoline_hash;
143 GHashTable *jit_trampoline_hash;
144 GHashTable *delegate_trampoline_hash;
145 GHashTable *static_rgctx_trampoline_hash;
146 GHashTable *llvm_vcall_trampoline_hash;
147 /* maps MonoMethod -> MonoJitDynamicMethodInfo */
148 GHashTable *dynamic_code_hash;
149 GHashTable *method_code_hash;
150 /* Maps methods to a RuntimeInvokeInfo structure */
151 GHashTable *runtime_invoke_hash;
152 /* Maps MonoMethod to a GPtrArray containing sequence point locations */
153 GHashTable *seq_points;
154 /* Debugger agent data */
155 gpointer agent_info;
156 /* Maps MonoMethod to an arch-specific structure */
157 GHashTable *arch_seq_points;
158 } MonoJitDomainInfo;
159
160 typedef struct {
161 MonoJitInfo *ji;
162 MonoCodeManager *code_mp;
163 } MonoJitDynamicMethodInfo;
164
165 #define domain_jit_info(domain) ((MonoJitDomainInfo*)((domain)->runtime_info))
166
167 /* Arch-specific */
168 typedef struct {
169 int dummy;
170 } MonoDynCallInfo;
171
172 /*
173 * Possible frame types returned by the stack walker.
174 */
175 typedef enum {
176 /* Normal managed frames */
177 FRAME_TYPE_MANAGED = 0,
178 /* Pseudo frame marking the start of a method invocation done by the soft debugger */
179 FRAME_TYPE_DEBUGGER_INVOKE = 1,
180 /* Frame for transitioning to native code */
181 FRAME_TYPE_MANAGED_TO_NATIVE = 2,
182 FRAME_TYPE_SENTINEL = 3
183 } StackFrameType;
184
185 /*
186 * Information about a stack frame
187 */
188 typedef struct {
189 StackFrameType type;
190 /*
191 * For FRAME_TYPE_MANAGED.
192 * For FRAME_TYPE_MANAGED_TO_NATIVE, the ji for the method which transitioned to
193 * native code, if there is one, else NULL.
194 */
195 MonoJitInfo *ji;
196 /*
197 * For FRAME_TYPE_MANAGED_TO_NATIVE, it is either the method which transitioned
198 * to native code, or the method which was JITted.
199 */
200 MonoMethod *method;
201 /* The domain containing the code executed by this frame */
202 MonoDomain *domain;
203 gboolean managed;
204 int native_offset;
205 int il_offset;
206 } StackFrameInfo;
207
208 #if 0
209 #define mono_bitset_foreach_bit(set,b,n) \
210 for (b = 0; b < n; b++)\
211 if (mono_bitset_test_fast(set,b))
212 #define mono_bitset_foreach_bit_rev(set,b,n) \
213 for (b = n - 1; b >= 0; b--)\
214 if (mono_bitset_test_fast(set,b))
215 #else
216 #define mono_bitset_foreach_bit(set,b,n) \
217 for (b = mono_bitset_find_start (set); b < n && b >= 0; b = mono_bitset_find_first (set, b))
218 #define mono_bitset_foreach_bit_rev(set,b,n) \
219 for (b = mono_bitset_find_last (set, n - 1); b >= 0; b = b ? mono_bitset_find_last (set, b) : -1)
220
221 #endif
222
223 /*
224 * Pull the list of opcodes
225 */
226 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
227 a = i,
228
229 enum {
230 #include "mono/cil/opcode.def"
231 CEE_LASTOP
232 };
233 #undef OPDEF
234
235 #define MONO_VARINFO(cfg,varnum) (&(cfg)->vars [varnum])
236
237 #define MONO_INST_NULLIFY_SREGS(dest) do { \
238 (dest)->sreg1 = (dest)->sreg2 = (dest)->sreg3 = -1; \
239 } while (0)
240
241 #define MONO_INST_NEW(cfg,dest,op) do { \
242 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
243 (dest)->opcode = (op); \
244 (dest)->dreg = -1; \
245 MONO_INST_NULLIFY_SREGS ((dest)); \
246 (dest)->cil_code = (cfg)->ip; \
247 } while (0)
248
249 #define MONO_INST_NEW_CALL(cfg,dest,op) do { \
250 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); \
251 (dest)->inst.opcode = (op); \
252 (dest)->inst.dreg = -1; \
253 MONO_INST_NULLIFY_SREGS (&(dest)->inst); \
254 (dest)->inst.cil_code = (cfg)->ip; \
255 } while (0)
256
257 #define MONO_INST_NEW_CALL_ARG(cfg,dest,op) do { \
258 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallArgParm)); \
259 (dest)->ins.opcode = (op); \
260 } while (0)
261
262 #define MONO_ADD_INS(b,inst) do { \
263 if ((b)->last_ins) { \
264 (b)->last_ins->next = (inst); \
265 (inst)->prev = (b)->last_ins; \
266 (b)->last_ins = (inst); \
267 } else { \
268 (b)->code = (b)->last_ins = (inst); \
269 } \
270 } while (0)
271
272 #define NULLIFY_INS(ins) do { \
273 (ins)->opcode = OP_NOP; \
274 (ins)->dreg = -1; \
275 MONO_INST_NULLIFY_SREGS ((ins)); \
276 (ins)->ssa_op = MONO_SSA_NOP; \
277 } while (0)
278
279 /* Remove INS from BB */
280 #define MONO_REMOVE_INS(bb,ins) do { \
281 if ((ins)->prev) \
282 (ins)->prev->next = (ins)->next; \
283 if ((ins)->next) \
284 (ins)->next->prev = (ins)->prev; \
285 if ((bb)->code == (ins)) \
286 (bb)->code = (ins)->next; \
287 if ((bb)->last_ins == (ins)) \
288 (bb)->last_ins = (ins)->prev; \
289 } while (0)
290
291 /* Remove INS from BB and nullify it */
292 #define MONO_DELETE_INS(bb,ins) do { \
293 MONO_REMOVE_INS ((bb), (ins)); \
294 NULLIFY_INS ((ins)); \
295 } while (0)
296
297 /*
298 * this is used to determine when some branch optimizations are possible: we exclude FP compares
299 * because they have weird semantics with NaNs.
300 */
301 #define MONO_IS_COND_BRANCH_OP(ins) (((ins)->opcode >= OP_LBEQ && (ins)->opcode <= OP_LBLT_UN) || ((ins)->opcode >= OP_FBEQ && (ins)->opcode <= OP_FBLT_UN) || ((ins)->opcode >= OP_IBEQ && (ins)->opcode <= OP_IBLT_UN))
302 #define MONO_IS_COND_BRANCH_NOFP(ins) (MONO_IS_COND_BRANCH_OP(ins) && !(((ins)->opcode >= OP_FBEQ) && ((ins)->opcode <= OP_FBLT_UN)) && (!(ins)->inst_left || (ins)->inst_left->inst_left->type != STACK_R8))
303
304 #define MONO_IS_BRANCH_OP(ins) (MONO_IS_COND_BRANCH_OP(ins) || ((ins)->opcode == OP_BR) || ((ins)->opcode == OP_BR_REG) || ((ins)->opcode == OP_SWITCH))
305
306 #define MONO_IS_COND_EXC(ins) ((((ins)->opcode >= OP_COND_EXC_EQ) && ((ins)->opcode <= OP_COND_EXC_LT_UN)) || (((ins)->opcode >= OP_COND_EXC_IEQ) && ((ins)->opcode <= OP_COND_EXC_ILT_UN)))
307
308 #define MONO_IS_SETCC(ins) ((((ins)->opcode >= OP_CEQ) && ((ins)->opcode <= OP_CLT_UN)) || (((ins)->opcode >= OP_ICEQ) && ((ins)->opcode <= OP_ICLT_UN)) || (((ins)->opcode >= OP_LCEQ) && ((ins)->opcode <= OP_LCLT_UN)) || (((ins)->opcode >= OP_FCEQ) && ((ins)->opcode <= OP_FCLT_UN)))
309
310
311 #define MONO_IS_LOAD_MEMBASE(ins) (((ins)->opcode >= OP_LOAD_MEMBASE) && ((ins)->opcode <= OP_LOADV_MEMBASE))
312 #define MONO_IS_STORE_MEMBASE(ins) (((ins)->opcode >= OP_STORE_MEMBASE_REG) && ((ins)->opcode <= OP_STOREV_MEMBASE))
313 #define MONO_IS_STORE_MEMINDEX(ins) (((ins)->opcode >= OP_STORE_MEMINDEX) && ((ins)->opcode <= OP_STORER8_MEMINDEX))
314
315 #define MONO_IS_CALL(ins) (((ins->opcode >= OP_VOIDCALL) && (ins->opcode <= OP_VOIDCALL_MEMBASE)) || ((ins->opcode >= OP_FCALL) && (ins->opcode <= OP_FCALL_MEMBASE)) || ((ins->opcode >= OP_LCALL) && (ins->opcode <= OP_LCALL_MEMBASE)) || ((ins->opcode >= OP_VCALL) && (ins->opcode <= OP_VCALL_MEMBASE)) || ((ins->opcode >= OP_CALL) && (ins->opcode <= OP_CALL_MEMBASE)) || ((ins->opcode >= OP_VCALL2) && (ins->opcode <= OP_VCALL2_MEMBASE)) || (ins->opcode == OP_TAILCALL))
316
317 #define MONO_IS_JUMP_TABLE(ins) (((ins)->opcode == OP_JUMP_TABLE) ? TRUE : ((((ins)->opcode == OP_AOTCONST) && (ins->inst_i1 == (gpointer)MONO_PATCH_INFO_SWITCH)) ? TRUE : ((ins)->opcode == OP_SWITCH) ? TRUE : ((((ins)->opcode == OP_GOT_ENTRY) && ((ins)->inst_right->inst_i1 == (gpointer)MONO_PATCH_INFO_SWITCH)) ? TRUE : FALSE)))
318
319 #define MONO_JUMP_TABLE_FROM_INS(ins) (((ins)->opcode == OP_JUMP_TABLE) ? (ins)->inst_p0 : (((ins)->opcode == OP_AOTCONST) && (ins->inst_i1 == (gpointer)MONO_PATCH_INFO_SWITCH) ? (ins)->inst_p0 : (((ins)->opcode == OP_SWITCH) ? (ins)->inst_p0 : ((((ins)->opcode == OP_GOT_ENTRY) && ((ins)->inst_right->inst_i1 == (gpointer)MONO_PATCH_INFO_SWITCH)) ? (ins)->inst_right->inst_p0 : NULL))))
320
321 /* FIXME: Add more instructions */
322 #define MONO_INS_HAS_NO_SIDE_EFFECT(ins) (MONO_IS_MOVE (ins) || (ins->opcode == OP_ICONST) || (ins->opcode == OP_I8CONST) || MONO_IS_ZERO (ins) || (ins->opcode == OP_ADD_IMM) || (ins->opcode == OP_R8CONST) || (ins->opcode == OP_LADD_IMM) || (ins->opcode == OP_ISUB_IMM) || (ins->opcode == OP_IADD_IMM) || (ins->opcode == OP_INEG) || (ins->opcode == OP_LNEG) || (ins->opcode == OP_ISUB) || (ins->opcode == OP_CMOV_IGE) || (ins->opcode == OP_ISHL_IMM) || (ins->opcode == OP_ISHR_IMM) || (ins->opcode == OP_ISHR_UN_IMM) || (ins->opcode == OP_IAND_IMM) || (ins->opcode == OP_ICONV_TO_U1) || (ins->opcode == OP_ICONV_TO_I1) || (ins->opcode == OP_SEXT_I4) || (ins->opcode == OP_LCONV_TO_U1) || (ins->opcode == OP_ICONV_TO_U2) || (ins->opcode == OP_ICONV_TO_I2) || (ins->opcode == OP_LCONV_TO_I2))
323
324 #define MONO_METHOD_IS_FINAL(m) (((m)->flags & METHOD_ATTRIBUTE_FINAL) || ((m)->klass && ((m)->klass->flags & TYPE_ATTRIBUTE_SEALED)))
325
326
327 #ifdef MONO_ARCH_SIMD_INTRINSICS
328
329 #define MONO_IS_PHI(ins) (((ins)->opcode == OP_PHI) || ((ins)->opcode == OP_FPHI) || ((ins)->opcode == OP_VPHI) || ((ins)->opcode == OP_XPHI))
330 #define MONO_IS_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE) || ((ins)->opcode == OP_VMOVE) || ((ins)->opcode == OP_XMOVE))
331 #define MONO_IS_NON_FP_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_VMOVE) || ((ins)->opcode == OP_XMOVE))
332 #define MONO_IS_REAL_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE) || ((ins)->opcode == OP_XMOVE))
333 #define MONO_IS_ZERO(ins) (((ins)->opcode == OP_VZERO) || ((ins)->opcode == OP_XZERO))
334
335 #define MONO_CLASS_IS_SIMD(cfg, klass) (((cfg)->opt & MONO_OPT_SIMD) && (klass)->simd_type)
336
337 #else
338
339 #define MONO_IS_PHI(ins) (((ins)->opcode == OP_PHI) || ((ins)->opcode == OP_FPHI) || ((ins)->opcode == OP_VPHI))
340 #define MONO_IS_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE) || ((ins)->opcode == OP_VMOVE))
341 #define MONO_IS_NON_FP_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_VMOVE))
342 /*A real MOVE is one that isn't decomposed such as a VMOVE or LMOVE*/
343 #define MONO_IS_REAL_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE))
344 #define MONO_IS_ZERO(ins) ((ins)->opcode == OP_VZERO)
345
346 #define MONO_CLASS_IS_SIMD(cfg, klass) (0)
347
348 #endif
349
350 typedef struct MonoInstList MonoInstList;
351 typedef struct MonoInst MonoInst;
352 typedef struct MonoCallInst MonoCallInst;
353 typedef struct MonoCallArgParm MonoCallArgParm;
354 typedef struct MonoEdge MonoEdge;
355 typedef struct MonoMethodVar MonoMethodVar;
356 typedef struct MonoBasicBlock MonoBasicBlock;
357 typedef struct MonoLMF MonoLMF;
358 typedef struct MonoSpillInfo MonoSpillInfo;
359 typedef struct MonoTraceSpec MonoTraceSpec;
360
361 extern guint32 mono_jit_tls_id;
362 extern MonoTraceSpec *mono_jit_trace_calls;
363 extern gboolean mono_break_on_exc;
364 extern int mono_exc_esp_offset;
365 extern gboolean mono_compile_aot;
366 extern gboolean mono_aot_only;
367 extern gboolean mono_use_imt;
368 extern MonoMethodDesc *mono_inject_async_exc_method;
369 extern int mono_inject_async_exc_pos;
370 extern MonoMethodDesc *mono_break_at_bb_method;
371 extern int mono_break_at_bb_bb_num;
372 extern gboolean check_for_pending_exc;
373 extern gboolean disable_vtypes_in_regs;
374 extern gboolean mono_verify_all;
375 extern gboolean mono_dont_free_global_codeman;
376 extern gboolean mono_do_x86_stack_align;
377 extern const char *mono_build_date;
378 extern gboolean mono_do_signal_chaining;
379
380 #define INS_INFO(opcode) (&ins_info [((opcode) - OP_START - 1) * 4])
381
382 extern const char ins_info[];
383 extern const gint8 ins_sreg_counts [];
384
385 #define mono_inst_get_num_src_registers(ins) (ins_sreg_counts [(ins)->opcode - OP_START - 1])
386 #define mono_inst_get_src_registers(ins, regs) (((regs) [0] = (ins)->sreg1), ((regs) [1] = (ins)->sreg2), ((regs) [2] = (ins)->sreg3), mono_inst_get_num_src_registers ((ins)))
387
388 #define MONO_BB_FOR_EACH_INS(bb, ins) for ((ins) = (bb)->code; (ins); (ins) = (ins)->next)
389
390 #define MONO_BB_FOR_EACH_INS_SAFE(bb, n, ins) for ((ins) = (bb)->code, n = (ins) ? (ins)->next : NULL; (ins); (ins) = (n), (n) = (ins) ? (ins)->next : NULL)
391
392 #define MONO_BB_FOR_EACH_INS_REVERSE_SAFE(bb, p, ins) for ((ins) = (bb)->last_ins, p = (ins) ? (ins)->prev : NULL; (ins); (ins) = (p), (p) = (ins) ? (ins)->prev : NULL)
393
394 #define mono_bb_first_ins(bb) (bb)->code
395
396 struct MonoEdge {
397 MonoEdge *next;
398 MonoBasicBlock *bb;
399 /* add edge type? */
400 };
401
402 struct MonoSpillInfo {
403 int offset;
404 };
405
406 /*
407 * The IR-level extended basic block.
408 *
409 * A basic block can have multiple exits just fine, as long as the point of
410 * 'departure' is the last instruction in the basic block. Extended basic
411 * blocks, on the other hand, may have instructions that leave the block
412 * midstream. The important thing is that they cannot be _entered_
413 * midstream, ie, execution of a basic block (or extened bb) always start
414 * at the beginning of the block, never in the middle.
415 */
416 struct MonoBasicBlock {
417 MonoInst *last_ins;
418
419 /* the next basic block in the order it appears in IL */
420 MonoBasicBlock *next_bb;
421
422 /*
423 * Before instruction selection it is the first tree in the
424 * forest and the first item in the list of trees. After
425 * instruction selection it is the first instruction and the
426 * first item in the list of instructions.
427 */
428 MonoInst *code;
429
430 /* unique block number identification */
431 gint32 block_num;
432
433 gint32 dfn;
434
435 /* Basic blocks: incoming and outgoing counts and pointers */
436 /* Each bb should only appear once in each array */
437 gint16 out_count, in_count;
438 MonoBasicBlock **in_bb;
439 MonoBasicBlock **out_bb;
440
441 /* Points to the start of the CIL code that initiated this BB */
442 unsigned char* cil_code;
443
444 /* Length of the CIL block */
445 gint32 cil_length;
446
447 /* The address of the generated code, used for fixups */
448 int native_offset;
449 int max_offset;
450 int max_length;
451
452 /* Visited and reachable flags */
453 guint32 flags;
454
455 /*
456 * SSA and loop based flags
457 */
458 MonoBitSet *dominators;
459 MonoBitSet *dfrontier;
460 MonoBasicBlock *idom;
461 GSList *dominated;
462 /* fast dominator algorithm */
463 MonoBasicBlock *df_parent, *ancestor, *child, *label;
464 MonoEdge *bucket;
465 int size, sdom, idomn;
466
467 /* loop nesting and recognition */
468 GList *loop_blocks;
469 gint8 nesting;
470 gint8 loop_body_start;
471
472 /*
473 * Whenever the bblock is rarely executed so it should be emitted after
474 * the function epilog.
475 */
476 guint out_of_line : 1;
477 /* Caches the result of uselessness calculation during optimize_branches */
478 guint not_useless : 1;
479 /* Whenever the decompose_array_access_opts () pass needs to process this bblock */
480 guint has_array_access : 1;
481 /* Whenever this bblock is extended, ie. it has branches inside it */
482 guint extended : 1;
483 /* Whenever this bblock contains a OP_JUMP_TABLE instruction */
484 guint has_jump_table : 1;
485 /* Whenever this bblock contains an OP_CALL_HANDLER instruction */
486 guint has_call_handler : 1;
487
488 /* use for liveness analysis */
489 MonoBitSet *gen_set;
490 MonoBitSet *kill_set;
491 MonoBitSet *live_in_set;
492 MonoBitSet *live_out_set;
493
494 /* fields to deal with non-empty stack slots at bb boundary */
495 guint16 out_scount, in_scount;
496 MonoInst **out_stack;
497 MonoInst **in_stack;
498
499 /* we use that to prevent merging of bblocks covered by different clauses*/
500 guint real_offset;
501
502 /*
503 * The region encodes whether the basic block is inside
504 * a finally, catch, filter or none of these.
505 *
506 * If the value is -1, then it is neither finally, catch nor filter
507 *
508 * Otherwise the format is:
509 *
510 * Bits: | 0-3 | 4-7 | 8-31
511 * | | |
512 * | clause-flags | MONO_REGION | clause-index
513 *
514 */
515 guint region;
516
517 /* The current symbolic register number, used in local register allocation. */
518 guint32 max_vreg;
519 };
520
521 /* BBlock flags */
522 enum {
523 BB_VISITED = 1 << 0,
524 BB_REACHABLE = 1 << 1,
525 BB_EXCEPTION_DEAD_OBJ = 1 << 2,
526 BB_EXCEPTION_UNSAFE = 1 << 3,
527 BB_EXCEPTION_HANDLER = 1 << 4
528 };
529
530 typedef struct MonoMemcpyArgs {
531 int size, align;
532 } MonoMemcpyArgs;
533
534 typedef enum {
535 LLVMArgNone,
536 LLVMArgInIReg,
537 LLVMArgInFPReg,
538 LLVMArgVtypeInReg,
539 LLVMArgVtypeByVal,
540 LLVMArgVtypeRetAddr /* On on cinfo->ret */
541 } LLVMArgStorage;
542
543 typedef struct {
544 LLVMArgStorage storage;
545
546 /* Only if storage == ArgValuetypeInReg */
547 LLVMArgStorage pair_storage [2];
548 } LLVMArgInfo;
549
550 typedef struct {
551 LLVMArgInfo ret;
552 /* args [0] is for the this argument if it exists */
553 LLVMArgInfo args [1];
554 } LLVMCallInfo;
555
556 #define MONO_MAX_SRC_REGS 3
557
558 struct MonoInst {
559 guint16 opcode;
560 guint8 type; /* stack type */
561 guint ssa_op : 3;
562 guint8 flags : 5;
563
564 /* used by the register allocator */
565 gint32 dreg, sreg1, sreg2, sreg3;
566
567 MonoInst *next, *prev;
568
569 union {
570 union {
571 MonoInst *src;
572 MonoMethodVar *var;
573 mgreg_t const_val;
574 #if (SIZEOF_REGISTER > SIZEOF_VOID_P) && (G_BYTE_ORDER == G_BIG_ENDIAN)
575 struct {
576 gpointer p[SIZEOF_REGISTER/SIZEOF_VOID_P];
577 } pdata;
578 #else
579 gpointer p;
580 #endif
581 MonoMethod *method;
582 MonoMethodSignature *signature;
583 MonoBasicBlock **many_blocks;
584 MonoBasicBlock *target_block;
585 MonoInst **args;
586 MonoType *vtype;
587 MonoClass *klass;
588 int *phi_args;
589 MonoCallInst *call_inst;
590 } op [2];
591 gint64 i8const;
592 double r8const;
593 } data;
594
595 const unsigned char* cil_code; /* for debugging and bblock splitting */
596
597 /* used mostly by the backend to store additional info it may need */
598 union {
599 gint32 reg3;
600 gint32 arg_info;
601 gint32 size;
602 MonoMemcpyArgs *memcpy_args; /* in OP_MEMSET and OP_MEMCPY */
603 gpointer data;
604 gint shift_amount;
605 gboolean is_pinvoke; /* for variables in the unmanaged marshal format */
606 gboolean record_cast_details; /* For CEE_CASTCLASS */
607 MonoInst *spill_var; /* for OP_ICONV_TO_R8_RAW and OP_FCONV_TO_R8_X */
608 guint16 source_opcode; /*OP_XCONV_R8_TO_I4 needs to know which op was used to do proper widening*/
609 } backend;
610
611 MonoClass *klass;
612 };
613
614 struct MonoCallInst {
615 MonoInst inst;
616 MonoMethodSignature *signature;
617 MonoMethod *method;
618 MonoInst **args;
619 MonoInst *out_args;
620 MonoInst *vret_var;
621 gconstpointer fptr;
622 guint stack_usage;
623 guint virtual : 1;
624 guint tail_call : 1;
625 /* If this is TRUE, 'fptr' points to a MonoJumpInfo instead of an address. */
626 guint fptr_is_patch : 1;
627 /*
628 * If this is true, then the call returns a vtype in a register using the same
629 * calling convention as OP_CALL.
630 */
631 guint vret_in_reg : 1;
632 /* Whenever there is an IMT argument and it is dynamic */
633 guint dynamic_imt_arg : 1;
634 /* Whenever there is an RGCTX argument */
635 guint32 rgctx_reg : 1;
636 regmask_t used_iregs;
637 regmask_t used_fregs;
638 GSList *out_ireg_args;
639 GSList *out_freg_args;
640 #ifdef ENABLE_LLVM
641 LLVMCallInfo *cinfo;
642 #endif
643 };
644
645 struct MonoCallArgParm {
646 MonoInst ins;
647 gint32 size;
648 gint32 offset;
649 gint32 offPrm;
650 };
651
652 /*
653 * flags for MonoInst
654 * Note: some of the values overlap, because they can't appear
655 * in the same MonoInst.
656 */
657 enum {
658 MONO_INST_HAS_METHOD = 1,
659 /* temp local created by a DUP: used only within a BB */
660 MONO_INST_IS_TEMP = 1,
661 MONO_INST_INIT = 1, /* in localloc */
662 MONO_INST_SINGLE_STEP_LOC = 1, /* in SEQ_POINT */
663 MONO_INST_IS_DEAD = 2,
664 MONO_INST_TAILCALL = 4,
665 MONO_INST_VOLATILE = 4,
666 MONO_INST_NOTYPECHECK = 4,
667 MONO_INST_UNALIGNED = 8,
668 MONO_INST_CFOLD_TAKEN = 8, /* On branches */
669 MONO_INST_CFOLD_NOT_TAKEN = 16, /* On branches */
670 MONO_INST_DEFINITION_HAS_SIDE_EFFECTS = 8,
671 /* the address of the variable has been taken */
672 MONO_INST_INDIRECT = 16,
673 MONO_INST_NORANGECHECK = 16,
674 };
675
676 #define inst_c0 data.op[0].const_val
677 #define inst_c1 data.op[1].const_val
678 #define inst_i0 data.op[0].src
679 #define inst_i1 data.op[1].src
680 #if (SIZEOF_REGISTER > SIZEOF_VOID_P) && (G_BYTE_ORDER == G_BIG_ENDIAN)
681 #define inst_p0 data.op[0].pdata.p[SIZEOF_REGISTER/SIZEOF_VOID_P - 1]
682 #define inst_p1 data.op[1].pdata.p[SIZEOF_REGISTER/SIZEOF_VOID_P - 1]
683 #else
684 #define inst_p0 data.op[0].p
685 #define inst_p1 data.op[1].p
686 #endif
687 #define inst_l data.i8const
688 #define inst_r data.r8const
689 #define inst_left data.op[0].src
690 #define inst_right data.op[1].src
691
692 #define inst_newa_len data.op[0].src
693 #define inst_newa_class data.op[1].klass
694
695 #define inst_var data.op[0].var
696 #define inst_vtype data.op[1].vtype
697 /* in branch instructions */
698 #define inst_many_bb data.op[1].many_blocks
699 #define inst_target_bb data.op[0].target_block
700 #define inst_true_bb data.op[1].many_blocks[0]
701 #define inst_false_bb data.op[1].many_blocks[1]
702
703 #define inst_basereg sreg1
704 #define inst_indexreg sreg2
705 #define inst_destbasereg dreg
706 #define inst_offset data.op[0].const_val
707 #define inst_imm data.op[1].const_val
708 #define inst_call data.op[1].call_inst
709
710 #define inst_phi_args data.op[1].phi_args
711
712 /* instruction description for use in regalloc/scheduling */
713 enum {
714 MONO_INST_DEST,
715 MONO_INST_SRC1, /* we depend on the SRCs to be consecutive */
716 MONO_INST_SRC2,
717 MONO_INST_SRC3,
718 MONO_INST_LEN,
719 MONO_INST_CLOB,
720 /* Unused, commented out to reduce the size of the mdesc tables
721 MONO_INST_FLAGS,
722 MONO_INST_COST,
723 MONO_INST_DELAY,
724 MONO_INST_RES,
725 */
726 MONO_INST_MAX
727 };
728
729 typedef union {
730 struct {
731 guint16 tid; /* tree number */
732 guint16 bid; /* block number */
733 } pos ;
734 guint32 abs_pos;
735 } MonoPosition;
736
737 typedef struct {
738 MonoPosition first_use, last_use;
739 } MonoLiveRange;
740
741 typedef struct MonoLiveRange2 MonoLiveRange2;
742
743 struct MonoLiveRange2 {
744 int from, to;
745 MonoLiveRange2 *next;
746 };
747
748 typedef struct {
749 /* List of live ranges sorted by 'from' */
750 MonoLiveRange2 *range;
751 MonoLiveRange2 *last_range;
752 } MonoLiveInterval;
753
754 /*
755 * Additional information about a variable
756 */
757 struct MonoMethodVar {
758 guint idx; /* inside cfg->varinfo, cfg->vars */
759 MonoLiveRange range; /* generated by liveness analysis */
760 MonoLiveInterval *interval; /* generated by liveness analysis */
761 int reg; /* != -1 if allocated into a register */
762 int spill_costs;
763 MonoBitSet *def_in; /* used by SSA */
764 MonoInst *def; /* used by SSA */
765 MonoBasicBlock *def_bb; /* used by SSA */
766 GList *uses; /* used by SSA */
767 char cpstate; /* used by SSA conditional constant propagation */
768 /* The native offsets corresponding to the live range of the variable */
769 gint32 live_range_start, live_range_end;
770 /*
771 * cfg->varinfo [idx]->dreg could be replaced for OP_REGVAR, this contains the
772 * original vreg.
773 */
774 gint32 vreg;
775 };
776
777 typedef struct {
778 gpointer end_of_stack;
779 guint32 stack_size;
780 #if !defined(HAVE_KW_THREAD) || !defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
781 MonoLMF *lmf;
782 #endif
783 MonoLMF *first_lmf;
784 gpointer restore_stack_prot;
785 guint32 handling_stack_ovf;
786 gpointer signal_stack;
787 guint32 signal_stack_size;
788 gpointer stack_ovf_guard_base;
789 guint32 stack_ovf_guard_size;
790 void (*abort_func) (MonoObject *object);
791 /* Used to implement --debug=casts */
792 MonoClass *class_cast_from, *class_cast_to;
793 } MonoJitTlsData;
794
795 typedef enum {
796 #define PATCH_INFO(a,b) MONO_PATCH_INFO_ ## a,
797 #include "patch-info.h"
798 #undef PATCH_INFO
799 MONO_PATCH_INFO_NUM
800 } MonoJumpInfoType;
801
802 /*
803 * We need to store the image which the token refers to along with the token,
804 * since the image might not be the same as the image of the method which
805 * contains the relocation, because of inlining.
806 */
807 typedef struct MonoJumpInfoToken {
808 MonoImage *image;
809 guint32 token;
810 gboolean has_context;
811 MonoGenericContext context;
812 } MonoJumpInfoToken;
813
814 typedef struct MonoJumpInfoBBTable {
815 MonoBasicBlock **table;
816 int table_size;
817 } MonoJumpInfoBBTable;
818
819 typedef struct MonoJumpInfoRgctxEntry MonoJumpInfoRgctxEntry;
820
821 typedef struct MonoJumpInfo MonoJumpInfo;
822 struct MonoJumpInfo {
823 MonoJumpInfo *next;
824 union {
825 int i;
826 guint8 *p;
827 MonoInst *label;
828 } ip;
829
830 MonoJumpInfoType type;
831 union {
832 gconstpointer target;
833 #if SIZEOF_VOID_P == 8
834 gint64 offset;
835 #else
836 int offset;
837 #endif
838 MonoBasicBlock *bb;
839 MonoInst *inst;
840 MonoMethod *method;
841 MonoClass *klass;
842 MonoClassField *field;
843 MonoImage *image;
844 MonoVTable *vtable;
845 const char *name;
846 MonoJumpInfoToken *token;
847 MonoJumpInfoBBTable *table;
848 MonoJumpInfoRgctxEntry *rgctx_entry;
849 } data;
850 };
851
852 /* Contains information describing an rgctx entry */
853 struct MonoJumpInfoRgctxEntry {
854 MonoMethod *method;
855 gboolean in_mrgctx;
856 MonoJumpInfo *data; /* describes the data to be loaded */
857 int info_type;
858 };
859
860 typedef enum {
861 MONO_TRAMPOLINE_JIT,
862 MONO_TRAMPOLINE_JUMP,
863 MONO_TRAMPOLINE_CLASS_INIT,
864 MONO_TRAMPOLINE_GENERIC_CLASS_INIT,
865 MONO_TRAMPOLINE_RGCTX_LAZY_FETCH,
866 MONO_TRAMPOLINE_AOT,
867 MONO_TRAMPOLINE_AOT_PLT,
868 MONO_TRAMPOLINE_DELEGATE,
869 MONO_TRAMPOLINE_RESTORE_STACK_PROT,
870 MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING,
871 MONO_TRAMPOLINE_MONITOR_ENTER,
872 MONO_TRAMPOLINE_MONITOR_EXIT,
873 #ifdef ENABLE_LLVM
874 MONO_TRAMPOLINE_LLVM_VCALL,
875 #endif
876 MONO_TRAMPOLINE_NUM
877 } MonoTrampolineType;
878
879 #define MONO_TRAMPOLINE_TYPE_MUST_RETURN(t) \
880 ((t) == MONO_TRAMPOLINE_CLASS_INIT || \
881 (t) == MONO_TRAMPOLINE_GENERIC_CLASS_INIT || \
882 (t) == MONO_TRAMPOLINE_RESTORE_STACK_PROT || \
883 (t) == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH || \
884 (t) == MONO_TRAMPOLINE_MONITOR_ENTER || \
885 (t) == MONO_TRAMPOLINE_MONITOR_EXIT)
886
887 /* optimization flags */
888 #define OPTFLAG(id,shift,name,descr) MONO_OPT_ ## id = 1 << shift,
889 enum {
890 #include "optflags-def.h"
891 MONO_OPT_LAST
892 };
893
894 /* Bit-fields in the MonoBasicBlock.region */
895 #define MONO_REGION_TRY 0
896 #define MONO_REGION_FINALLY 16
897 #define MONO_REGION_CATCH 32
898 #define MONO_REGION_FAULT 64 /* Currently unused */
899 #define MONO_REGION_FILTER 128
900
901 #define MONO_BBLOCK_IS_IN_REGION(bblock, regtype) (((bblock)->region & (0xf << 4)) == (regtype))
902
903 #define get_vreg_to_inst(cfg, vreg) ((vreg) < (cfg)->vreg_to_inst_len ? (cfg)->vreg_to_inst [(vreg)] : NULL)
904
905 #define vreg_is_volatile(cfg, vreg) (G_UNLIKELY (get_vreg_to_inst ((cfg), (vreg)) && (get_vreg_to_inst ((cfg), (vreg))->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT))))
906
907 /*
908 * Control Flow Graph and compilation unit information
909 */
910 typedef struct {
911 MonoMethod *method;
912 MonoMemPool *mempool;
913 MonoInst **varinfo;
914 MonoMethodVar *vars;
915 MonoInst *ret;
916 MonoBasicBlock *bb_entry;
917 MonoBasicBlock *bb_exit;
918 MonoBasicBlock *bb_init;
919 MonoBasicBlock **bblocks;
920 MonoBasicBlock **cil_offset_to_bb;
921 MonoMemPool *state_pool; /* used by instruction selection */
922 MonoBasicBlock *cbb; /* used by instruction selection */
923 MonoInst *prev_ins; /* in decompose */
924 MonoJumpInfo *patch_info;
925 MonoJitInfo *jit_info;
926 MonoJitDynamicMethodInfo *dynamic_info;
927 guint num_bblocks;
928 guint locals_start;
929 guint num_varinfo; /* used items in varinfo */
930 guint varinfo_count; /* total storage in varinfo */
931 gint stack_offset;
932 gint max_ireg;
933 gint cil_offset_to_bb_len;
934 gint locals_min_stack_offset, locals_max_stack_offset;
935 MonoRegState *rs;
936 MonoSpillInfo *spill_info [16]; /* machine register spills */
937 gint spill_count;
938 gint spill_info_len [16];
939 /* unsigned char *cil_code; */
940 MonoMethod *inlined_method; /* the method which is currently inlined */
941 MonoInst *domainvar; /* a cache for the current domain */
942 MonoInst *got_var; /* Global Offset Table variable */
943 MonoInst **locals;
944 MonoInst *rgctx_var; /* Runtime generic context variable (for static generic methods) */
945 MonoInst **args;
946 MonoType **arg_types;
947 MonoMethod *current_method; /* The method currently processed by method_to_ir () */
948 MonoMethod *method_to_register; /* The method to register in JIT info tables */
949 MonoGenericContext *generic_context;
950
951 /*
952 * This variable represents the hidden argument holding the vtype
953 * return address. If the method returns something other than a vtype, or
954 * the vtype is returned in registers this is NULL.
955 */
956 MonoInst *vret_addr;
957
958 /*
959 * This is used to initialize the cil_code field of MonoInst's.
960 */
961 const unsigned char *ip;
962
963 struct MonoAliasingInformation *aliasing_info;
964
965 /* A hashtable of region ID-> SP var mappings */
966 /* An SP var is a place to store the stack pointer (used by handlers)*/
967 GHashTable *spvars;
968
969 /* A hashtable of region ID -> EX var mappings */
970 /* An EX var stores the exception object passed to catch/filter blocks */
971 GHashTable *exvars;
972
973 GList *ldstr_list; /* used by AOT */
974
975 MonoDomain *domain;
976
977 guint real_offset;
978 GHashTable *cbb_hash;
979
980 /* The current virtual register number */
981 guint32 next_vreg;
982
983 MonoGenericSharingContext *generic_sharing_context;
984
985 unsigned char *cil_start;
986 unsigned char *native_code;
987 guint code_size;
988 guint code_len;
989 guint prolog_end;
990 guint epilog_begin;
991 regmask_t used_int_regs;
992 guint32 opt;
993 guint32 prof_options;
994 guint32 flags;
995 guint32 comp_done;
996 guint32 verbose_level;
997 guint32 stack_usage;
998 guint32 param_area;
999 guint32 frame_reg;
1000 gint32 sig_cookie;
1001 guint disable_aot : 1;
1002 guint disable_ssa : 1;
1003 guint disable_llvm : 1;
1004 guint enable_extended_bblocks : 1;
1005 guint run_cctors : 1;
1006 guint need_lmf_area : 1;
1007 guint compile_aot : 1;
1008 guint compile_llvm : 1;
1009 guint got_var_allocated : 1;
1010 guint ret_var_is_local : 1;
1011 guint ret_var_set : 1;
1012 guint globalra : 1;
1013 guint unverifiable : 1;
1014 guint skip_visibility : 1;
1015 guint disable_reuse_registers : 1;
1016 guint disable_reuse_stack_slots : 1;
1017 guint disable_initlocals_opt : 1;
1018 guint disable_omit_fp : 1;
1019 guint disable_vreg_to_lvreg : 1;
1020 guint disable_deadce_vars : 1;
1021 guint extend_live_ranges : 1;
1022 guint has_got_slots : 1;
1023 guint uses_rgctx_reg : 1;
1024 guint uses_vtable_reg : 1;
1025 guint uses_simd_intrinsics : 1;
1026 guint keep_cil_nops : 1;
1027 guint gen_seq_points : 1;
1028 gpointer debug_info;
1029 guint32 lmf_offset;
1030 guint16 *intvars;
1031 MonoProfileCoverageInfo *coverage_info;
1032 GHashTable *token_info_hash;
1033 MonoCompileArch arch;
1034 guint32 inline_depth;
1035 guint32 exception_type; /* MONO_EXCEPTION_* */
1036 guint32 exception_data;
1037 char* exception_message;
1038 gpointer exception_ptr;
1039
1040 guint8 * encoded_unwind_ops;
1041 guint32 encoded_unwind_ops_len;
1042 GSList* unwind_ops;
1043
1044 /* Fields used by the local reg allocator */
1045 void* reginfo;
1046 int reginfo_len;
1047
1048 /* Maps vregs to their associated MonoInst's */
1049 /* vregs with an associated MonoInst are 'global' while others are 'local' */
1050 MonoInst **vreg_to_inst;
1051
1052 /* Size of above array */
1053 guint32 vreg_to_inst_len;
1054
1055 /*
1056 * The original method to compile, differs from 'method' when doing generic
1057 * sharing.
1058 */
1059 MonoMethod *orig_method;
1060
1061 /* Patches which describe absolute addresses embedded into the native code */
1062 GHashTable *abs_patches;
1063
1064 /* If the arch passes valuetypes by address, then for methods
1065 which use JMP the arch code should use these local
1066 variables to store the addresses of incoming valuetypes.
1067 The addresses should be stored in mono_arch_emit_prolog()
1068 and can be used when emitting code for OP_JMP. See
1069 mini-ppc.c. */
1070 MonoInst **tailcall_valuetype_addrs;
1071
1072 /* Used to implement iconv_to_r8_raw on archs that can't do raw
1073 copy between an ireg and a freg. This is an int32 var.*/
1074 MonoInst *iconv_raw_var;
1075
1076 /* Used to implement fconv_to_r8_x. This is a double (8 bytes) var.*/
1077 MonoInst *fconv_to_r8_x_var;
1078
1079 /*Use to implement simd constructors. This is a vector (16 bytes) var.*/
1080 MonoInst *simd_ctor_var;
1081
1082 /* Used to implement dyn_call */
1083 MonoInst *dyn_call_var;
1084
1085 /*
1086 * List of sequence points represented as IL offset+native offset pairs.
1087 * Allocated using glib.
1088 * IL offset can be -1 or 0xffffff to refer to the sequence points
1089 * inside the prolog and epilog used to implement method entry/exit events.
1090 */
1091 GPtrArray *seq_points;
1092
1093 /* Used by AOT */
1094 guint32 got_offset;
1095 } MonoCompile;
1096
1097 typedef enum {
1098 MONO_CFG_HAS_ALLOCA = 1 << 0,
1099 MONO_CFG_HAS_CALLS = 1 << 1,
1100 MONO_CFG_HAS_LDELEMA = 1 << 2,
1101 MONO_CFG_HAS_VARARGS = 1 << 3,
1102 MONO_CFG_HAS_TAIL = 1 << 4,
1103 MONO_CFG_HAS_FPOUT = 1 << 5, /* there are fp values passed in int registers */
1104 MONO_CFG_HAS_SPILLUP = 1 << 6, /* spill var slots are allocated from bottom to top */
1105 MONO_CFG_HAS_CHECK_THIS = 1 << 7,
1106 MONO_CFG_HAS_ARRAY_ACCESS = 1 << 8
1107 } MonoCompileFlags;
1108
1109 typedef struct {
1110 gulong methods_compiled;
1111 gulong methods_aot;
1112 gulong methods_lookups;
1113 gulong method_trampolines;
1114 gulong allocate_var;
1115 gulong cil_code_size;
1116 gulong native_code_size;
1117 gulong code_reallocs;
1118 gulong max_code_size_ratio;
1119 gulong biggest_method_size;
1120 gulong allocated_code_size;
1121 gulong inlineable_methods;
1122 gulong inlined_methods;
1123 gulong basic_blocks;
1124 gulong max_basic_blocks;
1125 gulong locals_stack_size;
1126 gulong regvars;
1127 gulong cas_declsec_check;
1128 gulong cas_linkdemand_icall;
1129 gulong cas_linkdemand_pinvoke;
1130 gulong cas_linkdemand_aptc;
1131 gulong cas_linkdemand;
1132 gulong cas_demand_generation;
1133 gulong generic_virtual_invocations;
1134 char *max_ratio_method;
1135 char *biggest_method;
1136 gboolean enabled;
1137 } MonoJitStats;
1138
1139 extern MonoJitStats mono_jit_stats;
1140
1141 /* values for MonoInst.ssa_op */
1142 enum {
1143 MONO_SSA_NOP = 0,
1144 MONO_SSA_ADDRESS_TAKEN = 1,
1145 MONO_SSA_LOAD = 2,
1146 MONO_SSA_STORE = 4,
1147 MONO_SSA_LOAD_STORE = MONO_SSA_LOAD|MONO_SSA_STORE,
1148 MONO_SSA_INDIRECT_LOAD = MONO_SSA_LOAD|MONO_SSA_ADDRESS_TAKEN,
1149 MONO_SSA_INDIRECT_STORE = MONO_SSA_STORE|MONO_SSA_ADDRESS_TAKEN,
1150 MONO_SSA_INDIRECT_LOAD_STORE =
1151 MONO_SSA_LOAD|MONO_SSA_STORE|MONO_SSA_ADDRESS_TAKEN
1152 };
1153
1154 /* opcodes: value assigned after all the CIL opcodes */
1155 #ifdef MINI_OP
1156 #undef MINI_OP
1157 #endif
1158 #ifdef MINI_OP3
1159 #undef MINI_OP3
1160 #endif
1161 #define MINI_OP(a,b,dest,src1,src2) a,
1162 #define MINI_OP3(a,b,dest,src1,src2,src3) a,
1163 enum {
1164 OP_START = MONO_CEE_LAST - 1,
1165 #include "mini-ops.h"
1166 OP_LAST
1167 };
1168 #undef MINI_OP
1169 #undef MINI_OP3
1170
1171 #if SIZEOF_VOID_P == 8
1172 #define OP_PCONST OP_I8CONST
1173 #define OP_PADD OP_LADD
1174 #define OP_PADD_IMM OP_LADD_IMM
1175 #define OP_PSUB OP_LSUB
1176 #define OP_PMUL OP_LMUL
1177 #define OP_PMUL_IMM OP_LMUL_IMM
1178 #define OP_PNEG OP_LNEG
1179 #define OP_PCONV_TO_I1 OP_LCONV_TO_I1
1180 #define OP_PCONV_TO_U1 OP_LCONV_TO_U1
1181 #define OP_PCONV_TO_I2 OP_LCONV_TO_I2
1182 #define OP_PCONV_TO_U2 OP_LCONV_TO_U2
1183 #define OP_PCONV_TO_OVF_I1_UN OP_LCONV_TO_OVF_I1_UN
1184 #define OP_PCONV_TO_OVF_I1 OP_LCONV_TO_OVF_I1
1185 #define OP_PBEQ OP_LBEQ
1186 #define OP_PCEQ OP_LCEQ
1187 #define OP_PBNE_UN OP_LBNE_UN
1188 #define OP_PBGE_UN OP_LBGE_UN
1189 #define OP_PBLT_UN OP_LBLT_UN
1190 #define OP_PBGE OP_LBGE
1191 #define OP_STOREP_MEMBASE_REG OP_STOREI8_MEMBASE_REG
1192 #define OP_STOREP_MEMBASE_IMM OP_STOREI8_MEMBASE_IMM
1193 #else
1194 #define OP_PCONST OP_ICONST
1195 #define OP_PADD OP_IADD
1196 #define OP_PADD_IMM OP_IADD_IMM
1197 #define OP_PSUB OP_ISUB
1198 #define OP_PMUL OP_IMUL
1199 #define OP_PMUL_IMM OP_IMUL_IMM
1200 #define OP_PNEG OP_INEG
1201 #define OP_PCONV_TO_I1 OP_ICONV_TO_I1
1202 #define OP_PCONV_TO_U1 OP_ICONV_TO_U1
1203 #define OP_PCONV_TO_I2 OP_ICONV_TO_I2
1204 #define OP_PCONV_TO_U2 OP_ICONV_TO_U2
1205 #define OP_PCONV_TO_OVF_I1_UN OP_ICONV_TO_OVF_I1_UN
1206 #define OP_PCONV_TO_OVF_I1 OP_ICONV_TO_OVF_I1
1207 #define OP_PBEQ OP_IBEQ
1208 #define OP_PCEQ OP_ICEQ
1209 #define OP_PBNE_UN OP_IBNE_UN
1210 #define OP_PBGE_UN OP_IBGE_UN
1211 #define OP_PBLT_UN OP_IBLT_UN
1212 #define OP_PBGE OP_IBGE
1213 #define OP_STOREP_MEMBASE_REG OP_STOREI4_MEMBASE_REG
1214 #define OP_STOREP_MEMBASE_IMM OP_STOREI4_MEMBASE_IMM
1215 #endif
1216
1217 /* Opcodes to load/store regsize quantities */
1218 #ifdef __mono_ilp32__
1219 #define OP_LOADR_MEMBASE OP_LOADI8_MEMBASE
1220 #define OP_STORER_MEMBASE_REG OP_STOREI8_MEMBASE_REG
1221 #else
1222 #define OP_LOADR_MEMBASE OP_LOAD_MEMBASE
1223 #define OP_STORER_MEMBASE_REG OP_STORE_MEMBASE_REG
1224 #endif
1225
1226 typedef enum {
1227 STACK_INV,
1228 STACK_I4,
1229 STACK_I8,
1230 STACK_PTR,
1231 STACK_R8,
1232 STACK_MP,
1233 STACK_OBJ,
1234 STACK_VTYPE,
1235 STACK_MAX
1236 } MonoStackType;
1237
1238 typedef struct {
1239 union {
1240 double r8;
1241 gint32 i4;
1242 gint64 i8;
1243 gpointer p;
1244 MonoClass *klass;
1245 } data;
1246 int type;
1247 } StackSlot;
1248
1249 #if HAVE_ARRAY_ELEM_INIT
1250 extern const guint8 mono_burg_arity [];
1251 #else
1252 extern guint8 mono_burg_arity [];
1253 #endif
1254
1255 extern const char MONO_ARCH_CPU_SPEC [] MONO_INTERNAL;
1256 #define MONO_ARCH_CPU_SPEC_IDX_COMBINE(a) a ## _idx
1257 #define MONO_ARCH_CPU_SPEC_IDX(a) MONO_ARCH_CPU_SPEC_IDX_COMBINE(a)
1258 extern const guint16 MONO_ARCH_CPU_SPEC_IDX(MONO_ARCH_CPU_SPEC) [] MONO_INTERNAL;
1259 #define ins_get_spec(op) ((const char*)&MONO_ARCH_CPU_SPEC + MONO_ARCH_CPU_SPEC_IDX(MONO_ARCH_CPU_SPEC)[(op) - OP_LOAD])
1260
1261 enum {
1262 MONO_COMP_DOM = 1,
1263 MONO_COMP_IDOM = 2,
1264 MONO_COMP_DFRONTIER = 4,
1265 MONO_COMP_DOM_REV = 8,
1266 MONO_COMP_LIVENESS = 16,
1267 MONO_COMP_SSA = 32,
1268 MONO_COMP_SSA_DEF_USE = 64,
1269 MONO_COMP_REACHABILITY = 128,
1270 MONO_COMP_LOOPS = 256
1271 };
1272
1273 typedef enum {
1274 MONO_GRAPH_CFG = 1,
1275 MONO_GRAPH_DTREE = 2,
1276 MONO_GRAPH_CFG_CODE = 4,
1277 MONO_GRAPH_CFG_SSA = 8,
1278 MONO_GRAPH_CFG_OPTCODE = 16
1279 } MonoGraphOptions;
1280
1281 typedef struct {
1282 guint16 size;
1283 guint16 offset;
1284 guint8 pad;
1285 } MonoJitArgumentInfo;
1286
1287 typedef struct {
1288 gboolean handle_sigint;
1289 gboolean keep_delegates;
1290 gboolean collect_pagefault_stats;
1291 gboolean break_on_unverified;
1292 gboolean better_cast_details;
1293 gboolean mdb_optimizations;
1294 gboolean no_gdb_backtrace;
1295 gboolean suspend_on_sigsegv;
1296 gboolean dyn_runtime_invoke;
1297 gboolean gdb;
1298 gboolean gen_seq_points;
1299 } MonoDebugOptions;
1300
1301 enum {
1302 BRANCH_NOT_TAKEN,
1303 BRANCH_TAKEN,
1304 BRANCH_UNDEF
1305 };
1306
1307 typedef enum {
1308 CMP_EQ,
1309 CMP_NE,
1310 CMP_LE,
1311 CMP_GE,
1312 CMP_LT,
1313 CMP_GT,
1314 CMP_LE_UN,
1315 CMP_GE_UN,
1316 CMP_LT_UN,
1317 CMP_GT_UN
1318 } CompRelation;
1319
1320 typedef enum {
1321 CMP_TYPE_L,
1322 CMP_TYPE_I,
1323 CMP_TYPE_F
1324 } CompType;
1325
1326 /* Implicit exceptions */
1327 enum {
1328 MONO_EXC_INDEX_OUT_OF_RANGE,
1329 MONO_EXC_OVERFLOW,
1330 MONO_EXC_ARITHMETIC,
1331 MONO_EXC_DIVIDE_BY_ZERO,
1332 MONO_EXC_INVALID_CAST,
1333 MONO_EXC_NULL_REF,
1334 MONO_EXC_ARRAY_TYPE_MISMATCH,
1335 MONO_EXC_INTRINS_NUM
1336 };
1337
1338 enum {
1339 MINI_TOKEN_SOURCE_CLASS,
1340 MINI_TOKEN_SOURCE_METHOD,
1341 MINI_TOKEN_SOURCE_FIELD
1342 };
1343
1344 /*
1345 * This structures contains information about a trampoline function required by
1346 * the AOT compiler in full-aot mode.
1347 */
1348 typedef struct
1349 {
1350 guint8 *code;
1351 guint32 code_size;
1352 char *name;
1353 } MonoAotTrampInfo;
1354
1355 typedef void (*MonoInstFunc) (MonoInst *tree, gpointer data);
1356
1357 /* main function */
1358 int mono_main (int argc, char* argv[]);
1359 void mono_set_defaults (int verbose_level, guint32 opts);
1360 MonoDomain* mini_init (const char *filename, const char *runtime_version) MONO_INTERNAL;
1361 void mini_cleanup (MonoDomain *domain) MONO_INTERNAL;
1362 MonoDebugOptions *mini_get_debug_options (void) MONO_INTERNAL;
1363 char* mono_get_runtime_build_info (void) MONO_INTERNAL;
1364
1365 /* helper methods */
1366 void mono_disable_optimizations (guint32 opts) MONO_INTERNAL;
1367 MonoJumpInfoToken* mono_jump_info_token_new (MonoMemPool *mp, MonoImage *image, guint32 token) MONO_INTERNAL;
1368 MonoJumpInfoToken* mono_jump_info_token_new2 (MonoMemPool *mp, MonoImage *image, guint32 token, MonoGenericContext *context) MONO_INTERNAL;
1369 MonoInst* mono_find_spvar_for_region (MonoCompile *cfg, int region) MONO_INTERNAL;
1370 void mono_precompile_assemblies (void) MONO_INTERNAL;
1371 int mono_parse_default_optimizations (const char* p);
1372 void mono_bblock_add_inst (MonoBasicBlock *bb, MonoInst *inst) MONO_INTERNAL;
1373 void mono_bblock_insert_after_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) MONO_INTERNAL;
1374 void mono_bblock_insert_before_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) MONO_INTERNAL;
1375 void mono_verify_bblock (MonoBasicBlock *bb) MONO_INTERNAL;
1376 void mono_verify_cfg (MonoCompile *cfg) MONO_INTERNAL;
1377 void mono_constant_fold (MonoCompile *cfg) MONO_INTERNAL;
1378 MonoInst* mono_constant_fold_ins (MonoCompile *cfg, MonoInst *ins, MonoInst *arg1, MonoInst *arg2, gboolean overwrite) MONO_INTERNAL;
1379 int mono_eval_cond_branch (MonoInst *branch) MONO_INTERNAL;
1380 int mono_is_power_of_two (guint32 val) MONO_INTERNAL;
1381 void mono_cprop_local (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst **acp, int acp_size) MONO_INTERNAL;
1382 MonoInst* mono_compile_create_var (MonoCompile *cfg, MonoType *type, int opcode) MONO_INTERNAL;
1383 MonoInst* mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, int vreg) MONO_INTERNAL;
1384 void mono_compile_make_var_load (MonoCompile *cfg, MonoInst *dest, gssize var_index) MONO_INTERNAL;
1385 MonoInst* mono_compile_create_var_load (MonoCompile *cfg, gssize var_index) MONO_INTERNAL;
1386 MonoInst* mono_compile_create_var_store (MonoCompile *cfg, gssize var_index, MonoInst *value) MONO_INTERNAL;
1387 MonoType* mono_type_from_stack_type (MonoInst *ins) MONO_INTERNAL;
1388 guint32 mono_alloc_ireg (MonoCompile *cfg) MONO_INTERNAL;
1389 guint32 mono_alloc_freg (MonoCompile *cfg) MONO_INTERNAL;
1390 guint32 mono_alloc_preg (MonoCompile *cfg) MONO_INTERNAL;
1391 guint32 mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type) MONO_INTERNAL;
1392
1393 void mono_link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to) MONO_INTERNAL;
1394 void mono_unlink_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to) MONO_INTERNAL;
1395 gboolean mono_bblocks_linked (MonoBasicBlock *bb1, MonoBasicBlock *bb2) MONO_INTERNAL;
1396 void mono_remove_bblock (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1397 void mono_nullify_basic_block (MonoBasicBlock *bb) MONO_INTERNAL;
1398 void mono_merge_basic_blocks (MonoCompile *cfg, MonoBasicBlock *bb, MonoBasicBlock *bbn) MONO_INTERNAL;
1399 void mono_optimize_branches (MonoCompile *cfg) MONO_INTERNAL;
1400
1401 void mono_blockset_print (MonoCompile *cfg, MonoBitSet *set, const char *name, guint idom) MONO_INTERNAL;
1402 void mono_print_ins_index (int i, MonoInst *ins) MONO_INTERNAL;
1403 void mono_print_ins (MonoInst *ins) MONO_INTERNAL;
1404 void mono_print_bb (MonoBasicBlock *bb, const char *msg) MONO_INTERNAL;
1405 void mono_print_code (MonoCompile *cfg, const char *msg) MONO_INTERNAL;
1406 void mono_print_method_from_ip (void *ip);
1407 char *mono_pmip (void *ip);
1408 const char* mono_inst_name (int op);
1409 void mono_inst_set_src_registers (MonoInst *ins, int *regs) MONO_INTERNAL;
1410 int mono_op_to_op_imm (int opcode) MONO_INTERNAL;
1411 int mono_op_imm_to_op (int opcode) MONO_INTERNAL;
1412 int mono_load_membase_to_load_mem (int opcode) MONO_INTERNAL;
1413 guint mono_type_to_load_membase (MonoCompile *cfg, MonoType *type) MONO_INTERNAL;
1414 guint mono_type_to_store_membase (MonoCompile *cfg, MonoType *type) MONO_INTERNAL;
1415 guint mini_type_to_stind (MonoCompile* cfg, MonoType *type) MONO_INTERNAL;
1416 guint32 mono_reverse_branch_op (guint32 opcode) MONO_INTERNAL;
1417 void mono_disassemble_code (MonoCompile *cfg, guint8 *code, int size, char *id) MONO_INTERNAL;
1418 void mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target) MONO_INTERNAL;
1419 void mono_remove_patch_info (MonoCompile *cfg, int ip) MONO_INTERNAL;
1420 MonoJumpInfo* mono_patch_info_dup_mp (MonoMemPool *mp, MonoJumpInfo *patch_info) MONO_INTERNAL;
1421 guint mono_patch_info_hash (gconstpointer data) MONO_INTERNAL;
1422 gint mono_patch_info_equal (gconstpointer ka, gconstpointer kb) MONO_INTERNAL;
1423 MonoJumpInfo *mono_patch_info_list_prepend (MonoJumpInfo *list, int ip, MonoJumpInfoType type, gconstpointer target) MONO_INTERNAL;
1424 gpointer mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *patch_info, gboolean run_cctors) MONO_INTERNAL;
1425 gpointer mono_jit_find_compiled_method_with_jit_info (MonoDomain *domain, MonoMethod *method, MonoJitInfo **ji) MONO_INTERNAL;
1426 gpointer mono_jit_find_compiled_method (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
1427 gpointer mono_jit_compile_method (MonoMethod *method) MONO_INTERNAL;
1428 MonoLMF * mono_get_lmf (void) MONO_INTERNAL;
1429 MonoLMF** mono_get_lmf_addr (void) MONO_INTERNAL;
1430 void mono_set_lmf (MonoLMF *lmf) MONO_INTERNAL;
1431 void mono_jit_thread_attach (MonoDomain *domain);
1432 guint32 mono_get_jit_tls_key (void) MONO_INTERNAL;
1433 gint32 mono_get_jit_tls_offset (void) MONO_INTERNAL;
1434 gint32 mono_get_lmf_tls_offset (void) MONO_INTERNAL;
1435 gint32 mono_get_lmf_addr_tls_offset (void) MONO_INTERNAL;
1436 MonoInst* mono_get_jit_tls_intrinsic (MonoCompile *cfg) MONO_INTERNAL;
1437 MonoInst* mono_get_domain_intrinsic (MonoCompile* cfg) MONO_INTERNAL;
1438 MonoInst* mono_get_thread_intrinsic (MonoCompile* cfg) MONO_INTERNAL;
1439 GList *mono_varlist_insert_sorted (MonoCompile *cfg, GList *list, MonoMethodVar *mv, gboolean sort_end) MONO_INTERNAL;
1440 GList *mono_varlist_sort (MonoCompile *cfg, GList *list, int sort_type) MONO_INTERNAL;
1441 void mono_analyze_liveness (MonoCompile *cfg) MONO_INTERNAL;
1442 void mono_linear_scan (MonoCompile *cfg, GList *vars, GList *regs, regmask_t *used_mask) MONO_INTERNAL;
1443 void mono_global_regalloc (MonoCompile *cfg) MONO_INTERNAL;
1444 void mono_create_jump_table (MonoCompile *cfg, MonoInst *label, MonoBasicBlock **bbs, int num_blocks) MONO_INTERNAL;
1445 int mono_compile_assembly (MonoAssembly *ass, guint32 opts, const char *aot_options) MONO_INTERNAL;
1446 MonoCompile *mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gboolean run_cctors, gboolean compile_aot, int parts) MONO_INTERNAL;
1447 void mono_destroy_compile (MonoCompile *cfg) MONO_INTERNAL;
1448 MonoJitICallInfo *mono_find_jit_opcode_emulation (int opcode) MONO_INTERNAL;
1449 void mono_print_ins_index (int i, MonoInst *ins) MONO_INTERNAL;
1450 void mono_print_ins (MonoInst *ins) MONO_INTERNAL;
1451 gboolean mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
1452 gboolean mini_method_verify (MonoCompile *cfg, MonoMethod *method) MONO_INTERNAL;
1453 MonoInst *mono_get_got_var (MonoCompile *cfg) MONO_INTERNAL;
1454
1455 gboolean mini_class_is_system_array (MonoClass *klass) MONO_INTERNAL;
1456 MonoMethodSignature *mono_get_element_address_signature (int arity) MONO_INTERNAL;
1457 MonoJitICallInfo *mono_get_element_address_icall (int rank) MONO_INTERNAL;
1458 MonoJitICallInfo *mono_get_array_new_va_icall (int rank) MONO_INTERNAL;
1459
1460 void mono_linterval_add_range (MonoCompile *cfg, MonoLiveInterval *interval, int from, int to) MONO_INTERNAL;
1461 void mono_linterval_print (MonoLiveInterval *interval) MONO_INTERNAL;
1462 void mono_linterval_print_nl (MonoLiveInterval *interval) MONO_INTERNAL;
1463 gboolean mono_linterval_covers (MonoLiveInterval *interval, int pos) MONO_INTERNAL;
1464 gint32 mono_linterval_get_intersect_pos (MonoLiveInterval *i1, MonoLiveInterval *i2) MONO_INTERNAL;
1465 void mono_linterval_split (MonoCompile *cfg, MonoLiveInterval *interval, MonoLiveInterval **i1, MonoLiveInterval **i2, int pos) MONO_INTERNAL;
1466 void mono_liveness_handle_exception_clauses (MonoCompile *cfg) MONO_INTERNAL;
1467
1468 /* AOT */
1469 void mono_aot_init (void) MONO_INTERNAL;
1470 gpointer mono_aot_get_method (MonoDomain *domain,
1471 MonoMethod *method) MONO_INTERNAL;
1472 gpointer mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token) MONO_INTERNAL;
1473 gboolean mono_aot_is_got_entry (guint8 *code, guint8 *addr) MONO_INTERNAL;
1474 guint8* mono_aot_get_plt_entry (guint8 *code) MONO_INTERNAL;
1475 guint32 mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
1476 gboolean mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) MONO_INTERNAL;
1477 gboolean mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass) MONO_INTERNAL;
1478 MonoJitInfo* mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) MONO_INTERNAL;
1479 gpointer mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code) MONO_INTERNAL;
1480 gpointer mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot) MONO_INTERNAL;
1481 gpointer mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
1482 gpointer mono_aot_get_named_code (const char *name) MONO_INTERNAL;
1483 gpointer mono_aot_get_unbox_trampoline (MonoMethod *method) MONO_INTERNAL;
1484 gpointer mono_aot_get_lazy_fetch_trampoline (guint32 slot) MONO_INTERNAL;
1485 gpointer mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr) MONO_INTERNAL;
1486 gpointer mono_aot_get_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) MONO_INTERNAL;
1487 guint8* mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) MONO_INTERNAL;
1488 guint32 mono_aot_method_hash (MonoMethod *method) MONO_INTERNAL;
1489 char* mono_aot_wrapper_name (MonoMethod *method) MONO_INTERNAL;
1490 MonoAotTrampInfo* mono_aot_tramp_info_create (const char *name, guint8 *code, guint32 code_len) MONO_INTERNAL;
1491 guint mono_aot_str_hash (gconstpointer v1) MONO_INTERNAL;
1492 MonoMethod* mono_aot_get_array_helper_from_wrapper (MonoMethod *method) MONO_INTERNAL;
1493
1494 /* This is an exported function */
1495 void mono_aot_register_globals (gpointer *globals);
1496 /* This too */
1497 void mono_aot_register_module (gpointer *aot_info);
1498
1499 void mono_xdebug_init (char *xdebug_opts) MONO_INTERNAL;
1500 void mono_save_xdebug_info (MonoCompile *cfg) MONO_INTERNAL;
1501 void mono_save_trampoline_xdebug_info (const char *tramp_name, guint8 *code, guint32 code_size, GSList *unwind_info) MONO_INTERNAL;
1502 /* This is an exported function */
1503 void mono_xdebug_emit (void) MONO_INTERNAL;
1504
1505 /* LLVM backend */
1506 void mono_llvm_init (void) MONO_INTERNAL;
1507 void mono_llvm_cleanup (void) MONO_INTERNAL;
1508 void mono_llvm_emit_method (MonoCompile *cfg) MONO_INTERNAL;
1509 void mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_INTERNAL;
1510
1511 gboolean mono_method_blittable (MonoMethod *method) MONO_INTERNAL;
1512 gboolean mono_method_same_domain (MonoJitInfo *caller, MonoJitInfo *callee) MONO_INTERNAL;
1513
1514 void mono_register_opcode_emulation (int opcode, const char* name, const char *sigstr, gpointer func, gboolean no_throw) MONO_INTERNAL;
1515 void mono_draw_graph (MonoCompile *cfg, MonoGraphOptions draw_options) MONO_INTERNAL;
1516 void mono_add_ins_to_end (MonoBasicBlock *bb, MonoInst *inst) MONO_INTERNAL;
1517 gpointer mono_create_ftnptr (MonoDomain *domain, gpointer addr) MONO_INTERNAL;
1518
1519 void mono_replace_ins (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, MonoInst **prev, MonoBasicBlock *first_bb, MonoBasicBlock *last_bb);
1520
1521 int mono_find_method_opcode (MonoMethod *method) MONO_INTERNAL;
1522 MonoJitICallInfo *mono_find_jit_icall_by_name (const char *name) MONO_INTERNAL;
1523 MonoJitICallInfo *mono_find_jit_icall_by_addr (gconstpointer addr) MONO_INTERNAL;
1524 MonoJitICallInfo *mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL;
1525 gconstpointer mono_icall_get_wrapper (MonoJitICallInfo* callinfo) MONO_INTERNAL;
1526
1527 void mono_trampolines_init (void) MONO_INTERNAL;
1528 void mono_trampolines_cleanup (void) MONO_INTERNAL;
1529 guint8 * mono_get_trampoline_code (MonoTrampolineType tramp_type) MONO_INTERNAL;
1530 gpointer mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
1531 gpointer mono_create_jump_trampoline (MonoDomain *domain,
1532 MonoMethod *method,
1533 gboolean add_sync_wrapper) MONO_INTERNAL;
1534 gpointer mono_create_class_init_trampoline (MonoVTable *vtable) MONO_INTERNAL;
1535 gpointer mono_create_generic_class_init_trampoline (void) MONO_INTERNAL;
1536 gpointer mono_create_jit_trampoline (MonoMethod *method) MONO_INTERNAL;
1537 gpointer mono_create_jit_trampoline_from_token (MonoImage *image, guint32 token) MONO_INTERNAL;
1538 gpointer mono_create_jit_trampoline_in_domain (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
1539 gpointer mono_create_delegate_trampoline (MonoClass *klass) MONO_INTERNAL;
1540 gpointer mono_create_rgctx_lazy_fetch_trampoline (guint32 offset) MONO_INTERNAL;
1541 gpointer mono_create_monitor_enter_trampoline (void) MONO_INTERNAL;
1542 gpointer mono_create_monitor_exit_trampoline (void) MONO_INTERNAL;
1543 gpointer mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) MONO_INTERNAL;
1544 gpointer mono_create_llvm_vcall_trampoline (MonoMethod *method) MONO_INTERNAL;
1545 gpointer mono_create_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset) MONO_INTERNAL;
1546 MonoVTable* mono_find_class_init_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL;
1547 guint32 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL;
1548 gpointer mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp) MONO_INTERNAL;
1549 gpointer mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp) MONO_INTERNAL;
1550 gpointer mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
1551 gpointer mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
1552 guint8* tramp) MONO_INTERNAL;
1553 gpointer mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
1554 guint8* tramp) MONO_INTERNAL;
1555 void mono_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
1556 void mono_generic_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
1557 void mono_monitor_enter_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
1558 void mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
1559 gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type);
1560 gpointer mini_get_vtable_trampoline (void) MONO_INTERNAL;
1561 gpointer* mono_get_vcall_slot_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL;
1562
1563 gboolean mono_running_on_valgrind (void) MONO_INTERNAL;
1564 void* mono_global_codeman_reserve (int size) MONO_INTERNAL;
1565 const char *mono_regname_full (int reg, int bank) MONO_INTERNAL;
1566 gint32* mono_allocate_stack_slots_full (MonoCompile *cfg, gboolean backward, guint32 *stack_size, guint32 *stack_align) MONO_INTERNAL;
1567 gint32* mono_allocate_stack_slots (MonoCompile *cfg, guint32 *stack_size, guint32 *stack_align) MONO_INTERNAL;
1568 void mono_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1569 MonoInst *mono_branch_optimize_exception_target (MonoCompile *cfg, MonoBasicBlock *bb, const char * exname) MONO_INTERNAL;
1570 void mono_remove_critical_edges (MonoCompile *cfg) MONO_INTERNAL;
1571 gboolean mono_is_regsize_var (MonoType *t) MONO_INTERNAL;
1572 void mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align) MONO_INTERNAL;
1573 CompRelation mono_opcode_to_cond (int opcode) MONO_INTERNAL;
1574 CompType mono_opcode_to_type (int opcode, int cmp_opcode) MONO_INTERNAL;
1575 CompRelation mono_negate_cond (CompRelation cond) MONO_INTERNAL;
1576 int mono_op_imm_to_op (int opcode) MONO_INTERNAL;
1577 void mono_decompose_op_imm (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins) MONO_INTERNAL;
1578 void mono_peephole_ins (MonoBasicBlock *bb, MonoInst *ins) MONO_INTERNAL;
1579 MonoUnwindOp *mono_create_unwind_op (int when,
1580 int tag, int reg,
1581 int val) MONO_INTERNAL;
1582 void mono_emit_unwind_op (MonoCompile *cfg, int when,
1583 int tag, int reg,
1584 int val) MONO_INTERNAL;
1585
1586 int mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
1587 MonoInst *return_var, GList *dont_inline, MonoInst **inline_args,
1588 guint inline_offset, gboolean is_virtual_call) MONO_INTERNAL;
1589
1590 MonoInst *mono_decompose_opcode (MonoCompile *cfg, MonoInst *ins) MONO_INTERNAL;
1591 void mono_decompose_long_opts (MonoCompile *cfg) MONO_INTERNAL;
1592 void mono_decompose_vtype_opts (MonoCompile *cfg) MONO_INTERNAL;
1593 void mono_decompose_array_access_opts (MonoCompile *cfg) MONO_INTERNAL;
1594 void mono_decompose_soft_float (MonoCompile *cfg) MONO_INTERNAL;
1595 void mono_handle_global_vregs (MonoCompile *cfg) MONO_INTERNAL;
1596 void mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts) MONO_INTERNAL;
1597 void mono_if_conversion (MonoCompile *cfg) MONO_INTERNAL;
1598
1599 /* methods that must be provided by the arch-specific port */
1600 void mono_arch_init (void) MONO_INTERNAL;
1601 void mono_arch_cleanup (void) MONO_INTERNAL;
1602 void mono_arch_cpu_init (void) MONO_INTERNAL;
1603 guint32 mono_arch_cpu_optimizazions (guint32 *exclude_mask) MONO_INTERNAL;
1604 void mono_arch_instrument_mem_needs (MonoMethod *method, int *stack, int *code) MONO_INTERNAL;
1605 void *mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) MONO_INTERNAL;
1606 void *mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) MONO_INTERNAL;
1607 void *mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers) MONO_INTERNAL;
1608 void mono_codegen (MonoCompile *cfg) MONO_INTERNAL;
1609 void mono_call_inst_add_outarg_reg (MonoCompile *cfg, MonoCallInst *call, int vreg, int hreg, gboolean fp) MONO_INTERNAL;
1610 const char *mono_arch_regname (int reg) MONO_INTERNAL;
1611 const char *mono_arch_fregname (int reg) MONO_INTERNAL;
1612 gpointer mono_arch_get_throw_exception (void) MONO_INTERNAL;
1613 gpointer mono_arch_get_rethrow_exception (void) MONO_INTERNAL;
1614 gpointer mono_arch_get_throw_exception_by_name (void) MONO_INTERNAL;
1615 gpointer mono_arch_get_throw_corlib_exception (void) MONO_INTERNAL;
1616 void mono_arch_exceptions_init (void) MONO_INTERNAL;
1617 guchar* mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) MONO_INTERNAL;
1618 guchar* mono_arch_create_trampoline_code_full (MonoTrampolineType tramp_type, guint32 *code_size, MonoJumpInfo **ji, GSList **out_unwind_ops, gboolean aot) MONO_INTERNAL;
1619 gpointer mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot) MONO_INTERNAL;
1620 gpointer mono_arch_create_rgctx_lazy_fetch_trampoline_full (guint32 slot, guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1621 gpointer mono_arch_create_generic_class_init_trampoline (void) MONO_INTERNAL;
1622 gpointer mono_arch_get_nullified_class_init_trampoline (guint32 *code_len) MONO_INTERNAL;
1623 gpointer mono_arch_create_monitor_enter_trampoline (void) MONO_INTERNAL;
1624 gpointer mono_arch_create_monitor_exit_trampoline (void) MONO_INTERNAL;
1625 gpointer mono_arch_create_monitor_enter_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1626 gpointer mono_arch_create_monitor_exit_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1627 gpointer mono_arch_create_generic_class_init_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1628 GList *mono_arch_get_allocatable_int_vars (MonoCompile *cfg) MONO_INTERNAL;
1629 GList *mono_arch_get_global_int_regs (MonoCompile *cfg) MONO_INTERNAL;
1630 GList *mono_arch_get_global_fp_regs (MonoCompile *cfg) MONO_INTERNAL;
1631 GList *mono_arch_get_iregs_clobbered_by_call (MonoCallInst *call) MONO_INTERNAL;
1632 GList *mono_arch_get_fregs_clobbered_by_call (MonoCallInst *call) MONO_INTERNAL;
1633 guint32 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv) MONO_INTERNAL;
1634 void mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors) MONO_INTERNAL;
1635 void mono_arch_flush_icache (guint8 *code, gint size) MONO_INTERNAL;
1636 int mono_arch_max_epilog_size (MonoCompile *cfg) MONO_INTERNAL;
1637 guint8 *mono_arch_emit_prolog (MonoCompile *cfg) MONO_INTERNAL;
1638 void mono_arch_emit_epilog (MonoCompile *cfg) MONO_INTERNAL;
1639 void mono_arch_emit_exceptions (MonoCompile *cfg) MONO_INTERNAL;
1640 void mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1641 void mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1642 void mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1643 void mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) MONO_INTERNAL;
1644 gboolean mono_arch_has_unwind_info (gconstpointer addr) MONO_INTERNAL;
1645 void mono_arch_setup_jit_tls_data (MonoJitTlsData *tls) MONO_INTERNAL;
1646 void mono_arch_free_jit_tls_data (MonoJitTlsData *tls) MONO_INTERNAL;
1647 void mono_arch_fill_argument_info (MonoCompile *cfg) MONO_INTERNAL;
1648 void mono_arch_allocate_vars (MonoCompile *m) MONO_INTERNAL;
1649 int mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info) MONO_INTERNAL;
1650 gboolean mono_arch_print_tree (MonoInst *tree, int arity) MONO_INTERNAL;
1651 void mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_INTERNAL;
1652 void mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src) MONO_INTERNAL;
1653 void mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) MONO_INTERNAL;
1654 MonoDynCallInfo *mono_arch_dyn_call_prepare (MonoMethodSignature *sig) MONO_INTERNAL;
1655 void mono_arch_dyn_call_free (MonoDynCallInfo *info) MONO_INTERNAL;
1656 void mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, guint8 *buf, int buf_len) MONO_INTERNAL;
1657 void mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) MONO_INTERNAL;
1658 MonoInst *mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) MONO_INTERNAL;
1659 void mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins) MONO_INTERNAL;
1660 void mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *ins) MONO_INTERNAL;
1661 GSList* mono_arch_get_delegate_invoke_impls (void) MONO_INTERNAL;
1662 LLVMCallInfo* mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) MONO_INTERNAL;
1663 guint8* mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji) MONO_INTERNAL;
1664 guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target) MONO_INTERNAL;
1665
1666 /* Soft Debug support */
1667 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
1668 void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip) MONO_INTERNAL;
1669 void mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip) MONO_INTERNAL;
1670 void mono_arch_start_single_stepping (void) MONO_INTERNAL;
1671 void mono_arch_stop_single_stepping (void) MONO_INTERNAL;
1672 gboolean mono_arch_is_single_step_event (void *info, void *sigctx) MONO_INTERNAL;
1673 gboolean mono_arch_is_breakpoint_event (void *info, void *sigctx) MONO_INTERNAL;
1674 guint8* mono_arch_get_ip_for_single_step (MonoJitInfo *ji, MonoContext *ctx) MONO_INTERNAL;
1675 guint8* mono_arch_get_ip_for_breakpoint (MonoJitInfo *ji, MonoContext *ctx) MONO_INTERNAL;
1676 void mono_arch_skip_breakpoint (MonoContext *ctx) MONO_INTERNAL;
1677 void mono_arch_skip_single_step (MonoContext *ctx) MONO_INTERNAL;
1678 gpointer mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) MONO_INTERNAL;
1679 #endif
1680
1681 MonoJitInfo *mono_arch_find_jit_info (MonoDomain *domain,
1682 MonoJitTlsData *jit_tls,
1683 MonoJitInfo *res,
1684 MonoJitInfo *prev_ji,
1685 MonoContext *ctx,
1686 MonoContext *new_ctx,
1687 MonoLMF **lmf,
1688 gboolean *managed) MONO_INTERNAL;
1689 gboolean
1690 mono_arch_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
1691 MonoJitInfo *ji, MonoContext *ctx,
1692 MonoContext *new_ctx, MonoLMF **lmf,
1693 StackFrameInfo *frame_info) MONO_INTERNAL;
1694 gpointer mono_arch_get_call_filter (void) MONO_INTERNAL;
1695 gpointer mono_arch_get_restore_context (void) MONO_INTERNAL;
1696 gpointer mono_arch_get_call_filter_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1697 gpointer mono_arch_get_restore_context_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1698 gpointer mono_arch_get_throw_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1699 gpointer mono_arch_get_rethrow_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1700 gpointer mono_arch_get_throw_exception_by_name_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1701 gpointer mono_arch_get_throw_corlib_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1702 gpointer mono_arch_get_throw_pending_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL;
1703 gboolean mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only) MONO_INTERNAL;
1704 void mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf) MONO_INTERNAL;
1705 gboolean mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr) MONO_INTERNAL;
1706 gpointer mono_arch_ip_from_context (void *sigctx) MONO_INTERNAL;
1707 void mono_arch_sigctx_to_monoctx (void *sigctx, MonoContext *ctx) MONO_INTERNAL;
1708 void mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx) MONO_INTERNAL;
1709 gpointer mono_arch_context_get_int_reg (MonoContext *ctx, int reg) MONO_INTERNAL;
1710 void mono_arch_flush_register_windows (void) MONO_INTERNAL;
1711 gboolean mono_arch_is_inst_imm (gint64 imm) MONO_INTERNAL;
1712 MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg) MONO_INTERNAL;
1713 MonoInst* mono_arch_get_thread_intrinsic (MonoCompile* cfg) MONO_INTERNAL;
1714 gboolean mono_arch_is_int_overflow (void *sigctx, void *info) MONO_INTERNAL;
1715 void mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg) MONO_INTERNAL;
1716 guint32 mono_arch_get_patch_offset (guint8 *code) MONO_INTERNAL;
1717 gpointer mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement) MONO_INTERNAL;
1718 gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL;
1719 void mono_arch_create_vars (MonoCompile *cfg) MONO_INTERNAL;
1720 void mono_arch_save_unwind_info (MonoCompile *cfg) MONO_INTERNAL;
1721 void mono_arch_register_lowlevel_calls (void) MONO_INTERNAL;
1722 gpointer mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr) MONO_INTERNAL;
1723 gpointer mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) MONO_INTERNAL;
1724 gpointer mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *method, int vt_offset) MONO_INTERNAL;
1725 void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr) MONO_INTERNAL;
1726 void mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
1727 void mono_arch_nullify_class_init_trampoline(guint8 *code, mgreg_t *regs) MONO_INTERNAL;
1728 void mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) MONO_INTERNAL;
1729 int mono_arch_get_this_arg_reg (MonoMethodSignature *sig, MonoGenericSharingContext *gsctx, guint8 *code) MONO_INTERNAL;
1730 gpointer mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code) MONO_INTERNAL;
1731 MonoObject* mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx) MONO_INTERNAL;
1732 gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target) MONO_INTERNAL;
1733 gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
1734 void mono_arch_emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg) MONO_INTERNAL;
1735 MonoMethod* mono_arch_find_imt_method (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
1736 MonoVTable* mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
1737 gpointer mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) MONO_INTERNAL;
1738 void mono_arch_notify_pending_exc (void) MONO_INTERNAL;
1739
1740 /* Exception handling */
1741
1742 /* Same as MonoStackWalk, but pass the context/frame type as well */
1743 typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoContext *ctx, gpointer data);
1744
1745 void mono_exceptions_init (void) MONO_INTERNAL;
1746 gboolean mono_handle_exception (MonoContext *ctx, gpointer obj,
1747 gpointer original_ip, gboolean test_only) MONO_INTERNAL;
1748 void mono_handle_native_sigsegv (int signal, void *sigctx) MONO_INTERNAL;
1749 void mono_print_thread_dump (void *sigctx);
1750 void mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) MONO_INTERNAL;
1751 void mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *ctx, gboolean do_il_offset, gpointer user_data) MONO_INTERNAL;
1752 void mono_jit_walk_stack_from_ctx_in_thread (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, gboolean do_il_offset, MonoThread *thread, MonoLMF *lmf, gpointer user_data) MONO_INTERNAL;
1753 void mono_setup_altstack (MonoJitTlsData *tls) MONO_INTERNAL;
1754 void mono_free_altstack (MonoJitTlsData *tls) MONO_INTERNAL;
1755 gpointer mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
1756 MonoJitInfo* mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain) MONO_INTERNAL;
1757
1758 MonoJitInfo * mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset, gboolean *managed) MONO_INTERNAL;
1759
1760 gpointer mono_get_throw_exception (void) MONO_INTERNAL;
1761 gpointer mono_get_rethrow_exception (void) MONO_INTERNAL;
1762 gpointer mono_get_call_filter (void) MONO_INTERNAL;
1763 gpointer mono_get_restore_context (void) MONO_INTERNAL;
1764 gpointer mono_get_throw_exception_by_name (void) MONO_INTERNAL;
1765 gpointer mono_get_throw_corlib_exception (void) MONO_INTERNAL;
1766
1767 /* the new function to do stack walks */
1768 typedef gboolean (*MonoStackFrameWalk) (MonoDomain *domain, MonoContext *ctx, MonoJitInfo *ji, gpointer data);
1769 void mono_walk_stack (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoContext *start_ctx, MonoStackFrameWalk func, gpointer user_data);
1770
1771 MonoArray *ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info) MONO_INTERNAL;
1772 MonoBoolean ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
1773 MonoReflectionMethod **method,
1774 gint32 *iloffset, gint32 *native_offset,
1775 MonoString **file, gint32 *line, gint32 *column) MONO_INTERNAL;
1776 MonoString *ves_icall_System_Exception_get_trace (MonoException *exc) MONO_INTERNAL;
1777
1778 /* Dominator/SSA methods */
1779 void mono_compile_dominator_info (MonoCompile *cfg, int dom_flags) MONO_INTERNAL;
1780 void mono_compute_natural_loops (MonoCompile *cfg) MONO_INTERNAL;
1781 MonoBitSet* mono_compile_iterated_dfrontier (MonoCompile *cfg, MonoBitSet *set) MONO_INTERNAL;
1782 void mono_ssa_compute (MonoCompile *cfg) MONO_INTERNAL;
1783 void mono_ssa_remove (MonoCompile *cfg) MONO_INTERNAL;
1784 void mono_ssa_cprop (MonoCompile *cfg) MONO_INTERNAL;
1785 void mono_ssa_deadce (MonoCompile *cfg) MONO_INTERNAL;
1786 void mono_ssa_strength_reduction (MonoCompile *cfg) MONO_INTERNAL;
1787 void mono_free_loop_info (MonoCompile *cfg) MONO_INTERNAL;
1788
1789 void mono_ssa_compute2 (MonoCompile *cfg);
1790 void mono_ssa_remove2 (MonoCompile *cfg);
1791 void mono_ssa_cprop2 (MonoCompile *cfg);
1792 void mono_ssa_deadce2 (MonoCompile *cfg);
1793
1794 /* debugging support */
1795 void mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block,
1796 guint32 breakpoint_id) MONO_INTERNAL;
1797 void mono_debug_open_method (MonoCompile *cfg) MONO_INTERNAL;
1798 void mono_debug_close_method (MonoCompile *cfg) MONO_INTERNAL;
1799 void mono_debug_open_block (MonoCompile *cfg, MonoBasicBlock *bb, guint32 address) MONO_INTERNAL;
1800 void mono_debug_record_line_number (MonoCompile *cfg, MonoInst *ins, guint32 address) MONO_INTERNAL;
1801 void mono_debug_serialize_debug_info (MonoCompile *cfg, guint8 **out_buf, guint32 *buf_len) MONO_INTERNAL;
1802 void mono_debug_add_aot_method (MonoDomain *domain,
1803 MonoMethod *method, guint8 *code_start,
1804 guint8 *debug_info, guint32 debug_info_len) MONO_INTERNAL;
1805 void mono_debug_add_icall_wrapper (MonoMethod *method, MonoJitICallInfo* info) MONO_INTERNAL;
1806 void mono_debug_print_vars (gpointer ip, gboolean only_arguments);
1807 void mono_debugger_run_finally (MonoContext *start_ctx);
1808
1809 extern gssize mono_breakpoint_info_index [MONO_BREAKPOINT_ARRAY_SIZE];
1810
1811 gboolean mono_breakpoint_clean_code (guint8 *method_start, guint8 *code, int offset, guint8 *buf, int size);
1812
1813 #ifdef MONO_DEBUGGER_SUPPORTED
1814
1815 /* Mono Debugger support */
1816 void mini_debugger_init (void);
1817 int mini_debugger_main (MonoDomain *domain, MonoAssembly *assembly, int argc, char **argv);
1818 gboolean mini_debug_running_inside_mdb (void);
1819 void mini_debugger_set_attach_ok (void);
1820
1821 #endif
1822
1823 /* Tracing */
1824 MonoTraceSpec *mono_trace_parse_options (const char *options) MONO_INTERNAL;
1825 void mono_trace_set_assembly (MonoAssembly *assembly) MONO_INTERNAL;
1826 gboolean mono_trace_eval (MonoMethod *method) MONO_INTERNAL;
1827
1828 extern void
1829 mono_perform_abc_removal (MonoCompile *cfg) MONO_INTERNAL;
1830 extern void
1831 mono_perform_abc_removal (MonoCompile *cfg) MONO_INTERNAL;
1832 extern void
1833 mono_perform_ssapre (MonoCompile *cfg) MONO_INTERNAL;
1834 extern void
1835 mono_local_cprop (MonoCompile *cfg) MONO_INTERNAL;
1836 extern void
1837 mono_local_cprop (MonoCompile *cfg);
1838 extern void
1839 mono_local_deadce (MonoCompile *cfg);
1840
1841 /* CAS - stack walk */
1842 MonoSecurityFrame* ves_icall_System_Security_SecurityFrame_GetSecurityFrame (gint32 skip) MONO_INTERNAL;
1843 MonoArray* ves_icall_System_Security_SecurityFrame_GetSecurityStack (gint32 skip) MONO_INTERNAL;
1844
1845 /* Generic sharing */
1846
1847 MonoGenericSharingContext* mono_get_generic_context_from_code (guint8 *code) MONO_INTERNAL;
1848
1849 MonoGenericContext* mini_method_get_context (MonoMethod *method) MONO_INTERNAL;
1850
1851 int mono_method_check_context_used (MonoMethod *method) MONO_INTERNAL;
1852
1853 gboolean mono_generic_context_equal_deep (MonoGenericContext *context1, MonoGenericContext *context2) MONO_INTERNAL;
1854
1855 gpointer mono_helper_get_rgctx_other_ptr (MonoClass *caller_class, MonoVTable *vtable,
1856 guint32 token, guint32 token_source, guint32 rgctx_type,
1857 gint32 rgctx_index) MONO_INTERNAL;
1858
1859 void mono_generic_sharing_init (void) MONO_INTERNAL;
1860
1861 MonoClass* mini_class_get_container_class (MonoClass *class) MONO_INTERNAL;
1862 MonoGenericContext* mini_class_get_context (MonoClass *class) MONO_INTERNAL;
1863
1864 MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
1865 MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
1866
1867 int mini_type_stack_size (MonoGenericSharingContext *gsctx, MonoType *t, int *align) MONO_INTERNAL;
1868 int mini_type_stack_size_full (MonoGenericSharingContext *gsctx, MonoType *t, guint32 *align, gboolean pinvoke) MONO_INTERNAL;
1869 void type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst) MONO_INTERNAL;
1870 guint mono_type_to_regmove (MonoCompile *cfg, MonoType *type) MONO_INTERNAL;
1871
1872 /* wapihandles.c */
1873 int mini_wapi_hps (int argc, char **argv) MONO_INTERNAL;
1874
1875 int mini_wapi_semdel (int argc, char **argv) MONO_INTERNAL;
1876
1877 int mini_wapi_seminfo (int argc, char **argv) MONO_INTERNAL;
1878
1879 /* SIMD support */
1880
1881 /*
1882 This enum MUST be kept in sync with its managed mirror Mono.Simd.AccelMode.
1883 The AccelMode values are masks while the ones here are the bit indexes.
1884 */
1885 enum {
1886 SIMD_VERSION_SSE1 = 0,
1887 SIMD_VERSION_SSE2 = 1,
1888 SIMD_VERSION_SSE3 = 2,
1889 SIMD_VERSION_SSSE3 = 3,
1890 SIMD_VERSION_SSE41 = 4,
1891 SIMD_VERSION_SSE42 = 5,
1892 SIMD_VERSION_SSE4a = 6,
1893 };
1894
1895 enum {
1896 SIMD_COMP_EQ,
1897 SIMD_COMP_LT,
1898 SIMD_COMP_LE,
1899 SIMD_COMP_UNORD,
1900 SIMD_COMP_NEQ,
1901 SIMD_COMP_NLT,
1902 SIMD_COMP_NLE,
1903 SIMD_COMP_ORD
1904 };
1905
1906 enum {
1907 SIMD_PREFETCH_MODE_NTA,
1908 SIMD_PREFETCH_MODE_0,
1909 SIMD_PREFETCH_MODE_1,
1910 SIMD_PREFETCH_MODE_2,
1911 };
1912
1913 const char *mono_arch_xregname (int reg) MONO_INTERNAL;
1914 void mono_simd_simplify_indirection (MonoCompile *cfg) MONO_INTERNAL;
1915 MonoInst* mono_emit_simd_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) MONO_INTERNAL;
1916 guint32 mono_arch_cpu_enumerate_simd_versions (void) MONO_INTERNAL;
1917 void mono_simd_intrinsics_init (void) MONO_INTERNAL;
1918
1919 /*
1920 * Per-OS implementation functions.
1921 */
1922 void mono_runtime_install_handlers (void) MONO_INTERNAL;
1923 void mono_runtime_cleanup_handlers (void) MONO_INTERNAL;
1924 void mono_runtime_setup_stat_profiler (void) MONO_INTERNAL;
1925 void mono_runtime_shutdown_stat_profiler (void) MONO_INTERNAL;
1926 void mono_runtime_posix_install_handlers (void) MONO_INTERNAL;
1927 pid_t mono_runtime_syscall_fork (void) MONO_INTERNAL;
1928 gboolean mono_gdb_render_native_backtraces (void) MONO_INTERNAL;
1929
1930 /*
1931 * Signal handling
1932 */
1933 #ifdef MONO_GET_CONTEXT
1934 #define GET_CONTEXT MONO_GET_CONTEXT
1935 #endif
1936
1937 #ifndef GET_CONTEXT
1938 #ifdef PLATFORM_WIN32
1939 #define GET_CONTEXT \
1940 void *ctx = context;
1941 #else
1942 #ifdef MONO_ARCH_USE_SIGACTION
1943 #define GET_CONTEXT \
1944 void *ctx = context;
1945 #elif defined(__sparc__)
1946 #define GET_CONTEXT \
1947 void *ctx = sigctx;
1948 #else
1949 #define GET_CONTEXT \
1950 void **_p = (void **)&_dummy; \
1951 struct sigcontext *ctx = (struct sigcontext *)++_p;
1952 #endif
1953 #endif
1954 #endif
1955
1956 #ifdef MONO_ARCH_USE_SIGACTION
1957 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, siginfo_t *info, void *context)
1958 #define SIG_HANDLER_PARAMS _dummy, info, context
1959 #elif defined(PLATFORM_WIN32)
1960 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, EXCEPTION_RECORD *info, void *context)
1961 #define SIG_HANDLER_PARAMS _dummy, info, context
1962 #elif defined(__sparc__)
1963 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, void *sigctx)
1964 #define SIG_HANDLER_PARAMS _dummy, sigctx
1965 #else
1966 #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy)
1967 #define SIG_HANDLER_PARAMS _dummy
1968 #endif
1969
1970 void SIG_HANDLER_SIGNATURE (mono_sigfpe_signal_handler) MONO_INTERNAL;
1971 void SIG_HANDLER_SIGNATURE (mono_sigill_signal_handler) MONO_INTERNAL;
1972 void SIG_HANDLER_SIGNATURE (mono_sigsegv_signal_handler) MONO_INTERNAL;
1973 void SIG_HANDLER_SIGNATURE (mono_sigint_signal_handler) MONO_INTERNAL;
1974 gboolean SIG_HANDLER_SIGNATURE (mono_chain_signal) MONO_INTERNAL;
1975
1976 /* for MONO_WRAPPER_UNKNOWN subtypes */
1977 enum {
1978 MONO_AOT_WRAPPER_MONO_ENTER,
1979 MONO_AOT_WRAPPER_MONO_EXIT,
1980 MONO_AOT_WRAPPER_LAST
1981 };
1982
1983 #endif /* __MONO_MINI_H__ */
Mirror of the official Mono project git repository