#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
#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,
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;
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 */
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 {
*/
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 */
LLVMArgInFPReg,
LLVMArgVtypeInReg,
LLVMArgVtypeByVal,
- LLVMArgVtypeRetAddr /* On on cinfo->ret */
+ LLVMArgVtypeRetAddr, /* On on cinfo->ret */
+ LLVMArgGSharedVt,
} LLVMArgStorage;
typedef struct {
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;
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 */
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<T>.Box () */
+ MONO_RGCTX_INFO_NULLABLE_CLASS_BOX,
+ MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX,
} MonoRgctxInfoType;
typedef struct _MonoRuntimeGenericContextInfoTemplate {
#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"
typedef struct MonoJumpInfo MonoJumpInfo;
struct MonoJumpInfo {
MonoJumpInfo *next;
+ /* Relocation type for patching */
+ int relocation;
union {
int i;
guint8 *p;
MonoJumpInfoRgctxEntry *rgctx_entry;
MonoJumpInfoImtTramp *imt_tramp;
MonoJumpInfoGSharedVtCall *gsharedvt;
+ MonoGSharedVtMethodInfo *gsharedvt_method;
MonoMethodSignature *sig;
} data;
};
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;
(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 {
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;
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;
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;
/* 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;
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;
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;
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;
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;
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__)
#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;
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;
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 */
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;
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;
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,
gboolean mono_arch_gsharedvt_sig_supported (MonoMethodSignature *sig) MONO_INTERNAL;
gpointer mono_arch_get_gsharedvt_trampoline (MonoTrampInfo **info, gboolean aot) MONO_INTERNAL;
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_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;
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,
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
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;
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;
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;
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;
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__ */
projects / mono.git / blobdiff