#endif
/* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION 125
+#define MONO_AOT_FILE_VERSION 129
//TODO: This is x86/amd64 specific.
#define mono_simd_shuffle_mask(a,b,c,d) ((a) | ((b) << 2) | ((c) << 4) | ((d) << 6))
MONO_AOT_FILE_FLAG_LLVM_THUMB = 8,
MONO_AOT_FILE_FLAG_LLVM_ONLY = 16,
MONO_AOT_FILE_FLAG_SAFEPOINTS = 32,
+ MONO_AOT_FILE_FLAG_SEPARATE_DATA = 64,
} MonoAotFileFlags;
+typedef enum {
+ MONO_AOT_TABLE_BLOB,
+ MONO_AOT_TABLE_IMAGE_TABLE,
+ MONO_AOT_TABLE_CLASS_NAME,
+ MONO_AOT_TABLE_METHOD_INFO_OFFSETS,
+ MONO_AOT_TABLE_EX_INFO_OFFSETS,
+ MONO_AOT_TABLE_CLASS_INFO_OFFSETS,
+ MONO_AOT_TABLE_GOT_INFO_OFFSETS,
+ MONO_AOT_TABLE_LLVM_GOT_INFO_OFFSETS,
+ MONO_AOT_TABLE_EXTRA_METHOD_INFO_OFFSETS,
+ MONO_AOT_TABLE_EXTRA_METHOD_TABLE,
+ MONO_AOT_TABLE_NUM
+} MonoAotFileTable;
+
/* This structure is stored in the AOT file */
typedef struct MonoAotFileInfo
{
gpointer extra_method_table;
gpointer got_info_offsets;
gpointer llvm_got_info_offsets;
- gpointer mem_end;
gpointer image_table;
+ gpointer mem_end;
/* The GUID of the assembly which the AOT image was generated from */
gpointer assembly_guid;
/*
* module is loaded.
*/
guint32 nshared_got_entries;
+ /* The size of the data file, if MONO_AOT_FILE_FLAG_SEPARATE_DATA is set */
+ guint32 datafile_size;
+
/* Arrays */
+ /* Offsets for tables inside the data file if MONO_AOT_FILE_FLAG_SEPARATE_DATA is set */
+ // FIXME: Sync with AOT
+ guint32 table_offsets [MONO_AOT_TABLE_NUM];
/* Number of trampolines */
guint32 num_trampolines [MONO_AOT_TRAMP_NUM];
/* The indexes of the first GOT slots used by the trampolines */
} while (0)
#define MONO_INST_NEW(cfg,dest,op) do { \
- (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
+ (dest) = (MonoInst *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->opcode = (op); \
(dest)->dreg = -1; \
MONO_INST_NULLIFY_SREGS ((dest)); \
} while (0)
#define MONO_INST_NEW_CALL(cfg,dest,op) do { \
- (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); \
+ (dest) = (MonoCallInst *)mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoCallInst)); \
(dest)->inst.opcode = (op); \
(dest)->inst.dreg = -1; \
MONO_INST_NULLIFY_SREGS (&(dest)->inst); \
LLVMArgVtypeByVal,
LLVMArgVtypeRetAddr, /* On on cinfo->ret */
LLVMArgGSharedVt,
+ /* Fixed size argument passed to/returned from gsharedvt method by ref */
+ LLVMArgGsharedvtFixed,
+ /* Fixed size vtype argument passed to/returned from gsharedvt method by ref */
+ LLVMArgGsharedvtFixedVtype,
+ /* Variable sized argument passed to/returned from gsharedvt method by ref */
+ LLVMArgGsharedvtVariable,
/* Vtype passed as one int array argument */
LLVMArgAsIArgs,
/* Vtype passed as a set of fp arguments */
/* Parameter index in the LLVM signature */
int pindex;
MonoType *type;
+ /* Only if storage == LLVMArgAsFpArgs. Dummy fp args to insert before this arg */
+ int ndummy_fpargs;
} LLVMArgInfo;
typedef struct {
* Set on instructions during code emission which make calls, i.e. OP_CALL, OP_THROW.
* backend.pc_offset will be set to the pc offset at the end of the native call instructions.
*/
- MONO_INST_GC_CALLSITE = 128
+ MONO_INST_GC_CALLSITE = 128,
+ /* On comparisons, mark the branch following the condition as likely to be taken */
+ MONO_INST_LIKELY = 128,
};
#define inst_c0 data.op[0].const_val
MONO_GENERIC_CONTEXT_USED_METHOD = 2
};
+enum {
+ /* Cannot be 0 since this is stored in rgctx slots, and 0 means an unitialized rgctx slot */
+ MONO_GSHAREDVT_BOX_TYPE_VTYPE = 1,
+ MONO_GSHAREDVT_BOX_TYPE_REF = 2,
+ MONO_GSHAREDVT_BOX_TYPE_NULLABLE = 3
+};
+
typedef enum {
MONO_RGCTX_INFO_STATIC_DATA,
MONO_RGCTX_INFO_KLASS,
MONO_RGCTX_INFO_TYPE,
MONO_RGCTX_INFO_REFLECTION_TYPE,
MONO_RGCTX_INFO_METHOD,
+ /* In llvmonly mode, this is a function descriptor */
MONO_RGCTX_INFO_GENERIC_METHOD_CODE,
MONO_RGCTX_INFO_CLASS_FIELD,
MONO_RGCTX_INFO_METHOD_RGCTX,
MONO_RGCTX_INFO_CAST_CACHE,
MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE,
MONO_RGCTX_INFO_VALUE_SIZE,
+ /* +1 to avoid zero values in rgctx slots */
MONO_RGCTX_INFO_FIELD_OFFSET,
/* Either the code for a gsharedvt method, or the address for a gsharedvt-out trampoline for the method */
+ /* In llvmonly mode, this is a function descriptor */
MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE,
/* Same for virtual calls */
+ /* In llvmonly mode, this is a function descriptor */
MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT,
/* Same for calli, associated with a signature */
MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI,
- /*
- * 0 - vtype
- * 1 - ref
- * 2 - gsharedvt type
- */
+ /* One of MONO_GSHAREDVT_BOX_TYPE */
MONO_RGCTX_INFO_CLASS_BOX_TYPE,
/* Resolves to a MonoGSharedVtMethodRuntimeInfo */
MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO,
MONO_RGCTX_INFO_MEMCPY,
MONO_RGCTX_INFO_BZERO,
/* The address of Nullable<T>.Box () */
+ /* In llvmonly mode, this is a function descriptor */
MONO_RGCTX_INFO_NULLABLE_CLASS_BOX,
MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX,
/* MONO_PATCH_INFO_VCALL_METHOD */
gboolean need_rgctx_tramp;
} MonoDelegateTrampInfo;
+/*
+ * A function descriptor, which is a function address + argument pair.
+ * In llvm-only mode, these are used instead of trampolines to pass
+ * extra arguments to runtime functions/methods.
+ */
+typedef struct
+{
+ gpointer addr;
+ gpointer arg;
+} MonoFtnDesc;
+
typedef enum {
#define PATCH_INFO(a,b) MONO_PATCH_INFO_ ## a,
#include "patch-info.h"
/* DWARF location list for 'rgctx_var' */
GSList *rgctx_loclist;
+ int *gsharedvt_vreg_to_idx;
+
+ GSList *signatures;
+
/* GC Maps */
/* The offsets of the locals area relative to the frame pointer */
#define OP_DUMMY_PCONST OP_DUMMY_I8CONST
#define OP_PADD OP_LADD
#define OP_PADD_IMM OP_LADD_IMM
+#define OP_PSUB_IMM OP_LSUB_IMM
#define OP_PAND_IMM OP_LAND_IMM
+#define OP_PXOR_IMM OP_LXOR_IMM
#define OP_PSUB OP_LSUB
#define OP_PMUL OP_LMUL
#define OP_PMUL_IMM OP_LMUL_IMM
#define OP_DUMMY_PCONST OP_DUMMY_ICONST
#define OP_PADD OP_IADD
#define OP_PADD_IMM OP_IADD_IMM
+#define OP_PSUB_IMM OP_ISUB_IMM
#define OP_PAND_IMM OP_IAND_IMM
+#define OP_PXOR_IMM OP_IXOR_IMM
#define OP_PSUB OP_ISUB
#define OP_PMUL OP_IMUL
#define OP_PMUL_IMM OP_IMUL_IMM
/* main function */
MONO_API int mono_main (int argc, char* argv[]);
MONO_API void mono_set_defaults (int verbose_level, guint32 opts);
-void mono_parse_env_options (int argc, char *argv []);
+MONO_API void mono_parse_env_options (int *ref_argc, char **ref_argv []);
MonoDomain* mini_init (const char *filename, const char *runtime_version);
void mini_cleanup (MonoDomain *domain);
MONO_API MonoDebugOptions *mini_get_debug_options (void);
+MONO_API gboolean mini_parse_debug_option (const char *option);
/* helper methods */
void mini_jit_init (void);
void mono_aot_init_gshared_method_rgctx (gpointer aot_module, guint32 method_index, MonoMethodRuntimeGenericContext *rgctx);
/* This is an exported function */
-MONO_API void mono_aot_register_globals (gpointer *globals);
-/* This too */
MONO_API void mono_aot_register_module (gpointer *aot_info);
+/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */
+/*
+ * Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later
+ * passed to the free function.
+ */
+typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, gpointer user_data, void **out_handle);
+/* Not yet used */
+typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, gpointer user_data, void *handle);
+MONO_API void mono_install_load_aot_data_hook (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, gpointer user_data);
+
void mono_xdebug_init (const char *xdebug_opts);
void mono_save_xdebug_info (MonoCompile *cfg);
void mono_save_trampoline_xdebug_info (MonoTrampInfo *info);
/* This is an exported function */
void mono_xdebug_flush (void);
-/* LLVM backend */
-/* 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 (MonoAssembly *assembly, const char *global_prefix, gboolean emit_dwarf, gboolean static_link, gboolean llvm_only) 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);
-int mono_llvm_load (const char* bpath);
-void mono_llvm_rethrow_exception (MonoObject *ex);
-void mono_llvm_throw_exception (MonoObject *ex);
-void mono_llvm_throw_corlib_exception (guint32 ex_token_index);
-void mono_llvm_resume_exception (void);
-gint32 mono_llvm_match_exception (MonoJitInfo *jinfo, guint32 region_start, guint32 region_end);
-void mono_llvm_clear_exception (void);
-MonoObject *mono_llvm_load_exception (void);
-void mono_llvm_reset_exception (void);
-void mono_llvm_raise_exception (MonoException *e);
-
-gboolean mini_llvm_init (void);
-
gboolean mono_method_blittable (MonoMethod *method);
gboolean mono_method_same_domain (MonoJitInfo *caller, MonoJitInfo *callee);
gpointer mono_create_monitor_enter_v4_trampoline (void);
gpointer mono_create_monitor_exit_trampoline (void);
gpointer mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr);
-gpointer mono_create_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset) MONO_LLVM_INTERNAL;
MonoVTable* mono_find_class_init_trampoline_by_addr (gconstpointer addr);
guint32 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr);
gpointer mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp);
void mono_monitor_enter_v4_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp);
void mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp);
gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type);
-gpointer mini_get_vtable_trampoline (int slot_index);
+gpointer mini_get_vtable_trampoline (MonoVTable *vt, int slot_index);
const char* mono_get_generic_trampoline_simple_name (MonoTrampolineType tramp_type);
char* mono_get_generic_trampoline_name (MonoTrampolineType tramp_type);
char* mono_get_rgctx_fetch_trampoline_name (int slot);
gpointer mini_get_single_step_trampoline (void);
gpointer mini_get_breakpoint_trampoline (void);
gpointer mini_add_method_trampoline (MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp);
+gpointer mini_add_method_wrappers_llvmonly (MonoMethod *m, gpointer compiled_method, gboolean caller_gsharedvt, gboolean add_unbox_tramp, gpointer *out_arg);
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);
+MonoFtnDesc *mini_create_llvmonly_ftndesc (MonoDomain *domain, gpointer addr, gpointer arg);
gboolean mono_running_on_valgrind (void);
void* mono_global_codeman_reserve (int size);
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_decompose_array_access_opts (MonoCompile *cfg);
void mono_decompose_soft_float (MonoCompile *cfg);
void mono_handle_global_vregs (MonoCompile *cfg);
void mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts);
+void mono_allocate_gsharedvt_vars (MonoCompile *cfg);
void mono_if_conversion (MonoCompile *cfg);
/* virtual function delegate */
GSList* mono_arch_get_delegate_invoke_impls (void);
LLVMCallInfo* mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) MONO_LLVM_INTERNAL;
guint8* mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji);
-guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target);
+guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target);
GSList* mono_arch_get_cie_program (void);
void mono_arch_set_target (char *mtriple);
gboolean mono_arch_gsharedvt_sig_supported (MonoMethodSignature *sig);
void mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg);
guint32 mono_arch_get_patch_offset (guint8 *code);
gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs);
-void mono_arch_create_vars (MonoCompile *cfg);
+void mono_arch_create_vars (MonoCompile *cfg) MONO_LLVM_INTERNAL;
void mono_arch_save_unwind_info (MonoCompile *cfg);
void mono_arch_register_lowlevel_calls (void);
gpointer mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr);
typedef gboolean (*MonoJitStackWalk) (StackFrameInfo *frame, MonoContext *ctx, gpointer data);
void mono_exceptions_init (void);
-gboolean mono_handle_exception (MonoContext *ctx, gpointer obj);
+gboolean mono_handle_exception (MonoContext *ctx, MonoObject *obj);
void mono_handle_native_sigsegv (int signal, void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo);
MONO_API void mono_print_thread_dump (void *sigctx);
MONO_API void mono_print_thread_dump_from_ctx (MonoContext *ctx);
MonoBitSet* mono_compile_iterated_dfrontier (MonoCompile *cfg, MonoBitSet *set);
void mono_ssa_compute (MonoCompile *cfg);
void mono_ssa_remove (MonoCompile *cfg);
+void mono_ssa_remove_gsharedvt (MonoCompile *cfg);
void mono_ssa_cprop (MonoCompile *cfg);
void mono_ssa_deadce (MonoCompile *cfg);
void mono_ssa_strength_reduction (MonoCompile *cfg);
gpointer mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig,
gint32 vcall_offset, gboolean calli);
+MonoMethod* mini_get_gsharedvt_in_sig_wrapper (MonoMethodSignature *sig);
+MonoMethod* mini_get_gsharedvt_out_sig_wrapper (MonoMethodSignature *sig);
+MonoMethodSignature* mini_get_gsharedvt_out_sig_wrapper_signature (gboolean has_this, gboolean has_ret, int param_count);
+gboolean mini_gsharedvt_runtime_invoke_supported (MonoMethodSignature *sig);
/* SIMD support */
projects / mono.git / blobdiff