X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fmini.h;h=b47a0ab2f8763752a2e6ba1984d86736315dd4fa;hb=0db4b09607843d097a6f60f5c8101bb7ef8f3866;hp=752d55eb051d75329198985714ece24cfe2f0c1e;hpb=bcd9596e1718ff820dff5019bce162ef7a223e1f;p=mono.git diff --git a/mono/mini/mini.h b/mono/mini/mini.h index 752d55eb051..b47a0ab2f87 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -113,7 +113,7 @@ #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)) @@ -188,35 +188,29 @@ typedef struct MonoAotFileInfo 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; /* @@ -233,13 +227,20 @@ typedef struct MonoAotFileInfo 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 */ @@ -256,23 +257,26 @@ typedef struct MonoAotFileInfo 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; @@ -303,9 +307,10 @@ typedef struct /* 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; @@ -494,7 +499,6 @@ extern MonoMethodDesc *mono_inject_async_exc_method; 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; @@ -508,7 +512,6 @@ extern GSList *mono_single_method_list; 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]) @@ -722,6 +725,9 @@ typedef enum { * consists of floats/doubles. */ LLVMArgFpStruct, + LLVMArgVtypeByRef, + /* Vtype returned as an int */ + LLVMArgVtypeAsScalar, } LLVMArgStorage; typedef struct { @@ -1092,6 +1098,15 @@ 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, @@ -1306,17 +1321,12 @@ struct MonoJumpInfoGSharedVtCall { 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 @@ -1324,21 +1334,12 @@ typedef enum { /* 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, @@ -1456,8 +1457,6 @@ typedef struct { /* The current virtual register number */ guint32 next_vreg; - MonoGenericSharingContext *generic_sharing_context; - MonoGenericSharingContext gsctx; MonoGenericContext *gsctx_context; @@ -1910,12 +1909,18 @@ typedef struct { 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 @@ -2116,8 +2121,6 @@ void mono_cprop_local (MonoCompile *cfg, MonoBasicBlock *b 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; @@ -2195,7 +2198,7 @@ void mono_linear_scan (MonoCompile *cfg, GList *vars, GLis 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); @@ -2321,13 +2324,15 @@ void mono_save_trampoline_xdebug_info (MonoTrampInfo *info); 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); @@ -2395,8 +2400,10 @@ char* mono_get_rgctx_fetch_trampoline_name (int slot); 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); @@ -2426,7 +2433,7 @@ void mono_emit_unwind_op (MonoCompile *cfg, int when, 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; @@ -2491,8 +2498,8 @@ void mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBloc 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); @@ -2511,7 +2518,7 @@ GSList* mono_arch_get_cie_program (void); 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); @@ -2558,11 +2565,11 @@ mono_jumptable_get_entry (guint8 *code); #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); @@ -2635,6 +2642,7 @@ void mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoCont 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); @@ -2672,7 +2680,6 @@ MonoBoolean ves_icall_get_frame_info (gint32 skip, MonoBoolean need_f 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. @@ -2812,8 +2819,6 @@ mono_is_partially_sharable_inst (MonoGenericInst *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); @@ -2830,39 +2835,37 @@ void mono_generic_sharing_cleanup (void); 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 */