X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fmini.h;h=0a41407020b6d056db4a4ddda67548f52b706bbe;hb=0d40321933ac575314ab51efa3c62e8cf535a9d2;hp=ecac3e393a7c43082ec337e3a6b93f65fe40f8d3;hpb=f96c0fa9acbd17ec3de071682d9cfacffe8c51fd;p=mono.git diff --git a/mono/mini/mini.h b/mono/mini/mini.h index ecac3e393a7..0a41407020b 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -88,10 +88,10 @@ #define LLVM_ENABLED FALSE #endif -#ifdef MONO_ARCH_SOFT_FLOAT -#define COMPILE_SOFT_FLOAT(cfg) (!COMPILE_LLVM ((cfg))) +#ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK +#define COMPILE_SOFT_FLOAT(cfg) (!COMPILE_LLVM ((cfg)) && mono_arch_is_soft_float ()) #else -#define COMPILE_SOFT_FLOAT(cfg) 0 +#define COMPILE_SOFT_FLOAT(cfg) (0) #endif #ifdef ENABLE_LLVM @@ -133,11 +133,18 @@ #endif /* Version number of the AOT file format */ -#define MONO_AOT_FILE_VERSION 88 +#define MONO_AOT_FILE_VERSION 95 //TODO: This is x86/amd64 specific. #define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6)) +/* Remap printf to g_print (we use a mix of these in the mini code) */ +#ifdef PLATFORM_ANDROID +#define printf g_print +#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 */ enum { MONO_AOT_METHODREF_MIN = 240, @@ -213,9 +220,7 @@ typedef struct MonoAotFileInfo gpointer method_info_offsets; gpointer ex_info_offsets; gpointer code_offsets; -#ifdef MONOTOUCH gpointer method_addresses; -#endif gpointer extra_method_info_offsets; gpointer extra_method_table; gpointer got_info_offsets; @@ -278,7 +283,7 @@ typedef struct MonoAotFileInfo guint32 num_rgctx_fetch_trampolines; /* These are used for sanity checking object layout problems when cross-compiling */ - guint32 double_align, long_align; + guint32 double_align, long_align, generic_tramp_num; } MonoAotFileInfo; /* Per-domain information maintained by the JIT */ @@ -307,6 +312,9 @@ typedef struct GHashTable *arch_seq_points; /* Maps a GSharedVtTrampInfo structure to a trampoline address */ GHashTable *gsharedvt_arg_tramp_hash; + /* memcpy/bzero methods specialized for small constant sizes */ + gpointer *memcpy_addr [17]; + gpointer *bzero_addr [17]; } MonoJitDomainInfo; typedef struct { @@ -332,8 +340,10 @@ typedef struct { */ typedef MonoStackFrameInfo StackFrameInfo; +#define MONO_SEQ_POINT_FLAG_NONEMPTY_STACK 1 + typedef struct { - int il_offset, native_offset; + int il_offset, native_offset, flags; /* Indexes of successor sequence points */ int *next; /* Number of entries in next */ @@ -717,7 +727,8 @@ typedef enum { LLVMArgInFPReg, LLVMArgVtypeInReg, LLVMArgVtypeByVal, - LLVMArgVtypeRetAddr /* On on cinfo->ret */ + LLVMArgVtypeRetAddr, /* On on cinfo->ret */ + LLVMArgGSharedVt, } LLVMArgStorage; typedef struct { @@ -833,6 +844,7 @@ struct MonoCallInst { GSList *out_ireg_args; GSList *out_freg_args; GSList *outarg_vts; + gpointer call_info; #ifdef ENABLE_LLVM LLVMCallInfo *cinfo; int rgctx_arg_reg, imt_arg_reg; @@ -859,6 +871,7 @@ enum { MONO_INST_TAILCALL = 4, MONO_INST_VOLATILE = 4, MONO_INST_NOTYPECHECK = 4, + MONO_INST_NONEMPTY_STACK = 4, /* in SEQ_POINT */ MONO_INST_UNALIGNED = 8, MONO_INST_CFOLD_TAKEN = 8, /* On branches */ MONO_INST_CFOLD_NOT_TAKEN = 16, /* On branches */ @@ -1072,7 +1085,20 @@ typedef enum { MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT, /* Same for calli, associated with a signature */ MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI, - MONO_RGCTX_INFO_CLASS_IS_REF + /* + * 0 - vtype + * 1 - ref + * 2 - gsharedvt type + */ + MONO_RGCTX_INFO_CLASS_BOX_TYPE, + /* Resolves to a MonoGSharedVtMethodRuntimeInfo */ + MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO, + MONO_RGCTX_INFO_LOCAL_OFFSET, + MONO_RGCTX_INFO_MEMCPY, + MONO_RGCTX_INFO_BZERO, + /* The address of Nullable.Box () */ + MONO_RGCTX_INFO_NULLABLE_CLASS_BOX, + MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX, } MonoRgctxInfoType; typedef struct _MonoRuntimeGenericContextInfoTemplate { @@ -1102,6 +1128,23 @@ typedef struct { #define MONO_GSHAREDVT_DEL_INVOKE_VT_OFFSET -2 +typedef struct { + MonoMethod *method; + /* Array of MonoRuntimeGenericContextInfoTemplate* entries */ + GPtrArray *entries; +} MonoGSharedVtMethodInfo; + +/* This is used by gsharedvt methods to allocate locals and compute local offsets */ +typedef struct { + int locals_size; + /* + * The results of resolving the entries in MOonGSharedVtMethodInfo->entries. + * We use this instead of rgctx slots since these can be loaded using a load instead + * of a call to an rgctx fetch trampoline. + */ + gpointer entries [MONO_ZERO_LEN_ARRAY]; +} MonoGSharedVtMethodRuntimeInfo; + typedef enum { #define PATCH_INFO(a,b) MONO_PATCH_INFO_ ## a, #include "patch-info.h" @@ -1139,6 +1182,8 @@ typedef struct MonoJumpInfoGSharedVtCall MonoJumpInfoGSharedVtCall; typedef struct MonoJumpInfo MonoJumpInfo; struct MonoJumpInfo { MonoJumpInfo *next; + /* Relocation type for patching */ + int relocation; union { int i; guint8 *p; @@ -1166,6 +1211,7 @@ struct MonoJumpInfo { MonoJumpInfoRgctxEntry *rgctx_entry; MonoJumpInfoImtTramp *imt_tramp; MonoJumpInfoGSharedVtCall *gsharedvt; + MonoGSharedVtMethodInfo *gsharedvt_method; MonoMethodSignature *sig; } data; }; @@ -1196,15 +1242,11 @@ typedef enum { MONO_TRAMPOLINE_AOT_PLT, MONO_TRAMPOLINE_DELEGATE, MONO_TRAMPOLINE_RESTORE_STACK_PROT, -#ifndef DISABLE_REMOTING MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING, -#endif MONO_TRAMPOLINE_MONITOR_ENTER, MONO_TRAMPOLINE_MONITOR_EXIT, MONO_TRAMPOLINE_VCALL, -#ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD, -#endif MONO_TRAMPOLINE_NUM } MonoTrampolineType; @@ -1216,6 +1258,13 @@ typedef enum { (t) == MONO_TRAMPOLINE_MONITOR_ENTER || \ (t) == MONO_TRAMPOLINE_MONITOR_EXIT) +/* These trampolines receive an argument directly in a register */ +#define MONO_TRAMPOLINE_TYPE_HAS_ARG(t) \ + ((t) == MONO_TRAMPOLINE_GENERIC_CLASS_INIT || \ + (t) == MONO_TRAMPOLINE_MONITOR_ENTER || \ + (t) == MONO_TRAMPOLINE_MONITOR_EXIT || \ + (t) == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD) + /* optimization flags */ #define OPTFLAG(id,shift,name,descr) MONO_OPT_ ## id = 1 << shift, enum { @@ -1324,6 +1373,17 @@ typedef struct { gboolean gsharedvt; + MonoGSharedVtMethodInfo *gsharedvt_info; + + /* Points to the gsharedvt locals area at runtime */ + MonoInst *gsharedvt_locals_var; + + /* The localloc instruction used to initialize gsharedvt_locals_var */ + MonoInst *gsharedvt_locals_var_ins; + + /* Points to a MonoGSharedVtMethodRuntimeInfo at runtime */ + MonoInst *gsharedvt_info_var; + /* For native-to-managed wrappers, the saved old domain */ MonoInst *orig_domain_var; @@ -1472,7 +1532,7 @@ typedef struct { GSList *headers_to_free; /* Used by AOT */ - guint32 got_offset, ex_info_offset, method_info_offset; + guint32 got_offset, ex_info_offset, method_info_offset, method_index; /* Symbol used to refer to this method in generated assembly */ char *asm_symbol; char *llvm_method_name; @@ -1816,8 +1876,8 @@ enum { typedef void (*MonoInstFunc) (MonoInst *tree, gpointer data); /* main function */ -int mono_main (int argc, char* argv[]); -void mono_set_defaults (int verbose_level, guint32 opts); +MONO_API int mono_main (int argc, char* argv[]); +MONO_API void mono_set_defaults (int verbose_level, guint32 opts); MonoDomain* mini_init (const char *filename, const char *runtime_version) MONO_INTERNAL; void mini_cleanup (MonoDomain *domain) MONO_INTERNAL; MonoDebugOptions *mini_get_debug_options (void) MONO_INTERNAL; @@ -1825,6 +1885,7 @@ MonoDebugOptions *mini_get_debug_options (void) MONO_INTERNAL; /* helper methods */ void mono_disable_optimizations (guint32 opts) MONO_INTERNAL; void mono_set_optimizations (guint32 opts) MONO_INTERNAL; +guint32 mono_get_optimizations_for_method (MonoMethod *method, guint32 default_opt) MONO_INTERNAL; void mono_set_verbose_level (guint32 level) MONO_INTERNAL; MonoJumpInfoToken* mono_jump_info_token_new (MonoMemPool *mp, MonoImage *image, guint32 token) MONO_INTERNAL; MonoJumpInfoToken* mono_jump_info_token_new2 (MonoMemPool *mp, MonoImage *image, guint32 token, MonoGenericContext *context) MONO_INTERNAL; @@ -1833,7 +1894,7 @@ MonoInst* mono_find_exvar_for_offset (MonoCompile *cfg, int offset) MONO_ int mono_get_block_region_notry (MonoCompile *cfg, int region) MONO_LLVM_INTERNAL; void mono_precompile_assemblies (void) MONO_INTERNAL; -int mono_parse_default_optimizations (const char* p); +MONO_API int mono_parse_default_optimizations (const char* p); void mono_bblock_add_inst (MonoBasicBlock *bb, MonoInst *inst) MONO_LLVM_INTERNAL; void mono_bblock_insert_after_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) MONO_INTERNAL; void mono_bblock_insert_before_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *ins_to_insert) MONO_INTERNAL; @@ -1874,10 +1935,10 @@ void mono_print_ins_index (int i, MonoInst *ins) MONO_INTERNAL void mono_print_ins (MonoInst *ins) MONO_INTERNAL; void mono_print_bb (MonoBasicBlock *bb, const char *msg) MONO_INTERNAL; void mono_print_code (MonoCompile *cfg, const char *msg) MONO_INTERNAL; -void mono_print_method_from_ip (void *ip); -char *mono_pmip (void *ip); +MONO_API void mono_print_method_from_ip (void *ip); +MONO_API char *mono_pmip (void *ip); gboolean mono_debug_count (void) MONO_INTERNAL; -const char* mono_inst_name (int op); +MONO_API const char* mono_inst_name (int op); void mono_inst_set_src_registers (MonoInst *ins, int *regs) MONO_INTERNAL; int mono_op_to_op_imm (int opcode) MONO_INTERNAL; int mono_op_imm_to_op (int opcode) MONO_INTERNAL; @@ -1888,6 +1949,7 @@ guint mini_type_to_stind (MonoCompile* cfg, MonoType *type) M guint32 mono_reverse_branch_op (guint32 opcode) MONO_INTERNAL; void mono_disassemble_code (MonoCompile *cfg, guint8 *code, int size, char *id) MONO_INTERNAL; void mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target) MONO_LLVM_INTERNAL; +void mono_add_patch_info_rel (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target, int relocation) MONO_LLVM_INTERNAL; void mono_remove_patch_info (MonoCompile *cfg, int ip) MONO_INTERNAL; MonoJumpInfo* mono_patch_info_dup_mp (MonoMemPool *mp, MonoJumpInfo *patch_info) MONO_INTERNAL; guint mono_patch_info_hash (gconstpointer data) MONO_INTERNAL; @@ -1900,12 +1962,14 @@ gpointer mono_jit_compile_method (MonoMethod *method) MONO_INTERNAL; MonoLMF * mono_get_lmf (void) MONO_INTERNAL; MonoLMF** mono_get_lmf_addr (void) MONO_INTERNAL; void mono_set_lmf (MonoLMF *lmf) MONO_INTERNAL; -MonoDomain *mono_jit_thread_attach (MonoDomain *domain); -void mono_jit_set_domain (MonoDomain *domain); +MONO_API MonoDomain *mono_jit_thread_attach (MonoDomain *domain); +MONO_API void mono_jit_set_domain (MonoDomain *domain); MonoNativeTlsKey mono_get_jit_tls_key (void) MONO_INTERNAL; gint32 mono_get_jit_tls_offset (void) MONO_INTERNAL; gint32 mono_get_lmf_tls_offset (void) MONO_INTERNAL; gint32 mono_get_lmf_addr_tls_offset (void) MONO_INTERNAL; +int mini_get_tls_offset (MonoTlsKey key) MONO_INTERNAL; +MonoInst* mono_create_tls_get (MonoCompile *cfg, MonoTlsKey key) MONO_INTERNAL; MonoInst* mono_get_jit_tls_intrinsic (MonoCompile *cfg) MONO_INTERNAL; MonoInst* mono_get_domain_intrinsic (MonoCompile* cfg) MONO_INTERNAL; MonoInst* mono_get_thread_intrinsic (MonoCompile* cfg) MONO_INTERNAL; @@ -1957,14 +2021,24 @@ void mono_nacl_fix_patches(const guint8 *code, MonoJumpInfo *ji); guint8 *mono_arch_nacl_pad(guint8 *code, int pad); guint8 *mono_arch_nacl_skip_nops(guint8 *code); -extern const guint kNaClAlignment; -extern const guint kNaClAlignmentMask; +#if defined(TARGET_X86) +#define kNaClAlignment kNaClAlignmentX86 +#define kNaClAlignmentMask kNaClAlignmentMaskX86 +#elif defined(TARGET_AMD64) +#define kNaClAlignment kNaClAlignmentAMD64 +#define kNaClAlignmentMask kNaClAlignmentMaskAMD64 +#elif defined(TARGET_ARM) +#define kNaClAlignment kNaClAlignmentARM +#define kNaClAlignmentMask kNaClAlignmentMaskARM +#endif + +#define NACL_BUNDLE_ALIGN_UP(p) ((((p)+kNaClAlignmentMask)) & ~kNaClAlignmentMask) #endif #if defined(__native_client__) || defined(__native_client_codegen__) extern volatile int __nacl_thread_suspension_needed; -extern void __nacl_suspend_thread_if_needed(); -void mono_nacl_gc(); +void __nacl_suspend_thread_if_needed(void); +void mono_nacl_gc(void); #endif #if defined(__native_client_codegen__) || defined(__native_client__) @@ -1973,6 +2047,12 @@ void mono_nacl_gc(); #define NACL_SIZE(a, b) (a) #endif +static inline MonoMethod* +jinfo_get_method (MonoJitInfo *ji) +{ + return mono_jit_info_get_method (ji); +} + /* AOT */ void mono_aot_init (void) MONO_INTERNAL; void mono_aot_cleanup (void) MONO_INTERNAL; @@ -2002,6 +2082,7 @@ MonoMethod* mono_aot_get_array_helper_from_wrapper (MonoMethod *method) MONO_INT guint32 mono_aot_get_got_offset (MonoJumpInfo *ji) MONO_LLVM_INTERNAL; char* mono_aot_get_method_name (MonoCompile *cfg) MONO_LLVM_INTERNAL; char* mono_aot_get_plt_symbol (MonoJumpInfoType type, gconstpointer data) MONO_LLVM_INTERNAL; +int mono_aot_get_method_index (MonoMethod *method) MONO_LLVM_INTERNAL; MonoJumpInfo* mono_aot_patch_info_dup (MonoJumpInfo* ji) MONO_LLVM_INTERNAL; void mono_aot_set_make_unreadable (gboolean unreadable) MONO_INTERNAL; gboolean mono_aot_is_pagefault (void *ptr) MONO_INTERNAL; @@ -2010,11 +2091,11 @@ void mono_aot_register_jit_icall (const char *name, gpointer addr) MO void* mono_aot_readonly_field_override (MonoClassField *field) MONO_INTERNAL; /* This is an exported function */ -void mono_aot_register_globals (gpointer *globals); +MONO_API void mono_aot_register_globals (gpointer *globals); /* This too */ -void mono_aot_register_module (gpointer *aot_info); +MONO_API void mono_aot_register_module (gpointer *aot_info); -void mono_xdebug_init (char *xdebug_opts) MONO_INTERNAL; +void mono_xdebug_init (const char *xdebug_opts) MONO_INTERNAL; void mono_save_xdebug_info (MonoCompile *cfg) MONO_INTERNAL; void mono_save_trampoline_xdebug_info (MonoTrampInfo *info) MONO_INTERNAL; /* This is an exported function */ @@ -2037,7 +2118,7 @@ void mono_draw_graph (MonoCompile *cfg, MonoGraphOptions void mono_add_ins_to_end (MonoBasicBlock *bb, MonoInst *inst) MONO_INTERNAL; gpointer mono_create_ftnptr (MonoDomain *domain, gpointer addr) MONO_INTERNAL; -void mono_replace_ins (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, MonoInst **prev, MonoBasicBlock *first_bb, MonoBasicBlock *last_bb); +MONO_API void mono_replace_ins (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, MonoInst **prev, MonoBasicBlock *first_bb, MonoBasicBlock *last_bb); int mono_find_method_opcode (MonoMethod *method) MONO_INTERNAL; MonoJitICallInfo *mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL; @@ -2080,7 +2161,9 @@ gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type); gpointer mini_get_vtable_trampoline (int slot_index) MONO_INTERNAL; char* mono_get_generic_trampoline_name (MonoTrampolineType tramp_type) MONO_INTERNAL; char* mono_get_rgctx_fetch_trampoline_name (int slot) MONO_INTERNAL; -gpointer mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp) MONO_INTERNAL; +gpointer mini_get_nullified_class_init_trampoline (void) MONO_INTERNAL; +gpointer mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp) MONO_INTERNAL; +gboolean mini_jit_info_is_gsharedvt (MonoJitInfo *ji) MONO_INTERNAL; gboolean mono_running_on_valgrind (void) MONO_INTERNAL; void* mono_global_codeman_reserve (int size) MONO_INTERNAL; @@ -2110,6 +2193,8 @@ void mono_emit_unwind_op (MonoCompile *cfg, int when, int val) MONO_INTERNAL; MonoTrampInfo* mono_tramp_info_create (const char *name, guint8 *code, guint32 code_size, MonoJumpInfo *ji, GSList *unwind_ops) MONO_INTERNAL; void mono_tramp_info_free (MonoTrampInfo *info) MONO_INTERNAL; +void mono_tramp_info_register (MonoTrampInfo *info) MONO_INTERNAL; +int mini_exception_id_by_name (const char *name) MONO_INTERNAL; int mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock, MonoInst *return_var, GList *dont_inline, MonoInst **inline_args, @@ -2190,6 +2275,16 @@ gpointer mono_arch_get_gsharedvt_trampoline (MonoTrampInfo **info, gboolean gpointer mono_arch_get_gsharedvt_call_info (gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig, MonoGenericSharingContext *gsctx, gboolean gsharedvt_in, gint32 vcall_offset, gboolean calli) MONO_INTERNAL; gboolean mono_arch_opcode_needs_emulation (MonoCompile *cfg, int opcode) MONO_INTERNAL; +#ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK +gboolean mono_arch_is_soft_float (void) MONO_INTERNAL; +#else +static inline MONO_ALWAYS_INLINE gboolean +mono_arch_is_soft_float (void) +{ + return FALSE; +} +#endif + /* Soft Debug support */ #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip) MONO_INTERNAL; @@ -2295,8 +2390,8 @@ typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoCont void mono_exceptions_init (void) MONO_INTERNAL; gboolean mono_handle_exception (MonoContext *ctx, gpointer obj) MONO_INTERNAL; void mono_handle_native_sigsegv (int signal, void *sigctx) MONO_INTERNAL; -void mono_print_thread_dump (void *sigctx); -void mono_print_thread_dump_from_ctx (MonoContext *ctx); +MONO_API void mono_print_thread_dump (void *sigctx); +MONO_API void mono_print_thread_dump_from_ctx (MonoContext *ctx); void mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data) MONO_INTERNAL; void mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data) MONO_INTERNAL; void mono_walk_stack (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data) MONO_INTERNAL; @@ -2314,6 +2409,7 @@ MonoJitInfo * mono_find_jit_info (MonoDomain *domain, MonoJitTlsD typedef gboolean (*MonoExceptionFrameWalk) (MonoMethod *method, gpointer ip, size_t native_offset, gboolean managed, gpointer user_data); gboolean mono_exception_walk_trace (MonoException *ex, MonoExceptionFrameWalk func, gpointer user_data); +void mono_restore_context (MonoContext *ctx) MONO_INTERNAL; gboolean mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls, @@ -2374,12 +2470,12 @@ void mono_debug_add_aot_method (MonoDomain *domain, MonoMethod *method, guint8 *code_start, guint8 *debug_info, guint32 debug_info_len) MONO_INTERNAL; void mono_debug_add_icall_wrapper (MonoMethod *method, MonoJitICallInfo* info) MONO_INTERNAL; -void mono_debug_print_vars (gpointer ip, gboolean only_arguments); -void mono_debugger_run_finally (MonoContext *start_ctx); +MONO_API void mono_debug_print_vars (gpointer ip, gboolean only_arguments); +MONO_API void mono_debugger_run_finally (MonoContext *start_ctx); extern gssize mono_breakpoint_info_index [MONO_BREAKPOINT_ARRAY_SIZE]; -gboolean mono_breakpoint_clean_code (guint8 *method_start, guint8 *code, int offset, guint8 *buf, int size); +MONO_API gboolean mono_breakpoint_clean_code (guint8 *method_start, guint8 *code, int offset, guint8 *buf, int size); #ifdef MONO_DEBUGGER_SUPPORTED @@ -2421,6 +2517,9 @@ mono_set_generic_sharing_supported (gboolean supported) MONO_INTERNAL; void mono_set_generic_sharing_vt_supported (gboolean supported) MONO_INTERNAL; +void +mono_set_partial_sharing_supported (gboolean supported) MONO_INTERNAL; + gboolean mono_class_generic_sharing_enabled (MonoClass *class) MONO_INTERNAL; @@ -2436,6 +2535,9 @@ mono_method_lookup_rgctx (MonoVTable *class_vtable, MonoGenericInst *method_inst const char* mono_rgctx_info_type_to_str (MonoRgctxInfoType type) MONO_INTERNAL; +MonoJumpInfoType +mini_rgctx_info_type_to_patch_info_type (MonoRgctxInfoType info_type) MONO_INTERNAL; + gboolean mono_method_needs_static_rgctx_invoke (MonoMethod *method, gboolean allow_type_vars) MONO_INTERNAL; @@ -2468,10 +2570,10 @@ gboolean mono_method_is_generic_impl (MonoMethod *method) MONO_INTERNAL; gboolean -mono_method_is_generic_sharable_impl (MonoMethod *method, gboolean allow_type_vars) MONO_INTERNAL; +mono_method_is_generic_sharable (MonoMethod *method, gboolean allow_type_vars) MONO_INTERNAL; gboolean -mono_method_is_generic_sharable_impl_full (MonoMethod *method, gboolean allow_type_vars, gboolean allow_partial, gboolean allow_gsharedvt) MONO_INTERNAL; +mono_method_is_generic_sharable_full (MonoMethod *method, gboolean allow_type_vars, gboolean allow_partial, gboolean allow_gsharedvt) MONO_INTERNAL; gboolean mini_class_is_generic_sharable (MonoClass *klass) MONO_INTERNAL; @@ -2519,7 +2621,6 @@ gboolean mini_is_gsharedvt_type (MonoCompile *cfg, MonoType *t) MONO_INTERNAL; gboolean mini_is_gsharedvt_signature (MonoCompile *cfg, MonoMethodSignature *sig) MONO_INTERNAL; gboolean mini_is_gsharedvt_type_gsctx (MonoGenericSharingContext *gsctx, MonoType *t) MONO_INTERNAL; gboolean mini_is_gsharedvt_variable_type (MonoCompile *cfg, MonoType *t) MONO_INTERNAL; -MonoType* mini_get_gsharedvt_alloc_type_for_type (MonoCompile *cfg, MonoType *t); /* should be internal but it's used by llvm */ gboolean mini_is_gsharedvt_sharable_method (MonoMethod *method) MONO_INTERNAL; gboolean mini_is_gsharedvt_variable_signature (MonoMethodSignature *sig) MONO_INTERNAL; gboolean mini_is_gsharedvt_sharable_inst (MonoGenericInst *inst) MONO_INTERNAL; @@ -2657,4 +2758,26 @@ void SIG_HANDLER_SIGNATURE (mono_sigsegv_signal_handler) MONO_INTERNAL; void SIG_HANDLER_SIGNATURE (mono_sigint_signal_handler) MONO_INTERNAL; gboolean SIG_HANDLER_SIGNATURE (mono_chain_signal) MONO_INTERNAL; +#ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE +#define ARCH_HAVE_DELEGATE_TRAMPOLINES 1 +#else +#define ARCH_HAVE_DELEGATE_TRAMPOLINES 0 +#endif + +#ifdef MONO_ARCH_USE_OP_TAIL_CALL +#define ARCH_USE_OP_TAIL_CALL 1 +#else +#define ARCH_USE_OP_TAIL_CALL 0 +#endif + +#ifndef MONO_ARCH_HAVE_TLS_GET +#define MONO_ARCH_HAVE_TLS_GET 0 +#endif + +#ifdef MONO_ARCH_HAVE_TLS_GET_REG +#define ARCH_HAVE_TLS_GET_REG 1 +#else +#define ARCH_HAVE_TLS_GET_REG 0 +#endif + #endif /* __MONO_MINI_H__ */