X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fmini.h;h=0d9fe14859d27be0634849673239f4557a00bf6d;hb=e4abb3281f6abfa1effcbfc174884a3bb63865a4;hp=cca5f10aa0b209d575edc93fd0a7bd4b3e27f1c8;hpb=a398788572c2b0078a858e490371f779e7cb720d;p=mono.git diff --git a/mono/mini/mini.h b/mono/mini/mini.h index cca5f10aa0b..0d9fe14859d 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -33,7 +33,7 @@ typedef gint64 mgreg_t; #include "mini-arch.h" #include "regalloc.h" #include "declsec.h" -#include "unwind.h" +#include "mini-unwind.h" #ifndef G_LIKELY #define G_LIKELY(a) (a) @@ -66,12 +66,14 @@ typedef gint64 mgreg_t; #define LLVM_ENABLED FALSE #endif -#define NOT_IMPLEMENTED do { g_assert_not_reached (); } while (0) - -#ifndef DISABLE_AOT -#define MONO_USE_AOT_COMPILER +#ifdef MONO_ARCH_SOFT_FLOAT +#define COMPILE_SOFT_FLOAT(cfg) (!COMPILE_LLVM ((cfg))) +#else +#define COMPILE_SOFT_FLOAT(cfg) 0 #endif +#define NOT_IMPLEMENTED do { g_assert_not_reached (); } while (0) + /* for 32 bit systems */ #if G_BYTE_ORDER == G_LITTLE_ENDIAN #define MINI_LS_WORD_IDX 0 @@ -88,8 +90,15 @@ typedef gint64 mgreg_t; #define MONO_FAKE_IMT_METHOD ((MonoMethod*)GINT_TO_POINTER(-1)) #define MONO_FAKE_VTABLE_METHOD ((MonoMethod*)GINT_TO_POINTER(-2)) +#ifndef DISABLE_AOT +#define MONO_USE_AOT_COMPILER +#endif + /* Version number of the AOT file format */ -#define MONO_AOT_FILE_VERSION "53" +#define MONO_AOT_FILE_VERSION "67" + +//TODO: This is x86/amd64 specific. +#define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6)) /* Constants used to encode different types of methods in AOT */ enum { @@ -106,7 +115,36 @@ enum { /* Methods resolve using a METHODSPEC token */ MONO_AOT_METHODREF_METHODSPEC = 255, }; - + +/* Trampolines which we have a lot of */ +typedef enum { + MONO_AOT_TRAMP_SPECIFIC = 0, + MONO_AOT_TRAMP_STATIC_RGCTX = 1, + MONO_AOT_TRAMP_IMT_THUNK = 2, + MONO_AOT_TRAMP_NUM = 3 +} MonoAotTrampoline; + +typedef enum { + MONO_AOT_FILE_FLAG_WITH_LLVM = 1, + MONO_AOT_FILE_FLAG_FULL_AOT = 2 +} MonoAotFileFlags; + +/* This structure is stored in the AOT file */ +typedef struct MonoAotFileInfo +{ + guint32 plt_got_offset_base; + guint32 got_size; + guint32 plt_size; + guint32 nmethods; + guint32 flags; + /* Optimization flags used to compile the module */ + guint32 opts; + + guint32 num_trampolines [MONO_AOT_TRAMP_NUM]; + guint32 trampoline_got_offset_base [MONO_AOT_TRAMP_NUM]; + guint32 trampoline_size [MONO_AOT_TRAMP_NUM]; +} MonoAotFileInfo; + /* Per-domain information maintained by the JIT */ typedef struct { @@ -123,8 +161,14 @@ typedef struct /* maps MonoMethod -> MonoJitDynamicMethodInfo */ GHashTable *dynamic_code_hash; GHashTable *method_code_hash; - /* Compiled runtime invoke function for parameterless ctors */ - gpointer ctor_runtime_invoke; + /* Maps methods to a RuntimeInvokeInfo structure */ + GHashTable *runtime_invoke_hash; + /* Maps MonoMethod to a GPtrArray containing sequence point locations */ + GHashTable *seq_points; + /* Debugger agent data */ + gpointer agent_info; + /* Maps MonoMethod to an arch-specific structure */ + GHashTable *arch_seq_points; } MonoJitDomainInfo; typedef struct { @@ -134,6 +178,61 @@ typedef struct { #define domain_jit_info(domain) ((MonoJitDomainInfo*)((domain)->runtime_info)) +/* Arch-specific */ +typedef struct { + int dummy; +} MonoDynCallInfo; + +/* + * Possible frame types returned by the stack walker. + */ +typedef enum { + /* Normal managed frames */ + FRAME_TYPE_MANAGED = 0, + /* Pseudo frame marking the start of a method invocation done by the soft debugger */ + FRAME_TYPE_DEBUGGER_INVOKE = 1, + /* Frame for transitioning to native code */ + FRAME_TYPE_MANAGED_TO_NATIVE = 2, + FRAME_TYPE_SENTINEL = 3 +} StackFrameType; + +/* + * Information about a stack frame + */ +typedef struct { + StackFrameType type; + /* + * For FRAME_TYPE_MANAGED. + * For FRAME_TYPE_MANAGED_TO_NATIVE, the ji for the method which transitioned to + * native code, if there is one, else NULL. + */ + MonoJitInfo *ji; + /* + * For FRAME_TYPE_MANAGED_TO_NATIVE, it is either the method which transitioned + * to native code, or the method which was JITted. + */ + MonoMethod *method; + /* The domain containing the code executed by this frame */ + MonoDomain *domain; + gboolean managed; + int native_offset; + int il_offset; + gpointer lmf; +} StackFrameInfo; + +typedef struct { + int il_offset, native_offset; + /* Indexes of successor sequence points */ + int *next; + /* Number of entries in next */ + int next_len; +} SeqPoint; + +typedef struct { + int len; + SeqPoint seq_points [MONO_ZERO_LEN_ARRAY]; +} MonoSeqPointInfo; + #if 0 #define mono_bitset_foreach_bit(set,b,n) \ for (b = 0; b < n; b++)\ @@ -202,7 +301,6 @@ enum { (ins)->opcode = OP_NOP; \ (ins)->dreg = -1; \ MONO_INST_NULLIFY_SREGS ((ins)); \ - (ins)->ssa_op = MONO_SSA_NOP; \ } while (0) /* Remove INS from BB */ @@ -280,7 +378,6 @@ typedef struct MonoInstList MonoInstList; typedef struct MonoInst MonoInst; typedef struct MonoCallInst MonoCallInst; typedef struct MonoCallArgParm MonoCallArgParm; -typedef struct MonoEdge MonoEdge; typedef struct MonoMethodVar MonoMethodVar; typedef struct MonoBasicBlock MonoBasicBlock; typedef struct MonoLMF MonoLMF; @@ -305,6 +402,7 @@ 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_use_llvm; #define INS_INFO(opcode) (&ins_info [((opcode) - OP_START - 1) * 4]) @@ -322,12 +420,6 @@ extern const gint8 ins_sreg_counts []; #define mono_bb_first_ins(bb) (bb)->code -struct MonoEdge { - MonoEdge *next; - MonoBasicBlock *bb; - /* add edge type? */ -}; - struct MonoSpillInfo { int offset; }; @@ -376,6 +468,7 @@ struct MonoBasicBlock { /* The address of the generated code, used for fixups */ int native_offset; int max_offset; + int max_length; /* Visited and reachable flags */ guint32 flags; @@ -389,7 +482,6 @@ struct MonoBasicBlock { GSList *dominated; /* fast dominator algorithm */ MonoBasicBlock *df_parent, *ancestor, *child, *label; - MonoEdge *bucket; int size, sdom, idomn; /* loop nesting and recognition */ @@ -408,6 +500,10 @@ struct MonoBasicBlock { guint has_array_access : 1; /* Whenever this bblock is extended, ie. it has branches inside it */ guint extended : 1; + /* Whenever this bblock contains a OP_JUMP_TABLE instruction */ + guint has_jump_table : 1; + /* Whenever this bblock contains an OP_CALL_HANDLER instruction */ + guint has_call_handler : 1; /* use for liveness analysis */ MonoBitSet *gen_set; @@ -423,6 +519,9 @@ struct MonoBasicBlock { /* we use that to prevent merging of bblocks covered by different clauses*/ guint real_offset; + GSList *seq_points; + MonoInst *last_seq_point; + /* * The region encodes whether the basic block is inside * a finally, catch, filter or none of these. @@ -482,8 +581,7 @@ typedef struct { struct MonoInst { guint16 opcode; guint8 type; /* stack type */ - guint ssa_op : 3; - guint8 flags : 5; + guint8 flags; /* used by the register allocator */ gint32 dreg, sreg1, sreg2, sreg3; @@ -583,10 +681,10 @@ enum { /* temp local created by a DUP: used only within a BB */ MONO_INST_IS_TEMP = 1, MONO_INST_INIT = 1, /* in localloc */ + MONO_INST_SINGLE_STEP_LOC = 1, /* in SEQ_POINT */ MONO_INST_IS_DEAD = 2, MONO_INST_TAILCALL = 4, MONO_INST_VOLATILE = 4, - MONO_INST_BRLABEL = 4, MONO_INST_NOTYPECHECK = 4, MONO_INST_UNALIGNED = 8, MONO_INST_CFOLD_TAKEN = 8, /* On branches */ @@ -594,7 +692,9 @@ enum { MONO_INST_DEFINITION_HAS_SIDE_EFFECTS = 8, /* the address of the variable has been taken */ MONO_INST_INDIRECT = 16, - MONO_INST_NORANGECHECK = 16 + MONO_INST_NORANGECHECK = 16, + /* On loads, the source address can be null */ + MONO_INST_FAULT = 32 }; #define inst_c0 data.op[0].const_val @@ -714,6 +814,11 @@ typedef struct { void (*abort_func) (MonoObject *object); /* Used to implement --debug=casts */ MonoClass *class_cast_from, *class_cast_to; + + /* Stores state needed by mono_resume_unwind () */ + MonoContext ex_ctx; + /* FIXME: GC */ + gpointer ex_obj; } MonoJitTlsData; typedef enum { @@ -742,6 +847,12 @@ typedef struct MonoJumpInfoBBTable { typedef struct MonoJumpInfoRgctxEntry MonoJumpInfoRgctxEntry; +/* Contains information describing an LLVM IMT trampoline */ +typedef struct MonoJumpInfoImtTramp { + MonoMethod *method; + int vt_offset; +} MonoJumpInfoImtTramp; + typedef struct MonoJumpInfo MonoJumpInfo; struct MonoJumpInfo { MonoJumpInfo *next; @@ -770,6 +881,7 @@ struct MonoJumpInfo { MonoJumpInfoToken *token; MonoJumpInfoBBTable *table; MonoJumpInfoRgctxEntry *rgctx_entry; + MonoJumpInfoImtTramp *imt_tramp; } data; }; @@ -794,7 +906,7 @@ typedef enum { MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING, MONO_TRAMPOLINE_MONITOR_ENTER, MONO_TRAMPOLINE_MONITOR_EXIT, -#ifdef ENABLE_LLVM +#ifdef MONO_ARCH_LLVM_SUPPORTED MONO_TRAMPOLINE_LLVM_VCALL, #endif MONO_TRAMPOLINE_NUM @@ -848,7 +960,7 @@ typedef struct { MonoJumpInfo *patch_info; MonoJitInfo *jit_info; MonoJitDynamicMethodInfo *dynamic_info; - guint num_bblocks; + guint num_bblocks, max_block_num; guint locals_start; guint num_varinfo; /* used items in varinfo */ guint varinfo_count; /* total storage in varinfo */ @@ -869,6 +981,7 @@ typedef struct { MonoInst **args; MonoType **arg_types; MonoMethod *current_method; /* The method currently processed by method_to_ir () */ + MonoMethod *method_to_register; /* The method to register in JIT info tables */ MonoGenericContext *generic_context; /* @@ -937,22 +1050,30 @@ typedef struct { guint skip_visibility : 1; guint disable_reuse_registers : 1; guint disable_reuse_stack_slots : 1; + guint disable_reuse_ref_stack_slots : 1; guint disable_initlocals_opt : 1; + guint disable_initlocals_opt_refs : 1; guint disable_omit_fp : 1; guint disable_vreg_to_lvreg : 1; guint disable_deadce_vars : 1; + guint disable_out_of_line_bblocks : 1; + guint init_ref_vars : 1; guint extend_live_ranges : 1; + guint compute_precise_live_ranges : 1; guint has_got_slots : 1; guint uses_rgctx_reg : 1; guint uses_vtable_reg : 1; guint uses_simd_intrinsics : 1; guint keep_cil_nops : 1; + guint gen_seq_points : 1; + guint explicit_null_checks : 1; gpointer debug_info; guint32 lmf_offset; guint16 *intvars; MonoProfileCoverageInfo *coverage_info; GHashTable *token_info_hash; MonoCompileArch arch; + guint32 inline_depth; guint32 exception_type; /* MONO_EXCEPTION_* */ guint32 exception_data; char* exception_message; @@ -1000,8 +1121,27 @@ typedef struct { /*Use to implement simd constructors. This is a vector (16 bytes) var.*/ MonoInst *simd_ctor_var; + /* Used to implement dyn_call */ + MonoInst *dyn_call_var; + + /* + * List of sequence points represented as IL offset+native offset pairs. + * Allocated using glib. + * IL offset can be -1 or 0xffffff to refer to the sequence points + * inside the prolog and epilog used to implement method entry/exit events. + */ + GPtrArray *seq_points; + + /* The encoded sequence point info */ + MonoSeqPointInfo *seq_point_info; + /* Used by AOT */ - guint32 got_offset; + guint32 got_offset, ex_info_offset, method_info_offset; + /* Symbol used to refer to this method in generated assembly */ + char *asm_symbol; + + MonoJitExceptionInfo *llvm_ex_info; + guint32 llvm_ex_info_len; } MonoCompile; typedef enum { @@ -1048,19 +1188,6 @@ typedef struct { extern MonoJitStats mono_jit_stats; -/* values for MonoInst.ssa_op */ -enum { - MONO_SSA_NOP = 0, - MONO_SSA_ADDRESS_TAKEN = 1, - MONO_SSA_LOAD = 2, - MONO_SSA_STORE = 4, - MONO_SSA_LOAD_STORE = MONO_SSA_LOAD|MONO_SSA_STORE, - MONO_SSA_INDIRECT_LOAD = MONO_SSA_LOAD|MONO_SSA_ADDRESS_TAKEN, - MONO_SSA_INDIRECT_STORE = MONO_SSA_STORE|MONO_SSA_ADDRESS_TAKEN, - MONO_SSA_INDIRECT_LOAD_STORE = - MONO_SSA_LOAD|MONO_SSA_STORE|MONO_SSA_ADDRESS_TAKEN -}; - /* opcodes: value assigned after all the CIL opcodes */ #ifdef MINI_OP #undef MINI_OP @@ -1124,6 +1251,15 @@ enum { #define OP_STOREP_MEMBASE_IMM OP_STOREI4_MEMBASE_IMM #endif +/* Opcodes to load/store regsize quantities */ +#ifdef __mono_ilp32__ +#define OP_LOADR_MEMBASE OP_LOADI8_MEMBASE +#define OP_STORER_MEMBASE_REG OP_STOREI8_MEMBASE_REG +#else +#define OP_LOADR_MEMBASE OP_LOAD_MEMBASE +#define OP_STORER_MEMBASE_REG OP_STORE_MEMBASE_REG +#endif + typedef enum { STACK_INV, STACK_I4, @@ -1194,6 +1330,15 @@ typedef struct { gboolean mdb_optimizations; gboolean no_gdb_backtrace; gboolean suspend_on_sigsegv; + gboolean dyn_runtime_invoke; + gboolean gdb; + gboolean gen_seq_points; + gboolean explicit_null_checks; + /* + * Fill stack frames with 0x2a in method prologs. This helps with the + * debugging of the stack marking code in the GC. + */ + gboolean init_stacks; } MonoDebugOptions; enum { @@ -1261,9 +1406,13 @@ MonoDebugOptions *mini_get_debug_options (void) MONO_INTERNAL; char* mono_get_runtime_build_info (void) MONO_INTERNAL; /* helper methods */ +void mono_disable_optimizations (guint32 opts) 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; MonoInst* mono_find_spvar_for_region (MonoCompile *cfg, int region) MONO_INTERNAL; +MonoInst* mono_find_exvar_for_offset (MonoCompile *cfg, int offset) MONO_INTERNAL; +int mono_get_block_region_notry (MonoCompile *cfg, int region) MONO_INTERNAL; + void mono_precompile_assemblies (void) MONO_INTERNAL; int mono_parse_default_optimizations (const char* p); void mono_bblock_add_inst (MonoBasicBlock *bb, MonoInst *inst) MONO_INTERNAL; @@ -1321,8 +1470,10 @@ MonoJumpInfo *mono_patch_info_list_prepend (MonoJumpInfo *list, int ip, MonoJum gpointer mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *patch_info, gboolean run_cctors) MONO_INTERNAL; gpointer mono_jit_find_compiled_method_with_jit_info (MonoDomain *domain, MonoMethod *method, MonoJitInfo **ji) MONO_INTERNAL; gpointer mono_jit_find_compiled_method (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; +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; void mono_jit_thread_attach (MonoDomain *domain); guint32 mono_get_jit_tls_key (void) MONO_INTERNAL; gint32 mono_get_jit_tls_offset (void) MONO_INTERNAL; @@ -1345,6 +1496,11 @@ void mono_print_ins_index (int i, MonoInst *ins) MONO_INTERNAL; void mono_print_ins (MonoInst *ins) MONO_INTERNAL; gboolean mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; gboolean mini_method_verify (MonoCompile *cfg, MonoMethod *method) MONO_INTERNAL; +MonoInst *mono_get_got_var (MonoCompile *cfg) MONO_INTERNAL; +void mono_add_seq_point (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, int native_offset) MONO_INTERNAL; +MonoInst* mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args) MONO_INTERNAL; +MonoInst* mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this) MONO_INTERNAL; + gboolean mini_class_is_system_array (MonoClass *klass) MONO_INTERNAL; MonoMethodSignature *mono_get_element_address_signature (int arity) MONO_INTERNAL; @@ -1366,7 +1522,7 @@ gpointer mono_aot_get_method (MonoDomain *domain, gpointer mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token) MONO_INTERNAL; gboolean mono_aot_is_got_entry (guint8 *code, guint8 *addr) MONO_INTERNAL; guint8* mono_aot_get_plt_entry (guint8 *code) MONO_INTERNAL; -guint32 mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) MONO_INTERNAL; +guint32 mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) MONO_INTERNAL; gboolean mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) 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; @@ -1377,29 +1533,39 @@ gpointer mono_aot_get_named_code (const char *name) MONO_INTERNAL; gpointer mono_aot_get_unbox_trampoline (MonoMethod *method) MONO_INTERNAL; gpointer mono_aot_get_lazy_fetch_trampoline (guint32 slot) MONO_INTERNAL; gpointer mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr) MONO_INTERNAL; +gpointer mono_aot_get_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) MONO_INTERNAL; guint8* mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) MONO_INTERNAL; guint32 mono_aot_method_hash (MonoMethod *method) MONO_INTERNAL; char* mono_aot_wrapper_name (MonoMethod *method) MONO_INTERNAL; -MonoAotTrampInfo* mono_aot_tramp_info_create (char *name, guint8 *code, guint32 code_len) MONO_INTERNAL; -gboolean mono_aot_is_shared_got_patch (MonoJumpInfo *patch_info) MONO_INTERNAL; -guint mono_aot_str_hash (gconstpointer v1) MONO_INTERNAL; +MonoAotTrampInfo* mono_aot_tramp_info_create (const char *name, guint8 *code, guint32 code_len) MONO_INTERNAL; +MonoMethod* mono_aot_get_array_helper_from_wrapper (MonoMethod *method) MONO_INTERNAL; +guint32 mono_aot_get_got_offset (MonoJumpInfo *ji) MONO_INTERNAL; +char* mono_aot_get_method_name (MonoCompile *cfg) MONO_INTERNAL; +char* mono_aot_get_plt_symbol (MonoJumpInfoType type, gconstpointer data) MONO_INTERNAL; +char* mono_aot_get_method_debug_name (MonoCompile *cfg) MONO_INTERNAL; +MonoJumpInfo* mono_aot_patch_info_dup (MonoJumpInfo* ji) MONO_INTERNAL; +void mono_aot_set_make_unreadable (gboolean unreadable) MONO_INTERNAL; +gboolean mono_aot_is_pagefault (void *ptr) MONO_INTERNAL; +void mono_aot_handle_pagefault (void *ptr) MONO_INTERNAL; /* This is an exported function */ void mono_aot_register_globals (gpointer *globals); /* This too */ void mono_aot_register_module (gpointer *aot_info); -void mono_xdebug_init (void) MONO_INTERNAL; +void mono_xdebug_init (char *xdebug_opts) MONO_INTERNAL; void mono_save_xdebug_info (MonoCompile *cfg) MONO_INTERNAL; void mono_save_trampoline_xdebug_info (const char *tramp_name, guint8 *code, guint32 code_size, GSList *unwind_info) MONO_INTERNAL; /* This is an exported function */ -void mono_xdebug_emit (void) MONO_INTERNAL; +void mono_xdebug_flush (void) MONO_INTERNAL; /* LLVM backend */ void mono_llvm_init (void) MONO_INTERNAL; void mono_llvm_cleanup (void) MONO_INTERNAL; void mono_llvm_emit_method (MonoCompile *cfg) MONO_INTERNAL; void mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_INTERNAL; +void mono_llvm_create_aot_module (const char *got_symbol) MONO_INTERNAL; +void mono_llvm_emit_aot_module (const char *filename, int got_size) MONO_INTERNAL; gboolean mono_method_blittable (MonoMethod *method) MONO_INTERNAL; gboolean mono_method_same_domain (MonoJitInfo *caller, MonoJitInfo *callee) MONO_INTERNAL; @@ -1435,23 +1601,23 @@ gpointer mono_create_monitor_enter_trampoline (void) MONO_INTERNAL; gpointer mono_create_monitor_exit_trampoline (void) MONO_INTERNAL; gpointer mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) MONO_INTERNAL; gpointer mono_create_llvm_vcall_trampoline (MonoMethod *method) MONO_INTERNAL; +gpointer mono_create_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset) MONO_INTERNAL; MonoVTable* mono_find_class_init_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL; -MonoClass* mono_find_delegate_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL; guint32 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL; -gpointer mono_magic_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8* tramp) MONO_INTERNAL; -gpointer mono_generic_virtual_remoting_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8 *tramp) MONO_INTERNAL; -gpointer mono_delegate_trampoline (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL; -gpointer mono_aot_trampoline (gssize *regs, guint8 *code, guint8 *token_info, +gpointer mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp) MONO_INTERNAL; +gpointer mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp) MONO_INTERNAL; +gpointer mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL; +gpointer mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info, guint8* tramp) MONO_INTERNAL; -gpointer mono_aot_plt_trampoline (gssize *regs, guint8 *code, guint8 *token_info, +gpointer mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info, guint8* tramp) MONO_INTERNAL; -void mono_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL; -void mono_generic_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL; -void mono_monitor_enter_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL; -void mono_monitor_exit_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL; +void mono_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL; +void mono_generic_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL; +void mono_monitor_enter_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL; +void mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL; gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type); -gpointer mini_get_vtable_trampoline (void) MONO_INTERNAL; -gpointer* mono_get_vcall_slot_addr (guint8* code, gpointer *regs) MONO_INTERNAL; +gpointer mini_get_vtable_trampoline (int slot_index) MONO_INTERNAL; +gpointer* mono_get_vcall_slot_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL; gboolean mono_running_on_valgrind (void) MONO_INTERNAL; void* mono_global_codeman_reserve (int size) MONO_INTERNAL; @@ -1497,6 +1663,7 @@ guint32 mono_arch_cpu_optimizazions (guint32 *exclude_mask) MONO_INT void mono_arch_instrument_mem_needs (MonoMethod *method, int *stack, int *code) MONO_INTERNAL; void *mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) MONO_INTERNAL; void *mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) MONO_INTERNAL; +void *mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers) MONO_INTERNAL; void mono_codegen (MonoCompile *cfg) MONO_INTERNAL; void mono_call_inst_add_outarg_reg (MonoCompile *cfg, MonoCallInst *call, int vreg, int hreg, gboolean fp) MONO_INTERNAL; const char *mono_arch_regname (int reg) MONO_INTERNAL; @@ -1543,11 +1710,33 @@ gboolean mono_arch_print_tree (MonoInst *tree, int arity) MONO_INTERNAL; void mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_INTERNAL; void mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src) MONO_INTERNAL; void mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) MONO_INTERNAL; +MonoDynCallInfo *mono_arch_dyn_call_prepare (MonoMethodSignature *sig) MONO_INTERNAL; +void mono_arch_dyn_call_free (MonoDynCallInfo *info) MONO_INTERNAL; +void mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret, guint8 *buf, int buf_len) MONO_INTERNAL; +void mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) MONO_INTERNAL; MonoInst *mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) MONO_INTERNAL; void mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins) MONO_INTERNAL; void mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *ins) MONO_INTERNAL; GSList* mono_arch_get_delegate_invoke_impls (void) MONO_INTERNAL; LLVMCallInfo* mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) MONO_INTERNAL; +guint8* mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji) MONO_INTERNAL; +guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target) MONO_INTERNAL; +GSList* mono_arch_get_cie_program (void) MONO_INTERNAL; + +/* Soft Debug support */ +#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED +void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip) MONO_INTERNAL; +void mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip) MONO_INTERNAL; +void mono_arch_start_single_stepping (void) MONO_INTERNAL; +void mono_arch_stop_single_stepping (void) MONO_INTERNAL; +gboolean mono_arch_is_single_step_event (void *info, void *sigctx) MONO_INTERNAL; +gboolean mono_arch_is_breakpoint_event (void *info, void *sigctx) MONO_INTERNAL; +guint8* mono_arch_get_ip_for_single_step (MonoJitInfo *ji, MonoContext *ctx) MONO_INTERNAL; +guint8* mono_arch_get_ip_for_breakpoint (MonoJitInfo *ji, MonoContext *ctx) MONO_INTERNAL; +void mono_arch_skip_breakpoint (MonoContext *ctx) MONO_INTERNAL; +void mono_arch_skip_single_step (MonoContext *ctx) MONO_INTERNAL; +gpointer mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) MONO_INTERNAL; +#endif MonoJitInfo *mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, @@ -1557,6 +1746,11 @@ MonoJitInfo *mono_arch_find_jit_info (MonoDomain *domain, MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed) MONO_INTERNAL; +gboolean +mono_arch_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls, + MonoJitInfo *ji, MonoContext *ctx, + MonoContext *new_ctx, MonoLMF **lmf, + StackFrameInfo *frame_info) MONO_INTERNAL; gpointer mono_arch_get_call_filter (void) MONO_INTERNAL; gpointer mono_arch_get_restore_context (void) MONO_INTERNAL; gpointer mono_arch_get_call_filter_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot) MONO_INTERNAL; @@ -1576,47 +1770,59 @@ gpointer mono_arch_context_get_int_reg (MonoContext *ctx, int reg) MONO_INTERNA void mono_arch_flush_register_windows (void) MONO_INTERNAL; gboolean mono_arch_is_inst_imm (gint64 imm) MONO_INTERNAL; MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg) MONO_INTERNAL; -MonoInst* mono_arch_get_thread_intrinsic (MonoCompile* cfg) MONO_INTERNAL; gboolean mono_arch_is_int_overflow (void *sigctx, void *info) MONO_INTERNAL; void mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg) MONO_INTERNAL; guint32 mono_arch_get_patch_offset (guint8 *code) MONO_INTERNAL; -gpointer mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement) MONO_INTERNAL; -gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, gpointer *regs) MONO_INTERNAL; +gpointer mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement) MONO_INTERNAL; +gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL; void mono_arch_create_vars (MonoCompile *cfg) MONO_INTERNAL; void mono_arch_save_unwind_info (MonoCompile *cfg) MONO_INTERNAL; void mono_arch_register_lowlevel_calls (void) MONO_INTERNAL; gpointer mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr) MONO_INTERNAL; gpointer mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) MONO_INTERNAL; +gpointer mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *method, int vt_offset) MONO_INTERNAL; void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr) MONO_INTERNAL; -void mono_arch_patch_plt_entry (guint8 *code, guint8 *addr) MONO_INTERNAL; -void mono_arch_nullify_class_init_trampoline(guint8 *code, gssize *regs) MONO_INTERNAL; -void mono_arch_nullify_plt_entry (guint8 *code) 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 (MonoMethodSignature *sig, MonoGenericSharingContext *gsctx, guint8 *code) MONO_INTERNAL; -gpointer mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code) MONO_INTERNAL; -MonoObject* mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx) MONO_INTERNAL; +gpointer mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code) MONO_INTERNAL; gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target) MONO_INTERNAL; gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL; void mono_arch_emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg) MONO_INTERNAL; -MonoMethod* mono_arch_find_imt_method (gpointer *regs, guint8 *code) MONO_INTERNAL; -MonoVTable* mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code) MONO_INTERNAL; +MonoMethod* mono_arch_find_imt_method (mgreg_t *regs, guint8 *code) MONO_INTERNAL; +MonoVTable* mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code) MONO_INTERNAL; gpointer mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) MONO_INTERNAL; void mono_arch_notify_pending_exc (void) MONO_INTERNAL; -void mono_arch_fixup_jinfo (MonoCompile *cfg) MONO_INTERNAL; /* Exception handling */ + +/* Same as MonoStackWalk, but pass the context/frame type as well */ +typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoContext *ctx, gpointer data); + void mono_exceptions_init (void) MONO_INTERNAL; gboolean mono_handle_exception (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean test_only) 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); void mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) MONO_INTERNAL; void mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *ctx, gboolean do_il_offset, gpointer user_data) MONO_INTERNAL; +void mono_jit_walk_stack_from_ctx_in_thread (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, gboolean do_il_offset, MonoInternalThread *thread, MonoLMF *lmf, gpointer user_data) MONO_INTERNAL; void mono_setup_altstack (MonoJitTlsData *tls) MONO_INTERNAL; void mono_free_altstack (MonoJitTlsData *tls) MONO_INTERNAL; -gpointer mono_altstack_restore_prot (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL; +gpointer mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL; +MonoJitInfo* mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain) MONO_INTERNAL; +void mono_resume_unwind (void) MONO_INTERNAL; MonoJitInfo * mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset, gboolean *managed) MONO_INTERNAL; +gboolean +mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls, + MonoJitInfo *prev_ji, MonoContext *ctx, + MonoContext *new_ctx, char **trace, MonoLMF **lmf, + StackFrameInfo *frame) MONO_INTERNAL; + gpointer mono_get_throw_exception (void) MONO_INTERNAL; gpointer mono_get_rethrow_exception (void) MONO_INTERNAL; gpointer mono_get_call_filter (void) MONO_INTERNAL; @@ -1670,10 +1876,15 @@ 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); +#ifdef MONO_DEBUGGER_SUPPORTED + /* Mono Debugger support */ -void mono_debugger_init (void); -int mono_debugger_main (MonoDomain *domain, MonoAssembly *assembly, int argc, char **argv); +void mini_debugger_init (void); +int mini_debugger_main (MonoDomain *domain, MonoAssembly *assembly, int argc, char **argv); +gboolean mini_debug_running_inside_mdb (void); +void mini_debugger_set_attach_ok (void); +#endif /* Tracing */ MonoTraceSpec *mono_trace_parse_options (const char *options) MONO_INTERNAL; @@ -1779,6 +1990,8 @@ void mono_runtime_cleanup_handlers (void) MONO_INTERNAL; void mono_runtime_setup_stat_profiler (void) MONO_INTERNAL; void mono_runtime_shutdown_stat_profiler (void) MONO_INTERNAL; void mono_runtime_posix_install_handlers (void) MONO_INTERNAL; +pid_t mono_runtime_syscall_fork (void) MONO_INTERNAL; +gboolean mono_gdb_render_native_backtraces (void) MONO_INTERNAL; /* * Signal handling @@ -1788,9 +2001,9 @@ void mono_runtime_posix_install_handlers (void) MONO_INTERNAL; #endif #ifndef GET_CONTEXT -#ifdef PLATFORM_WIN32 +#ifdef HOST_WIN32 #define GET_CONTEXT \ - struct sigcontext *ctx = (struct sigcontext*)_dummy; + void *ctx = context; #else #ifdef MONO_ARCH_USE_SIGACTION #define GET_CONTEXT \ @@ -1809,6 +2022,9 @@ void mono_runtime_posix_install_handlers (void) MONO_INTERNAL; #ifdef MONO_ARCH_USE_SIGACTION #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, siginfo_t *info, void *context) #define SIG_HANDLER_PARAMS _dummy, info, context +#elif defined(HOST_WIN32) +#define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, EXCEPTION_RECORD *info, void *context) +#define SIG_HANDLER_PARAMS _dummy, info, context #elif defined(__sparc__) #define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, void *sigctx) #define SIG_HANDLER_PARAMS _dummy, sigctx @@ -1823,10 +2039,11 @@ 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; -/* for MONO_WRAPPER_UNKNOWN subtypes */ +/* for MONO_WRAPPER_UNKNOWN/MANAGED_TO_MANAGED subtypes */ enum { MONO_AOT_WRAPPER_MONO_ENTER, MONO_AOT_WRAPPER_MONO_EXIT, + MONO_AOT_WRAPPER_ELEMENT_ADDR, MONO_AOT_WRAPPER_LAST };