#endif
/* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION 97
+#define MONO_AOT_FILE_VERSION 100
//TODO: This is x86/amd64 specific.
#define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6))
#define printf g_print
#endif
+#if !defined(HAVE_KW_THREAD) || !defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
+#define MONO_JIT_TLS_DATA_HAS_LMF
+#endif
+
#define MONO_TYPE_IS_PRIMITIVE(t) ((!(t)->byref && ((((t)->type >= MONO_TYPE_BOOLEAN && (t)->type <= MONO_TYPE_R8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
/* Constants used to encode different types of methods in AOT */
guint32 tramp_page_code_offsets [MONO_AOT_TRAMP_NUM];
} MonoAotFileInfo;
+typedef struct
+{
+ MonoClass *klass;
+ MonoMethod *method;
+} MonoClassMethodPair;
+
/* Per-domain information maintained by the JIT */
typedef struct
{
GHashTable *jump_trampoline_hash;
GHashTable *jit_trampoline_hash;
GHashTable *delegate_trampoline_hash;
+ /* Maps ClassMethodPair -> MonoDelegateTrampInfo */
GHashTable *static_rgctx_trampoline_hash;
GHashTable *llvm_vcall_trampoline_hash;
/* maps MonoMethod -> MonoJitDynamicMethodInfo */
/* memcpy/bzero methods specialized for small constant sizes */
gpointer *memcpy_addr [17];
gpointer *bzero_addr [17];
+ gpointer llvm_module;
} MonoJitDomainInfo;
typedef struct {
extern gboolean check_for_pending_exc;
extern gboolean disable_vtypes_in_regs;
extern gboolean mono_verify_all;
-extern gboolean mono_dont_free_global_codeman;
extern gboolean mono_do_x86_stack_align;
extern const char *mono_build_date;
extern gboolean mono_do_signal_chaining;
+extern gboolean mono_do_crash_chaining;
extern gboolean mono_use_llvm;
extern gboolean mono_do_single_method_regression;
extern guint32 mono_single_method_regression_opt;
typedef struct {
gpointer end_of_stack;
guint32 stack_size;
-#if !defined(HAVE_KW_THREAD) || !defined(MONO_ARCH_ENABLE_MONO_LMF_VAR)
+ /* !defined(HAVE_KW_THREAD) || !defined(MONO_ARCH_ENABLE_MONO_LMF_VAR) */
MonoLMF *lmf;
-#endif
MonoLMF *first_lmf;
gpointer restore_stack_prot;
guint32 handling_stack_ovf;
*/
MonoContext orig_ex_ctx;
gboolean orig_ex_ctx_set;
+
+ /*
+ * Stores if we need to run a chained exception in Windows.
+ */
+ gboolean mono_win_chained_exception_needs_run;
} MonoJitTlsData;
/*
gpointer entries [MONO_ZERO_LEN_ARRAY];
} MonoGSharedVtMethodRuntimeInfo;
+typedef struct
+{
+ MonoMethod *invoke;
+ MonoMethod *method;
+ MonoMethodSignature *invoke_sig;
+ MonoMethodSignature *sig;
+ gpointer method_ptr;
+ gpointer invoke_impl;
+ gpointer impl_this;
+ gpointer impl_nothis;
+ gboolean need_rgctx_tramp;
+} MonoDelegateTrampInfo;
+
typedef enum {
#define PATCH_INFO(a,b) MONO_PATCH_INFO_ ## a,
#include "patch-info.h"
MonoJumpInfoGSharedVtCall *gsharedvt;
MonoGSharedVtMethodInfo *gsharedvt_method;
MonoMethodSignature *sig;
+ MonoClassMethodPair *del_tramp;
} data;
};
MONO_TRAMPOLINE_NUM
} MonoTrampolineType;
+/* These trampolines return normally to their caller */
#define MONO_TRAMPOLINE_TYPE_MUST_RETURN(t) \
((t) == MONO_TRAMPOLINE_CLASS_INIT || \
(t) == MONO_TRAMPOLINE_GENERIC_CLASS_INIT || \
MonoInst *lmf_var;
MonoInst *lmf_addr_var;
+ MonoInst *stack_inbalance_var;
+
unsigned char *cil_start;
#ifdef __native_client_codegen__
/* this alloc is not aligned, native_code */
guint soft_breakpoints : 1;
guint arch_eh_jit_info : 1;
guint has_indirection : 1;
- guint has_atomic_add_new_i4 : 1;
+ guint has_atomic_add_i4 : 1;
guint has_atomic_exchange_i4 : 1;
+ guint has_atomic_cas_i4 : 1;
+ guint check_pinvoke_callconv : 1;
+ guint has_unwind_info_for_epilog : 1;
gpointer debug_info;
guint32 lmf_offset;
guint16 *intvars;
#if SIZEOF_VOID_P == 8
#define OP_PCONST OP_I8CONST
+#define OP_DUMMY_PCONST OP_DUMMY_I8CONST
#define OP_PADD OP_LADD
#define OP_PADD_IMM OP_LADD_IMM
#define OP_PAND_IMM OP_LAND_IMM
#define OP_STOREP_MEMBASE_IMM OP_STOREI8_MEMBASE_IMM
#else
#define OP_PCONST OP_ICONST
+#define OP_DUMMY_PCONST OP_DUMMY_ICONST
#define OP_PADD OP_IADD
#define OP_PADD_IMM OP_IADD_IMM
#define OP_PAND_IMM OP_IAND_IMM
gboolean mdb_optimizations;
gboolean no_gdb_backtrace;
gboolean suspend_on_sigsegv;
+ gboolean suspend_on_exception;
gboolean suspend_on_unhandled;
gboolean dyn_runtime_invoke;
gboolean gdb;
* Load AOT JIT info eagerly.
*/
gboolean load_aot_jit_info_eagerly;
+ /*
+ * Check for pinvoke calling convention mismatches.
+ */
+ gboolean check_pinvoke_callconv;
} MonoDebugOptions;
enum {
MonoInst* mono_compile_create_var_store (MonoCompile *cfg, gssize var_index, MonoInst *value) MONO_INTERNAL;
MonoType* mono_type_from_stack_type (MonoInst *ins) MONO_INTERNAL;
guint32 mono_alloc_ireg (MonoCompile *cfg) MONO_LLVM_INTERNAL;
+guint32 mono_alloc_lreg (MonoCompile *cfg) MONO_LLVM_INTERNAL;
guint32 mono_alloc_freg (MonoCompile *cfg) MONO_LLVM_INTERNAL;
guint32 mono_alloc_preg (MonoCompile *cfg) MONO_LLVM_INTERNAL;
guint32 mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type) MONO_INTERNAL;
gboolean mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass) MONO_INTERNAL;
MonoJitInfo* mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) MONO_INTERNAL;
gpointer mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code) MONO_INTERNAL;
-void mono_aot_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
+void mono_aot_patch_plt_entry (guint8 *code, guint8 *plt_entry, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
gpointer mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot) MONO_INTERNAL;
gpointer mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
gpointer mono_aot_get_trampoline (const char *name) MONO_INTERNAL;
void mono_llvm_create_aot_module (const char *got_symbol) MONO_LLVM_INTERNAL;
void mono_llvm_emit_aot_module (const char *filename, int got_size) MONO_LLVM_INTERNAL;
void mono_llvm_check_method_supported (MonoCompile *cfg) MONO_LLVM_INTERNAL;
+void mono_llvm_free_domain_info (MonoDomain *domain) MONO_LLVM_INTERNAL;
gboolean mono_method_blittable (MonoMethod *method) MONO_INTERNAL;
gboolean mono_method_same_domain (MonoJitInfo *caller, MonoJitInfo *callee) MONO_INTERNAL;
gpointer mono_create_jit_trampoline_from_token (MonoImage *image, guint32 token) MONO_INTERNAL;
gpointer mono_create_jit_trampoline_in_domain (MonoDomain *domain, MonoMethod *method) MONO_LLVM_INTERNAL;
gpointer mono_create_delegate_trampoline (MonoDomain *domain, MonoClass *klass) MONO_INTERNAL;
+MonoDelegateTrampInfo* mono_create_delegate_trampoline_info (MonoDomain *domain, MonoClass *klass, MonoMethod *method) MONO_INTERNAL;
gpointer mono_create_rgctx_lazy_fetch_trampoline (guint32 offset) MONO_INTERNAL;
gpointer mono_create_monitor_enter_trampoline (void) MONO_INTERNAL;
gpointer mono_create_monitor_exit_trampoline (void) MONO_INTERNAL;
gboolean mono_arch_opcode_needs_emulation (MonoCompile *cfg, int opcode) MONO_INTERNAL;
gboolean mono_arch_tail_call_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig) MONO_INTERNAL;
int mono_arch_translate_tls_offset (int offset) MONO_INTERNAL;
+gboolean mono_arch_opcode_supported (int opcode) MONO_INTERNAL;
#ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
gboolean mono_arch_is_soft_float (void) MONO_INTERNAL;
void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr) MONO_INTERNAL;
void mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
void mono_arch_nullify_class_init_trampoline(guint8 *code, mgreg_t *regs) MONO_INTERNAL;
-void mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) MONO_INTERNAL;
int mono_arch_get_this_arg_reg (guint8 *code) MONO_INTERNAL;
gpointer mono_arch_get_this_arg_from_call (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target) MONO_INTERNAL;
mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data) MONO_INTERNAL;
gboolean
-mono_thread_state_init_from_handle (MonoThreadUnwindState *tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle) MONO_INTERNAL;
+mono_thread_state_init_from_handle (MonoThreadUnwindState *tctx, MonoThreadInfo *info) MONO_INTERNAL;
/* Exception handling */
MonoClass* mini_class_get_container_class (MonoClass *class) MONO_INTERNAL;
MonoGenericContext* mini_class_get_context (MonoClass *class) MONO_INTERNAL;
-MonoType* mini_replace_type (MonoType *type) MONO_INTERNAL;
+MonoType* mini_replace_type (MonoType *type) MONO_LLVM_INTERNAL;
MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
MonoMethod* mini_get_shared_method (MonoMethod *method) MONO_INTERNAL;
int mini_type_stack_size (MonoGenericSharingContext *gsctx, MonoType *t, int *align) MONO_INTERNAL;
int mini_type_stack_size_full (MonoGenericSharingContext *gsctx, MonoType *t, guint32 *align, gboolean pinvoke) MONO_INTERNAL;
void type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst) MONO_INTERNAL;
-guint mono_type_to_regmove (MonoCompile *cfg, MonoType *type) MONO_INTERNAL;
+guint mono_type_to_regmove (MonoCompile *cfg, MonoType *type) MONO_LLVM_INTERNAL;
void mono_cfg_add_try_hole (MonoCompile *cfg, MonoExceptionClause *clause, guint8 *start, MonoBasicBlock *bb) MONO_INTERNAL;
pid_t mono_runtime_syscall_fork (void) MONO_INTERNAL;
void mono_gdb_render_native_backtraces (pid_t crashed_pid) MONO_INTERNAL;
+void mono_cross_helpers_run (void) MONO_INTERNAL;
+
/*
* Signal handling
*/
#define MONO_ARCH_DYN_CALL_PARAM_AREA 0
#endif
-#ifdef MONO_ARCH_HAVE_IMT
-#define ARCH_HAVE_IMT 1
-#else
-#define ARCH_HAVE_IMT 0
-#endif
-
#ifdef MONO_ARCH_VARARG_ICALLS
#define ARCH_VARARG_ICALLS 1
#else
#define ARCH_VARARG_ICALLS 0
#endif
+#ifdef MONO_ARCH_HAVE_DUMMY_INIT
+#define ARCH_HAVE_DUMMY_INIT 1
+#else
+#define ARCH_HAVE_DUMMY_INIT 0
+#endif
+
+#ifdef MONO_CROSS_COMPILE
+#define MONO_IS_CROSS_COMPILE 1
+#else
+#define MONO_IS_CROSS_COMPILE 0
+#endif
+
+#if defined(__mono_ilp32__)
+#define MONO_IS_ILP32 1
+#else
+#define MONO_IS_ILP32 0
+#endif
+
#endif /* __MONO_MINI_H__ */