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