#endif
/* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION 117
+#define MONO_AOT_FILE_VERSION 121
//TODO: This is x86/amd64 specific.
#define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6))
#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)))))
+#define MONO_AOT_TRAMP_PAGE_SIZE 16384
+
/* Constants used to encode different types of methods in AOT */
enum {
MONO_AOT_METHODREF_MIN = 240,
guint32 dummy;
/* All the pointers should be at the start to avoid alignment problems */
-
- /* Mono's Global Offset Table */
- gpointer got;
+ /* Symbols */
+#define MONO_AOT_FILE_INFO_FIRST_SYMBOL jit_got
+ /* Global Offset Table for JITted code */
+ gpointer jit_got;
/* Global Offset Table for LLVM code */
gpointer llvm_got;
- /* Compiled code for methods */
- gpointer methods;
- gpointer jit_code_start;
- gpointer jit_code_end;
/* Mono EH Frame created by llc when using LLVM */
gpointer mono_eh_frame;
+ gpointer jit_code_start;
+ gpointer jit_code_end;
+ gpointer method_addresses;
/* Data blob */
gpointer blob;
gpointer class_name_table;
gpointer class_info_offsets;
gpointer method_info_offsets;
gpointer ex_info_offsets;
- gpointer method_addresses;
gpointer extra_method_info_offsets;
gpointer extra_method_table;
gpointer got_info_offsets;
gpointer llvm_got_info_offsets;
- gpointer unwind_info;
gpointer mem_end;
gpointer image_table;
- /* Start of Mono's Program Linkage Table */
- gpointer plt;
- /* End of Mono's Program Linkage Table */
- gpointer plt_end;
/* The GUID of the assembly which the AOT image was generated from */
gpointer assembly_guid;
/*
gpointer globals;
/* Points to a string containing the assembly name*/
gpointer assembly_name;
+ /* Start of Mono's Program Linkage Table */
+ gpointer plt;
+ /* End of Mono's Program Linkage Table */
+ gpointer plt_end;
+ gpointer unwind_info;
/* Points to a table mapping methods to their unbox trampolines */
gpointer unbox_trampolines;
/* Points to the end of the previous table */
gpointer unbox_trampolines_end;
/* Points to a table of unbox trampoline addresses/offsets */
gpointer unbox_trampoline_addresses;
+#define MONO_AOT_FILE_INFO_LAST_SYMBOL unbox_trampoline_addresses
+ /* Scalars */
/* The index of the first GOT slot used by the PLT */
guint32 plt_got_offset_base;
/* Number of entries in the GOT */
guint32 simd_opts;
/* Index of the blob entry holding the GC used by this module */
gint32 gc_name_index;
+ guint32 num_rgctx_fetch_trampolines;
+ /* These are used for sanity checking object layout problems when cross-compiling */
+ guint32 double_align, long_align, generic_tramp_num;
+ /* The page size used by trampoline pages */
+ guint32 tramp_page_size;
+ /* Arrays */
/* Number of trampolines */
guint32 num_trampolines [MONO_AOT_TRAMP_NUM];
/* The indexes of the first GOT slots used by the trampolines */
guint32 trampoline_got_offset_base [MONO_AOT_TRAMP_NUM];
/* The size of one trampoline */
guint32 trampoline_size [MONO_AOT_TRAMP_NUM];
- guint32 num_rgctx_fetch_trampolines;
-
- /* These are used for sanity checking object layout problems when cross-compiling */
- guint32 double_align, long_align, generic_tramp_num;
- /* The page size used by trampoline pages */
- guint32 tramp_page_size;
/* The offset where the trampolines begin on a trampoline page */
guint32 tramp_page_code_offsets [MONO_AOT_TRAMP_NUM];
} MonoAotFileInfo;
+/* Number of symbols in the MonoAotFileInfo structure */
+#define MONO_AOT_FILE_INFO_NUM_SYMBOLS (((G_STRUCT_OFFSET (MonoAotFileInfo, MONO_AOT_FILE_INFO_LAST_SYMBOL) - G_STRUCT_OFFSET (MonoAotFileInfo, MONO_AOT_FILE_INFO_FIRST_SYMBOL)) / sizeof (gpointer)) + 1)
+
typedef struct
{
MonoClass *klass;
/* maps MonoMethod -> MonoJitDynamicMethodInfo */
GHashTable *dynamic_code_hash;
GHashTable *method_code_hash;
- /* Maps methods to a RuntimeInvokeInfo structure */
+ /* Maps methods to a RuntimeInvokeInfo structure, protected by the associated MonoDomain lock */
MonoConcurrentHashTable *runtime_invoke_hash;
/* Maps MonoMethod to a GPtrArray containing sequence point locations */
+ /* Protected by the domain lock */
GHashTable *seq_points;
/* Debugger agent data */
gpointer agent_info;
extern int mono_inject_async_exc_pos;
extern MonoMethodDesc *mono_break_at_bb_method;
extern int mono_break_at_bb_bb_num;
-extern gboolean check_for_pending_exc;
extern gboolean mono_verify_all;
extern gboolean mono_do_x86_stack_align;
extern const char *mono_build_date;
extern GHashTable *mono_single_method_hash;
extern gboolean mono_using_xdebug;
extern int mini_verbose;
-extern gboolean check_for_pending_exc;
extern int valgrind_register;
#define INS_INFO(opcode) (&ins_info [((opcode) - OP_START - 1) * 4])
* consists of floats/doubles.
*/
LLVMArgFpStruct,
+ LLVMArgVtypeByRef,
+ /* Vtype returned as an int */
+ LLVMArgVtypeAsScalar,
} LLVMArgStorage;
typedef struct {
} MonoLMFExt;
/* Generic sharing */
+
+/*
+ * Flags for which contexts were used in inflating a generic.
+ */
+enum {
+ MONO_GENERIC_CONTEXT_USED_CLASS = 1,
+ MONO_GENERIC_CONTEXT_USED_METHOD = 2
+};
+
typedef enum {
MONO_RGCTX_INFO_STATIC_DATA,
MONO_RGCTX_INFO_KLASS,
typedef enum {
MONO_TRAMPOLINE_JIT,
MONO_TRAMPOLINE_JUMP,
- MONO_TRAMPOLINE_CLASS_INIT,
- MONO_TRAMPOLINE_GENERIC_CLASS_INIT,
MONO_TRAMPOLINE_RGCTX_LAZY_FETCH,
MONO_TRAMPOLINE_AOT,
MONO_TRAMPOLINE_AOT_PLT,
MONO_TRAMPOLINE_DELEGATE,
MONO_TRAMPOLINE_RESTORE_STACK_PROT,
MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING,
- MONO_TRAMPOLINE_MONITOR_ENTER,
- MONO_TRAMPOLINE_MONITOR_ENTER_V4,
- MONO_TRAMPOLINE_MONITOR_EXIT,
MONO_TRAMPOLINE_VCALL,
MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD,
MONO_TRAMPOLINE_NUM
/* 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 || \
- (t) == MONO_TRAMPOLINE_RESTORE_STACK_PROT || \
- (t) == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH || \
- (t) == MONO_TRAMPOLINE_MONITOR_ENTER || \
- (t) == MONO_TRAMPOLINE_MONITOR_ENTER_V4 || \
- (t) == MONO_TRAMPOLINE_MONITOR_EXIT)
+ ((t) == MONO_TRAMPOLINE_RESTORE_STACK_PROT || \
+ (t) == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH)
/* 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_ENTER_V4 || \
- (t) == MONO_TRAMPOLINE_MONITOR_EXIT || \
- (t) == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD)
+ ((t) == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD)
/* optimization flags */
#define OPTFLAG(id,shift,name,descr) MONO_OPT_ ## id = 1 << shift,
/* The current virtual register number */
guint32 next_vreg;
- MonoGenericSharingContext *generic_sharing_context;
-
MonoGenericSharingContext gsctx;
MonoGenericContext *gsctx_context;
gboolean suspend_on_unhandled;
gboolean dyn_runtime_invoke;
gboolean gdb;
+ gboolean arm_use_fallback_tls;
/*
* Whenever data such as next sequence points and flags is required.
* Next sequence points and flags are required by the debugger agent.
*/
gboolean gen_sdb_seq_points;
gboolean gen_seq_points_compact_data;
+ /*
+ * Setting single_imm_size should guarantee that each time managed code is compiled
+ * the same instructions and registers are used, regardless of the size of used values.
+ */
+ gboolean single_imm_size;
gboolean explicit_null_checks;
/*
* Fill stack frames with 0x2a in method prologs. This helps with the
MonoInst* mono_compile_create_var (MonoCompile *cfg, MonoType *type, int opcode);
MonoInst* mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, int vreg);
void mono_compile_make_var_load (MonoCompile *cfg, MonoInst *dest, gssize var_index);
-MonoInst* mono_compile_create_var_load (MonoCompile *cfg, gssize var_index);
-MonoInst* mono_compile_create_var_store (MonoCompile *cfg, gssize var_index, MonoInst *value);
MonoInst* mini_get_int_to_float_spill_area (MonoCompile *cfg);
MonoType* mono_type_from_stack_type (MonoInst *ins);
guint32 mono_alloc_ireg (MonoCompile *cfg) MONO_LLVM_INTERNAL;
void mono_global_regalloc (MonoCompile *cfg);
void mono_create_jump_table (MonoCompile *cfg, MonoInst *label, MonoBasicBlock **bbs, int num_blocks);
int mono_compile_assembly (MonoAssembly *ass, guint32 opts, const char *aot_options);
-MonoCompile *mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, JitFlags flags, int parts);
+MonoCompile *mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, JitFlags flags, int parts, int aot_method_index);
void mono_destroy_compile (MonoCompile *cfg);
MonoJitICallInfo *mono_find_jit_opcode_emulation (int opcode);
void mono_print_ins_index (int i, MonoInst *ins);
void mono_add_seq_point (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, int native_offset);
void mono_add_var_location (MonoCompile *cfg, MonoInst *var, gboolean is_reg, int reg, int offset, int from, int to);
MonoInst* mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args);
-MonoInst* mono_emit_jit_icall_by_info (MonoCompile *cfg, MonoJitICallInfo *info, MonoInst **args, MonoBasicBlock **out_cbb);
+MonoInst* mono_emit_jit_icall_by_info (MonoCompile *cfg, MonoJitICallInfo *info, MonoInst **args);
MonoInst* mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this);
void mono_create_helper_signatures (void);
void mono_xdebug_flush (void);
/* LLVM backend */
-/* Keep this in synch with mini-llvm-loaded.c */
+/* KEEP THIS IN SYNCH WITH mini-llvm-loaded.c */
void mono_llvm_init (void) MONO_LLVM_INTERNAL;
void mono_llvm_cleanup (void) MONO_LLVM_INTERNAL;
void mono_llvm_emit_method (MonoCompile *cfg) MONO_LLVM_INTERNAL;
void mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_LLVM_INTERNAL;
-void mono_llvm_create_aot_module (const char *got_symbol, gboolean external_symbols, gboolean emit_dwarf) MONO_LLVM_INTERNAL;
+void mono_llvm_create_aot_module (MonoAssembly *assembly, const char *global_prefix, gboolean emit_dwarf, gboolean static_link) MONO_LLVM_INTERNAL;
void mono_llvm_emit_aot_module (const char *filename, const char *cu_name) MONO_LLVM_INTERNAL;
+void mono_llvm_emit_aot_file_info (MonoAotFileInfo *info, gboolean has_jitted_code) MONO_LLVM_INTERNAL;
+void mono_llvm_emit_aot_data (const char *symbol, guint8 *data, int data_len) 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;
MONO_API void mono_personality (void);
gpointer mini_get_nullified_class_init_trampoline (void);
gpointer mini_get_single_step_trampoline (void);
gpointer mini_get_breakpoint_trampoline (void);
-gpointer mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp);
+gpointer mini_add_method_trampoline (MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp);
gboolean mini_jit_info_is_gsharedvt (MonoJitInfo *ji);
+gpointer* mini_resolve_imt_method (MonoVTable *vt, gpointer *vtable_slot, MonoMethod *imt_method, MonoMethod **impl_method, gpointer *out_aot_addr,
+ gboolean *out_need_rgctx_tramp, MonoMethod **variant_iface);
gboolean mono_running_on_valgrind (void);
void* mono_global_codeman_reserve (int size);
int val);
MonoTrampInfo* mono_tramp_info_create (const char *name, guint8 *code, guint32 code_size, MonoJumpInfo *ji, GSList *unwind_ops);
void mono_tramp_info_free (MonoTrampInfo *info);
-void mono_tramp_info_register (MonoTrampInfo *info);
+void mono_tramp_info_register (MonoTrampInfo *info, MonoDomain *domain);
int mini_exception_id_by_name (const char *name);
gboolean mini_type_is_hfa (MonoType *t, int *out_nfields, int *out_esize) MONO_LLVM_INTERNAL;
MonoInst *return_var, MonoInst **inline_args,
guint inline_offset, gboolean is_virtual_call);
-MonoInst *mono_decompose_opcode (MonoCompile *cfg, MonoInst *ins, MonoBasicBlock **out_cbb);
+MonoInst *mono_decompose_opcode (MonoCompile *cfg, MonoInst *ins);
void mono_decompose_long_opts (MonoCompile *cfg);
void mono_decompose_vtype_opts (MonoCompile *cfg);
void mono_decompose_vtype_opts_llvm (MonoCompile *cfg);
void mono_arch_free_jit_tls_data (MonoJitTlsData *tls);
void mono_arch_fill_argument_info (MonoCompile *cfg);
void mono_arch_allocate_vars (MonoCompile *m);
-int mono_arch_get_argument_info (MonoGenericSharingContext *gsctx, MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info);
-gboolean mono_arch_print_tree (MonoInst *tree, int arity);
+int mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info);
+gboolean mono_arch_print_tree (MonoInst *tree, int arity);
void mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call);
void mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src);
void mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val);
void mono_arch_set_target (char *mtriple);
gboolean mono_arch_gsharedvt_sig_supported (MonoMethodSignature *sig);
gpointer mono_arch_get_gsharedvt_trampoline (MonoTrampInfo **info, gboolean aot);
-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);
+gpointer mono_arch_get_gsharedvt_call_info (gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig, gboolean gsharedvt_in, gint32 vcall_offset, gboolean calli);
gboolean mono_arch_opcode_needs_emulation (MonoCompile *cfg, int opcode);
gboolean mono_arch_tail_call_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig);
int mono_arch_translate_tls_offset (int offset);
#endif
gboolean
-mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
- MonoJitInfo *ji, MonoContext *ctx,
- MonoContext *new_ctx, MonoLMF **lmf,
- mgreg_t **save_locations,
- StackFrameInfo *frame_info);
+mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
+ MonoJitInfo *ji, MonoContext *ctx,
+ MonoContext *new_ctx, MonoLMF **lmf,
+ mgreg_t **save_locations,
+ StackFrameInfo *frame_info);
gpointer mono_arch_get_throw_exception_by_name (void);
gpointer mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot);
gpointer mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot);
void mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data);
void mono_walk_stack (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data);
gboolean mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx);
+void mono_thread_state_init (MonoThreadUnwindState *ctx);
gboolean mono_thread_state_init_from_current (MonoThreadUnwindState *ctx);
gboolean mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx);
MonoReflectionMethod **method,
gint32 *iloffset, gint32 *native_offset,
MonoString **file, gint32 *line, gint32 *column);
-MonoString *ves_icall_System_Exception_get_trace (MonoException *exc);
void mono_set_cast_details (MonoClass *from, MonoClass *to);
/* Installs a function which is called when the runtime encounters an unhandled exception.
mono_class_generic_sharing_enabled (MonoClass *class);
gpointer
-mono_class_fill_runtime_generic_context (MonoVTable *class_vtable, guint8 *caller, guint32 slot);
+mono_class_fill_runtime_generic_context (MonoVTable *class_vtable, guint32 slot);
gpointer
-mono_method_fill_runtime_generic_context (MonoMethodRuntimeGenericContext *mrgctx, guint8 *caller, guint32 slot);
+mono_method_fill_runtime_generic_context (MonoMethodRuntimeGenericContext *mrgctx, guint32 slot);
MonoMethodRuntimeGenericContext*
mono_method_lookup_rgctx (MonoVTable *class_vtable, MonoGenericInst *method_inst);
gboolean
mini_is_gsharedvt_gparam (MonoType *t);
-MonoGenericSharingContext* mono_get_generic_context_from_code (guint8 *code);
-
MonoGenericContext* mini_method_get_context (MonoMethod *method);
int mono_method_check_context_used (MonoMethod *method);
MonoClass* mini_class_get_container_class (MonoClass *class);
MonoGenericContext* mini_class_get_context (MonoClass *class);
-MonoType* mini_replace_type (MonoType *type) MONO_LLVM_INTERNAL;
-MonoType* mini_get_underlying_type (MonoCompile *cfg, MonoType *type) MONO_LLVM_INTERNAL;
-MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type);
-MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type);
+MonoType* mini_get_underlying_type (MonoType *type) MONO_LLVM_INTERNAL;
+MonoType* mini_type_get_underlying_type (MonoType *type);
MonoMethod* mini_get_shared_method (MonoMethod *method);
MonoMethod* mini_get_shared_method_to_register (MonoMethod *method);
MonoMethod* mini_get_shared_method_full (MonoMethod *method, gboolean all_vt, gboolean is_gsharedvt);
+int mini_get_rgctx_entry_slot (MonoJumpInfoRgctxEntry *entry);
-int mini_type_stack_size (MonoGenericSharingContext *gsctx, MonoType *t, int *align);
-int mini_type_stack_size_full (MonoGenericSharingContext *gsctx, MonoType *t, guint32 *align, gboolean pinvoke);
+int mini_type_stack_size (MonoType *t, int *align);
+int mini_type_stack_size_full (MonoType *t, guint32 *align, gboolean pinvoke);
void type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst);
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);
void mono_cfg_set_exception (MonoCompile *cfg, int type);
-gboolean mini_type_is_reference (MonoCompile *cfg, MonoType *type);
-gboolean mini_type_is_vtype (MonoCompile *cfg, MonoType *t) MONO_LLVM_INTERNAL;
-gboolean mini_type_var_is_vt (MonoCompile *cfg, MonoType *type) MONO_LLVM_INTERNAL;
-gboolean mini_is_gsharedvt_klass (MonoCompile *cfg, MonoClass *klass) MONO_LLVM_INTERNAL;
-gboolean mini_is_gsharedvt_type (MonoCompile *cfg, MonoType *t);
-gboolean mini_is_gsharedvt_signature (MonoCompile *cfg, MonoMethodSignature *sig);
-gboolean mini_is_gsharedvt_type_gsctx (MonoGenericSharingContext *gsctx, MonoType *t);
-gboolean mini_is_gsharedvt_variable_type (MonoCompile *cfg, MonoType *t) MONO_LLVM_INTERNAL;
-gboolean mini_is_gsharedvt_variable_klass (MonoCompile *cfg, MonoClass *klass) MONO_LLVM_INTERNAL;
+
+gboolean mini_type_is_reference (MonoType *type);
+gboolean mini_type_is_vtype (MonoType *t) MONO_LLVM_INTERNAL;
+gboolean mini_type_var_is_vt (MonoType *type) MONO_LLVM_INTERNAL;
+gboolean mini_is_gsharedvt_type (MonoType *t);
+gboolean mini_is_gsharedvt_klass (MonoClass *klass) MONO_LLVM_INTERNAL;
+gboolean mini_is_gsharedvt_signature (MonoMethodSignature *sig);
+gboolean mini_is_gsharedvt_variable_type (MonoType *t) MONO_LLVM_INTERNAL;
+gboolean mini_is_gsharedvt_variable_klass (MonoClass *klass) MONO_LLVM_INTERNAL;
gboolean mini_is_gsharedvt_sharable_method (MonoMethod *method);
gboolean mini_is_gsharedvt_variable_signature (MonoMethodSignature *sig);
gboolean mini_is_gsharedvt_sharable_inst (MonoGenericInst *inst);
gpointer mini_method_get_rgctx (MonoMethod *m);
void mini_init_gsctx (MonoDomain *domain, MonoMemPool *mp, MonoGenericContext *context, MonoGenericSharingContext *gsctx);
-gpointer mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig, MonoGenericSharingContext *gsctx,
+gpointer mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig,
gint32 vcall_offset, gboolean calli);
/* SIMD support */