mono/mini/mini.h

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