#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)
#define LLVM_ENABLED FALSE
#endif
+#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 */
#endif
/* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION "57"
+#define MONO_AOT_FILE_VERSION "68"
+
+//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 {
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
{
/* 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 {
#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++)\
(ins)->opcode = OP_NOP; \
(ins)->dreg = -1; \
MONO_INST_NULLIFY_SREGS ((ins)); \
- (ins)->ssa_op = MONO_SSA_NOP; \
} while (0)
/* Remove INS from BB */
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;
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])
#define mono_bb_first_ins(bb) (bb)->code
-struct MonoEdge {
- MonoEdge *next;
- MonoBasicBlock *bb;
- /* add edge type? */
-};
-
struct MonoSpillInfo {
int offset;
};
/* Length of the CIL block */
gint32 cil_length;
- /* The address of the generated code, used for fixups */
+ /* The offset of the generated code, used for fixups */
int native_offset;
+ int native_length;
int max_offset;
int max_length;
GSList *dominated;
/* fast dominator algorithm */
MonoBasicBlock *df_parent, *ancestor, *child, *label;
- MonoEdge *bucket;
int size, sdom, idomn;
/* loop nesting and recognition */
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;
/* 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.
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;
MonoClass *klass;
int *phi_args;
MonoCallInst *call_inst;
+ MonoExceptionClause *exception_clause;
} op [2];
gint64 i8const;
double r8const;
*/
enum {
MONO_INST_HAS_METHOD = 1,
- /* 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_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
#define inst_call data.op[1].call_inst
#define inst_phi_args data.op[1].phi_args
+#define inst_eh_block data.op[1].exception_clause
/* instruction description for use in regalloc/scheduling */
enum {
guint32 signal_stack_size;
gpointer stack_ovf_guard_base;
guint32 stack_ovf_guard_size;
+ guint stack_ovf_valloced : 1;
void (*abort_func) (MonoObject *object);
/* Used to implement --debug=casts */
MonoClass *class_cast_from, *class_cast_to;
+
+ /* Stores state needed by mono_resume_unwind () and the handler block with a guard */
+ MonoContext ex_ctx;
+ /* FIXME: GC */
+ gpointer ex_obj;
+ /* handle block return address */
+ gpointer handler_block_return_address;
+ /* handler block been guarded */
+ MonoJitExceptionInfo *handler_block;
} MonoJitTlsData;
typedef enum {
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;
MonoJumpInfoToken *token;
MonoJumpInfoBBTable *table;
MonoJumpInfoRgctxEntry *rgctx_entry;
+ MonoJumpInfoImtTramp *imt_tramp;
} data;
};
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
+#ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
+ MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD,
#endif
MONO_TRAMPOLINE_NUM
} MonoTrampolineType;
*/
typedef struct {
MonoMethod *method;
+ MonoMethodHeader *header;
MonoMemPool *mempool;
MonoInst **varinfo;
MonoMethodVar *vars;
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 */
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;
/*
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;
/*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;
+
+ GSList *try_block_holes;
} MonoCompile;
typedef enum {
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
#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,
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 {
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;
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;
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;
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;
gpointer mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code) MONO_INTERNAL;
+void mono_aot_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
gpointer mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot) MONO_INTERNAL;
gpointer mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
gpointer mono_aot_get_named_code (const char *name) 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 (const char *name, guint8 *code, guint32 code_len) MONO_INTERNAL;
-guint mono_aot_str_hash (gconstpointer v1) 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;
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;
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;
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,
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;
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;
+/* Handle block guard */
+gpointer mono_arch_install_handler_block_guard (MonoJitInfo *ji, MonoJitExceptionInfo *clause, MonoContext *ctx, gpointer new_value) MONO_INTERNAL;
+gpointer mono_arch_create_handler_block_trampoline (void) MONO_INTERNAL;
+gpointer mono_create_handler_block_trampoline (void) MONO_INTERNAL;
+gboolean mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx) 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;
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
/* Generic sharing */
+
+void
+mono_set_generic_sharing_supported (gboolean supported) MONO_INTERNAL;
+
+gboolean
+mono_class_generic_sharing_enabled (MonoClass *class) MONO_INTERNAL;
+
+gpointer
+mono_class_fill_runtime_generic_context (MonoVTable *class_vtable, guint32 slot) MONO_INTERNAL;
+
+gpointer
+mono_method_fill_runtime_generic_context (MonoMethodRuntimeGenericContext *mrgctx, guint32 slot) MONO_INTERNAL;
+
+MonoMethodRuntimeGenericContext*
+mono_method_lookup_rgctx (MonoVTable *class_vtable, MonoGenericInst *method_inst) MONO_INTERNAL;
+
+gboolean
+mono_method_needs_static_rgctx_invoke (MonoMethod *method, gboolean allow_type_vars) MONO_INTERNAL;
+
+int
+mono_class_rgctx_get_array_size (int n, gboolean mrgctx) MONO_INTERNAL;
+
+guint32
+mono_method_lookup_or_register_other_info (MonoMethod *method, gboolean in_mrgctx, gpointer data,
+ int info_type, MonoGenericContext *generic_context) MONO_INTERNAL;
+
+MonoGenericContext
+mono_method_construct_object_context (MonoMethod *method) MONO_INTERNAL;
+
+int
+mono_generic_context_check_used (MonoGenericContext *context) MONO_INTERNAL;
+
+int
+mono_class_check_context_used (MonoClass *class) MONO_INTERNAL;
+
+gboolean
+mono_generic_context_is_sharable (MonoGenericContext *context, gboolean allow_type_vars) MONO_INTERNAL;
+
+gboolean
+mono_generic_context_is_sharable_full (MonoGenericContext *context, gboolean allow_type_vars, gboolean allow_partial) MONO_INTERNAL;
+
+gboolean
+mono_method_is_generic_impl (MonoMethod *method) MONO_INTERNAL;
+
+gboolean
+mono_method_is_generic_sharable_impl (MonoMethod *method, gboolean allow_type_vars) MONO_INTERNAL;
+
+gboolean
+mono_method_is_generic_sharable_impl_full (MonoMethod *method, gboolean allow_type_vars, gboolean allow_partial) MONO_INTERNAL;
+
+gboolean
+mono_is_partially_sharable_inst (MonoGenericInst *inst) MONO_INTERNAL;
+
MonoGenericSharingContext* mono_get_generic_context_from_code (guint8 *code) MONO_INTERNAL;
MonoGenericContext* mini_method_get_context (MonoMethod *method) MONO_INTERNAL;
MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
+MonoMethod* mini_get_shared_method (MonoMethod *method) MONO_INTERNAL;
+MonoMethod* mini_get_shared_method_to_register (MonoMethod *method) MONO_INTERNAL;
int mini_type_stack_size (MonoGenericSharingContext *gsctx, MonoType *t, int *align) MONO_INTERNAL;
int mini_type_stack_size_full (MonoGenericSharingContext *gsctx, MonoType *t, guint32 *align, gboolean pinvoke) MONO_INTERNAL;
void type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst) MONO_INTERNAL;
guint mono_type_to_regmove (MonoCompile *cfg, MonoType *type) MONO_INTERNAL;
+void mono_cfg_add_try_hole (MonoCompile *cfg, MonoExceptionClause *clause, guint8 *start, MonoBasicBlock *bb) MONO_INTERNAL;
+
/* wapihandles.c */
int mini_wapi_hps (int argc, char **argv) MONO_INTERNAL;
/*
This enum MUST be kept in sync with its managed mirror Mono.Simd.AccelMode.
-The AccelMode values are masks while the ones here are the bit indexes.
*/
enum {
- SIMD_VERSION_SSE1 = 0,
- SIMD_VERSION_SSE2 = 1,
- SIMD_VERSION_SSE3 = 2,
- SIMD_VERSION_SSSE3 = 3,
- SIMD_VERSION_SSE41 = 4,
- SIMD_VERSION_SSE42 = 5,
- SIMD_VERSION_SSE4a = 6,
+ SIMD_VERSION_SSE1 = 1 << 0,
+ SIMD_VERSION_SSE2 = 1 << 1,
+ SIMD_VERSION_SSE3 = 1 << 2,
+ SIMD_VERSION_SSSE3 = 1 << 3,
+ SIMD_VERSION_SSE41 = 1 << 4,
+ SIMD_VERSION_SSE42 = 1 << 5,
+ SIMD_VERSION_SSE4a = 1 << 6,
+ SIMD_VERSION_ALL = SIMD_VERSION_SSE1 | SIMD_VERSION_SSE2 |
+ SIMD_VERSION_SSE3 | SIMD_VERSION_SSSE3 |
+ SIMD_VERSION_SSE41 | SIMD_VERSION_SSE42 |
+ SIMD_VERSION_SSE4a,
+
+ /* this value marks the end of the bit indexes used in
+ * this emum.
+ */
+ SIMD_VERSION_INDEX_END = 6
};
+#define MASK(x) (1 << x)
+
enum {
SIMD_COMP_EQ,
SIMD_COMP_LT,
guint32 mono_arch_cpu_enumerate_simd_versions (void) MONO_INTERNAL;
void mono_simd_intrinsics_init (void) MONO_INTERNAL;
+#ifdef __linux__
+/* maybe enable also for other systems? */
+#define ENABLE_JIT_MAP 1
+void mono_enable_jit_map (void) MONO_INTERNAL;
+void mono_emit_jit_map (MonoJitInfo *jinfo) MONO_INTERNAL;
+void mono_emit_jit_tramp (void *start, int size, const char *desc) MONO_INTERNAL;
+#else
+#define mono_enable_jit_map()
+#define mono_emit_jit_map(ji)
+#define mono_emit_jit_tramp(s,z,d)
+#endif
+
/*
* Per-OS implementation functions.
*/
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
#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 \
void *ctx = context;
-#elif defined(__sparc__)
+#elif defined(__HAIKU__)
#define GET_CONTEXT \
- void *ctx = sigctx;
+ void *ctx = ®s;
#else
#define GET_CONTEXT \
void **_p = (void **)&_dummy; \
#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(__sparc__)
-#define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, void *sigctx)
-#define SIG_HANDLER_PARAMS _dummy, sigctx
+#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(__HAIKU__)
+#define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy, void *userData, vregs regs)
+#define SIG_HANDLER_PARAMS _dummy, userData, regs
#else
#define SIG_HANDLER_SIGNATURE(ftn) ftn (int _dummy)
#define SIG_HANDLER_PARAMS _dummy
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
};
projects / mono.git / blobdiff