X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Faot-runtime.c;h=af8894e170c20fcad0dc0839688690423a23186f;hb=af9204d60eb58a7ae2a8b023356920cf3cbbd525;hp=cdee980f62fee351cd48ef4b2a0e577ba5199434;hpb=ee0315162ce1c161705a067388d35e9506e8e992;p=mono.git diff --git a/mono/mini/aot-runtime.c b/mono/mini/aot-runtime.c index cdee980f62f..af8894e170c 100644 --- a/mono/mini/aot-runtime.c +++ b/mono/mini/aot-runtime.c @@ -19,7 +19,7 @@ #include #endif -#if PLATFORM_WIN32 +#if HOST_WIN32 #include #include #endif @@ -35,6 +35,10 @@ #include /* for WIFEXITED, WEXITSTATUS */ #endif +#ifdef HAVE_DL_ITERATE_PHDR +#include +#endif + #include #include #include @@ -57,9 +61,9 @@ #ifndef DISABLE_AOT -#ifdef PLATFORM_WIN32 +#ifdef TARGET_WIN32 #define SHARED_EXT ".dll" -#elif (defined(__ppc__) || defined(__powerpc__) || defined(__ppc64__)) || defined(__MACH__) +#elif ((defined(__ppc__) || defined(__powerpc__) || defined(__ppc64__)) || defined(__MACH__)) && !defined(__linux__) #define SHARED_EXT ".dylib" #else #define SHARED_EXT ".so" @@ -70,11 +74,8 @@ typedef struct MonoAotModule { char *aot_name; - /* Optimization flags used to compile the module */ - guint32 opts; /* Pointer to the Global Offset Table */ gpointer *got; - guint32 got_size, plt_size; GHashTable *name_cache; GHashTable *extra_methods; /* Maps methods to their code */ @@ -94,52 +95,39 @@ typedef struct MonoAotModule { guint8 *code_end; guint8 *plt; guint8 *plt_end; - guint32 plt_got_offset_base; - guint32 *code_offsets; - guint8 *method_info; + guint8 *blob; + gint32 *code_offsets; + /* This contains pairs sorted by offset */ + /* This is needed because LLVM emitted methods can be in any order */ + gint32 *sorted_code_offsets; guint32 *method_info_offsets; - guint8 *got_info; guint32 *got_info_offsets; - guint8 *ex_info; guint32 *ex_info_offsets; - guint32 *method_order; - guint32 *method_order_end; - guint8 *class_info; guint32 *class_info_offsets; guint32 *methods_loaded; guint16 *class_name_table; guint32 *extra_method_table; guint32 *extra_method_info_offsets; - guint8 *extra_method_info; guint8 *unwind_info; - guint8 *specific_trampolines; - guint32 num_specific_trampolines, specific_trampoline_got_offset_base; - guint32 specific_trampoline_index, specific_trampoline_size; + /* Points to the GNU .eh_frame_hdr section, if it exists */ + guint8 *eh_frame_hdr; + + /* Points to the .ARM.exidx section, if it exists */ + guint8 *arm_exidx; + guint32 arm_exidx_size; + + /* Points to the trampolines */ + guint8 *trampolines [MONO_AOT_TRAMP_NUM]; + /* The first unused trampoline of each kind */ + guint32 trampoline_index [MONO_AOT_TRAMP_NUM]; - guint8 *static_rgctx_trampolines; - guint32 num_static_rgctx_trampolines, static_rgctx_trampoline_got_offset_base; - guint32 static_rgctx_trampoline_index, static_rgctx_trampoline_size; + MonoAotFileInfo info; gpointer *globals; MonoDl *sofile; } MonoAotModule; -/* This structure is stored in the AOT file */ -typedef struct MonoAotFileInfo -{ - guint32 plt_got_offset_base; - guint32 got_size; - guint32 plt_size; - guint32 num_specific_trampolines; - guint32 specific_trampoline_size; - guint32 specific_trampoline_got_offset_base; - guint32 num_static_rgctx_trampolines; - guint32 static_rgctx_trampoline_size; - guint32 static_rgctx_trampoline_got_offset_base; - gpointer *got; -} MonoAotFileInfo; - static GHashTable *aot_modules; #define mono_aot_lock() EnterCriticalSection (&aot_mutex) #define mono_aot_unlock() LeaveCriticalSection (&aot_mutex) @@ -152,13 +140,10 @@ static CRITICAL_SECTION aot_mutex; static GHashTable *static_aot_modules; /* - * Disabling this will make a copy of the loaded code and use the copy instead - * of the original. This will place the caller and the callee close to each - * other in memory, possibly improving cache behavior. Since the original - * code is in copy-on-write memory, this will not increase the memory usage - * of the runtime. + * Maps MonoJitInfo* to the aot module they belong to, this can be different + * from ji->method->klass->image's aot module for generic instances. */ -static gboolean use_loaded_code = TRUE; +static GHashTable *ji_to_amodule; /* * Whenever to AOT compile loaded assemblies on demand and store them in @@ -182,52 +167,55 @@ static guint32 name_table_accesses = 0; static gsize aot_code_low_addr = (gssize)-1; static gsize aot_code_high_addr = 0; -/* Used to communicate with mono_aot_register_globals () */ -static guint32 globals_tls_id = -1; - static void init_plt (MonoAotModule *info); -static MonoJumpInfo* -load_patch_info (MonoAotModule *aot_module, MonoMemPool *mp, int n_patches, - guint32 got_index, guint32 **got_slots, - guint8 *buf, guint8 **endbuf); - /*****************************************************/ /* AOT RUNTIME */ /*****************************************************/ +/* + * load_image: + * + * Load one of the images referenced by AMODULE. Returns NULL if the image is not + * found, and sets the loader error if SET_ERROR is TRUE. + */ static MonoImage * -load_image (MonoAotModule *module, int index) +load_image (MonoAotModule *amodule, int index, gboolean set_error) { MonoAssembly *assembly; MonoImageOpenStatus status; - g_assert (index < module->image_table_len); + g_assert (index < amodule->image_table_len); - if (module->image_table [index]) - return module->image_table [index]; - if (module->out_of_date) + if (amodule->image_table [index]) + return amodule->image_table [index]; + if (amodule->out_of_date) return NULL; - assembly = mono_assembly_load (&module->image_names [index], NULL, &status); + assembly = mono_assembly_load (&amodule->image_names [index], NULL, &status); if (!assembly) { - mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s is unusable because dependency %s is not found.\n", module->aot_name, module->image_names [index].name); - module->out_of_date = TRUE; + mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s is unusable because dependency %s is not found.\n", amodule->aot_name, amodule->image_names [index].name); + amodule->out_of_date = TRUE; + + if (set_error) { + char *full_name = mono_stringify_assembly_name (&amodule->image_names [index]); + mono_loader_set_error_assembly_load (full_name, FALSE); + g_free (full_name); + } return NULL; } - if (strcmp (assembly->image->guid, module->image_guids [index])) { - mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s is out of date (Older than dependency %s).\n", module->aot_name, module->image_names [index].name); - module->out_of_date = TRUE; + if (strcmp (assembly->image->guid, amodule->image_guids [index])) { + mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s is out of date (Older than dependency %s).\n", amodule->aot_name, amodule->image_names [index].name); + amodule->out_of_date = TRUE; return NULL; } - module->image_table [index] = assembly->image; + amodule->image_table [index] = assembly->image; return assembly->image; } - static inline gint32 decode_value (guint8 *ptr, guint8 **rptr) { @@ -258,6 +246,48 @@ decode_value (guint8 *ptr, guint8 **rptr) return len; } +/* + * mono_aot_get_method: + * + * Decode an offset table emitted by emit_offset_table (), returning the INDEXth + * entry. + */ +static guint32 +mono_aot_get_offset (guint32 *table, int index) +{ + int i, group, ngroups, index_entry_size; + int start_offset, offset, noffsets, group_size; + guint8 *data_start, *p; + guint32 *index32 = NULL; + guint16 *index16 = NULL; + + noffsets = table [0]; + group_size = table [1]; + ngroups = table [2]; + index_entry_size = table [3]; + group = index / group_size; + + if (index_entry_size == 2) { + index16 = (guint16*)&table [4]; + data_start = (guint8*)&index16 [ngroups]; + p = data_start + index16 [group]; + } else { + index32 = (guint32*)&table [4]; + data_start = (guint8*)&index32 [ngroups]; + p = data_start + index32 [group]; + } + + /* offset will contain the value of offsets [group * group_size] */ + offset = start_offset = decode_value (p, &p); + for (i = group * group_size + 1; i <= index; ++i) { + offset += decode_value (p, &p); + } + + //printf ("Offset lookup: %d -> %d, start=%d, p=%d\n", index, offset, start_offset, table [3 + group]); + + return offset; +} + static MonoMethod* decode_method_ref_2 (MonoAotModule *module, guint8 *buf, guint8 **endbuf); @@ -329,7 +359,7 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf) return NULL; } if (mono_metadata_token_table (token) == 0) { - image = load_image (module, decode_value (p, &p)); + image = load_image (module, decode_value (p, &p), TRUE); if (!image) return NULL; klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF + token); @@ -343,6 +373,8 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf) MonoType *type; gclass = decode_klass_ref (module, p, &p); + if (!gclass) + return NULL; g_assert (gclass->generic_container); memset (&ctx, 0, sizeof (ctx)); @@ -393,14 +425,14 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf) g_assert_not_reached (); } } else { - image = load_image (module, decode_value (p, &p)); + image = load_image (module, decode_value (p, &p), TRUE); if (!image) return NULL; klass = mono_class_get (image, token); } } else if (token == MONO_TOKEN_TYPE_DEF) { /* Array */ - image = load_image (module, decode_value (p, &p)); + image = load_image (module, decode_value (p, &p), TRUE); if (!image) return NULL; rank = decode_value (p, &p); @@ -410,7 +442,6 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf) g_assert_not_reached (); } g_assert (klass); - mono_class_init (klass); *endbuf = p; return klass; @@ -460,6 +491,8 @@ can_method_ref_match_method (MonoAotModule *module, guint8 *buf, MonoMethod *met if (method->wrapper_type != wrapper_type) return FALSE; + } else if (image_index == MONO_AOT_METHODREF_WRAPPER_NAME) { + return FALSE; } else if (image_index < MONO_AOT_METHODREF_MIN || image_index == MONO_AOT_METHODREF_METHODSPEC || image_index == MONO_AOT_METHODREF_GINST) { if (method->wrapper_type) return FALSE; @@ -556,14 +589,6 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g case MONO_WRAPPER_STELEMREF: *method = mono_marshal_get_stelemref (); break; - case MONO_WRAPPER_STATIC_RGCTX_INVOKE: { - MonoMethod *m = decode_method_ref_2 (module, p, &p); - - if (!m) - return NULL; - *method = mono_marshal_get_static_rgctx_invoke (m); - break; - } case MONO_WRAPPER_SYNCHRONIZED: { MonoMethod *m = decode_method_ref_2 (module, p, &p); @@ -589,6 +614,28 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g *method = mono_monitor_get_fast_path (orig_method); break; } + case MONO_WRAPPER_RUNTIME_INVOKE: { + /* Direct wrapper */ + MonoMethod *m = decode_method_ref_2 (module, p, &p); + + if (!m) + return NULL; + *method = mono_marshal_get_runtime_invoke (m, FALSE); + break; + } + case MONO_WRAPPER_MANAGED_TO_MANAGED: { + int subtype = decode_value (p, &p); + + if (subtype == MONO_AOT_WRAPPER_ELEMENT_ADDR) { + int rank = decode_value (p, &p); + int elem_size = decode_value (p, &p); + + *method = mono_marshal_get_array_address (rank, elem_size); + } else { + g_assert_not_reached (); + } + break; + } default: g_assert_not_reached (); } @@ -599,7 +646,7 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g image_index = decode_value (p, &p); *token = decode_value (p, &p); - image = load_image (module, image_index); + image = load_image (module, image_index, TRUE); if (!image) return NULL; } else if (image_index == MONO_AOT_METHODREF_GINST) { @@ -617,7 +664,7 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g image_index = decode_value (p, &p); *token = decode_value (p, &p); - image = load_image (module, image_index); + image = load_image (module, image_index, TRUE); if (!image) return NULL; @@ -672,7 +719,7 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g g_assert (image_index < MONO_AOT_METHODREF_MIN); *token = MONO_TOKEN_METHOD_DEF | (value & 0xffffff); - image = load_image (module, image_index); + image = load_image (module, image_index, TRUE); if (!image) return NULL; } @@ -698,7 +745,8 @@ decode_method_ref_2 (MonoAotModule *module, guint8 *buf, guint8 **endbuf) return method; if (!image) return NULL; - return mono_get_method (image, token, NULL); + method = mono_get_method (image, token, NULL); + return method; } G_GNUC_UNUSED @@ -732,7 +780,7 @@ create_cache_structure (void) tmp = g_build_filename (home, ".mono", NULL); if (!g_file_test (tmp, G_FILE_TEST_IS_DIR)) { mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT creating directory %s", tmp); -#ifdef PLATFORM_WIN32 +#ifdef HOST_WIN32 err = mkdir (tmp); #else err = mkdir (tmp, 0777); @@ -747,7 +795,7 @@ create_cache_structure (void) tmp = g_build_filename (home, ".mono", "aot-cache", NULL); if (!g_file_test (tmp, G_FILE_TEST_IS_DIR)) { mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT creating directory %s", tmp); -#ifdef PLATFORM_WIN32 +#ifdef HOST_WIN32 err = mkdir (tmp); #else err = mkdir (tmp, 0777); @@ -816,7 +864,7 @@ load_aot_module_from_cache (MonoAssembly *assembly, char **aot_name) res = g_spawn_command_line_sync (cmd, &out, &err, &exit_status, NULL); -#if !defined(PLATFORM_WIN32) && !defined(__ppc__) && !defined(__ppc64__) && !defined(__powerpc__) +#if !defined(HOST_WIN32) && !defined(__ppc__) && !defined(__ppc64__) && !defined(__powerpc__) if (res) { if (!WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) == 0)) mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT failed: %s.", err); @@ -848,20 +896,78 @@ static void find_symbol (MonoDl *module, gpointer *globals, const char *name, gpointer *value) { if (globals) { - int i = 0; + int global_index; + guint16 *table, *entry; + guint16 table_size; + guint32 hash; + + /* The first entry points to the hash */ + table = globals [0]; + globals ++; + + table_size = table [0]; + table ++; + + hash = mono_metadata_str_hash (name) % table_size; + + entry = &table [hash * 2]; + + /* Search the hash for the index into the globals table */ + global_index = -1; + while (entry [0] != 0) { + guint32 index = entry [0] - 1; + guint32 next = entry [1]; + + //printf ("X: %s %s\n", (char*)globals [index * 2], name); + + if (!strcmp (globals [index * 2], name)) { + global_index = index; + break; + } - *value = NULL; - for (i = 0; globals [i]; i+= 2) { - if (strcmp (globals [i], name) == 0) { - *value = globals [i + 1]; + if (next != 0) { + entry = &table [next * 2]; + } else { break; } } + + if (global_index != -1) + *value = globals [global_index * 2 + 1]; + else + *value = NULL; } else { mono_dl_symbol (module, name, value); } } +#ifndef SHT_ARM_EXIDX +#define SHT_ARM_EXIDX 0x70000001 +#endif + +#ifdef HAVE_DL_ITERATE_PHDR +static int +dl_callback (struct dl_phdr_info *info, size_t size, void *data) +{ + int j; + MonoAotModule *amodule = data; + + if (!strcmp (amodule->aot_name, info->dlpi_name)) { + for (j = 0; j < info->dlpi_phnum; j++) { + if (info->dlpi_phdr [j].p_type == PT_GNU_EH_FRAME) + amodule->eh_frame_hdr = (guint8*)(info->dlpi_addr + info->dlpi_phdr [j].p_vaddr); + if (info->dlpi_phdr [j].p_type == SHT_ARM_EXIDX) { + amodule->arm_exidx = (guint8*)(info->dlpi_addr + info->dlpi_phdr [j].p_vaddr); + amodule->arm_exidx_size = info->dlpi_phdr [j].p_filesz; + } + } + return 1; + } else { + return 0; + } +} +#endif + static void load_aot_module (MonoAssembly *assembly, gpointer user_data) { @@ -877,6 +983,7 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) gboolean full_aot = FALSE; MonoAotFileInfo *file_info = NULL; int i; + gpointer *got_addr; if (mono_compile_aot) return; @@ -907,8 +1014,6 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) aot_name = g_strdup_printf ("%s", assembly->aname.name); mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "Found statically linked AOT module '%s'.\n", aot_name); } else { - TlsSetValue (globals_tls_id, NULL); - if (use_aot_cache) sofile = load_aot_module_from_cache (assembly, &aot_name); else { @@ -922,15 +1027,6 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) g_free (err); } } - - /* - * If the image was compiled in no-dlsym mode, it contains no global symbols, - * instead it contains an ELF ctor function which is called by dlopen () which - * in turn calls mono_aot_register_globals () to register a table which contains - * the name and address of the globals. - */ - globals = TlsGetValue (globals_tls_id); - TlsSetValue (globals_tls_id, NULL); } if (!sofile && !globals) { @@ -946,6 +1042,7 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) find_symbol (sofile, globals, "mono_aot_version", (gpointer *) &aot_version); find_symbol (sofile, globals, "mono_aot_opt_flags", (gpointer *)&opt_flags); find_symbol (sofile, globals, "mono_runtime_version", (gpointer *)&runtime_version); + find_symbol (sofile, globals, "mono_aot_got_addr", (gpointer *)&got_addr); if (!aot_version || strcmp (aot_version, MONO_AOT_FILE_VERSION)) { mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s has wrong file format version (expected %s got %s)\n", aot_name, MONO_AOT_FILE_VERSION, aot_version); @@ -965,14 +1062,10 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) } g_free (build_info); - { - char *full_aot_str; - - find_symbol (sofile, globals, "mono_aot_full_aot", (gpointer *)&full_aot_str); + find_symbol (sofile, globals, "mono_aot_file_info", (gpointer*)&file_info); + g_assert (file_info); - if (full_aot_str && !strcmp (full_aot_str, "TRUE")) - full_aot = TRUE; - } + full_aot = ((MonoAotFileInfo*)file_info)->flags & MONO_AOT_FILE_FLAG_FULL_AOT; if (mono_aot_only && !full_aot) { fprintf (stderr, "Can't use AOT image '%s' in aot-only mode because it is not compiled with --aot=full.\n", aot_name); @@ -983,6 +1076,11 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) usable = FALSE; } + if ((((MonoAotFileInfo*)file_info)->flags & MONO_AOT_FILE_FLAG_WITH_LLVM) && !mono_use_llvm) { + mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT module %s is compiled with LLVM.\n", aot_name); + usable = FALSE; + } + if (!usable) { if (mono_aot_only) { fprintf (stderr, "Failed to load AOT module '%s' while running in aot-only mode.\n", aot_name); @@ -995,29 +1093,18 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) return; } - find_symbol (sofile, globals, "mono_aot_file_info", (gpointer*)&file_info); - g_assert (file_info); - amodule = g_new0 (MonoAotModule, 1); amodule->aot_name = aot_name; amodule->assembly = assembly; - amodule->plt_got_offset_base = file_info->plt_got_offset_base; - amodule->num_specific_trampolines = file_info->num_specific_trampolines; - amodule->specific_trampoline_got_offset_base = file_info->specific_trampoline_got_offset_base; - amodule->specific_trampoline_size = file_info->specific_trampoline_size; - amodule->got_size = file_info->got_size; - amodule->plt_size = file_info->plt_size; - amodule->num_static_rgctx_trampolines = file_info->num_static_rgctx_trampolines; - amodule->static_rgctx_trampoline_got_offset_base = file_info->static_rgctx_trampoline_got_offset_base; - amodule->static_rgctx_trampoline_size = file_info->static_rgctx_trampoline_size; - amodule->got = file_info->got; + + memcpy (&amodule->info, file_info, sizeof (*file_info)); + + amodule->got = *got_addr; amodule->got [0] = assembly->image; amodule->globals = globals; amodule->sofile = sofile; amodule->method_to_code = g_hash_table_new (mono_aligned_addr_hash, NULL); - sscanf (opt_flags, "%d", &amodule->opts); - /* Read image table */ { guint32 table_len, i; @@ -1060,25 +1147,20 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) } /* Read method and method_info tables */ - find_symbol (sofile, globals, "method_offsets", (gpointer*)&amodule->code_offsets); + find_symbol (sofile, globals, "code_offsets", (gpointer*)&amodule->code_offsets); find_symbol (sofile, globals, "methods", (gpointer*)&amodule->code); find_symbol (sofile, globals, "methods_end", (gpointer*)&amodule->code_end); find_symbol (sofile, globals, "method_info_offsets", (gpointer*)&amodule->method_info_offsets); - find_symbol (sofile, globals, "method_info", (gpointer*)&amodule->method_info); find_symbol (sofile, globals, "ex_info_offsets", (gpointer*)&amodule->ex_info_offsets); - find_symbol (sofile, globals, "ex_info", (gpointer*)&amodule->ex_info); - find_symbol (sofile, globals, "method_order", (gpointer*)&amodule->method_order); - find_symbol (sofile, globals, "method_order_end", (gpointer*)&amodule->method_order_end); - find_symbol (sofile, globals, "class_info", (gpointer*)&amodule->class_info); + find_symbol (sofile, globals, "blob", (gpointer*)&amodule->blob); find_symbol (sofile, globals, "class_info_offsets", (gpointer*)&amodule->class_info_offsets); find_symbol (sofile, globals, "class_name_table", (gpointer *)&amodule->class_name_table); find_symbol (sofile, globals, "extra_method_table", (gpointer *)&amodule->extra_method_table); - find_symbol (sofile, globals, "extra_method_info", (gpointer *)&amodule->extra_method_info); find_symbol (sofile, globals, "extra_method_info_offsets", (gpointer *)&amodule->extra_method_info_offsets); - find_symbol (sofile, globals, "got_info", (gpointer*)&amodule->got_info); find_symbol (sofile, globals, "got_info_offsets", (gpointer*)&amodule->got_info_offsets); - find_symbol (sofile, globals, "specific_trampolines", (gpointer*)&amodule->specific_trampolines); - find_symbol (sofile, globals, "static_rgctx_trampolines", (gpointer*)&amodule->static_rgctx_trampolines); + find_symbol (sofile, globals, "specific_trampolines", (gpointer*)&(amodule->trampolines [MONO_AOT_TRAMP_SPECIFIC])); + find_symbol (sofile, globals, "static_rgctx_trampolines", (gpointer*)&(amodule->trampolines [MONO_AOT_TRAMP_STATIC_RGCTX])); + find_symbol (sofile, globals, "imt_thunks", (gpointer*)&(amodule->trampolines [MONO_AOT_TRAMP_IMT_THUNK])); find_symbol (sofile, globals, "unwind_info", (gpointer)&amodule->unwind_info); find_symbol (sofile, globals, "mem_end", (gpointer*)&amodule->mem_end); @@ -1088,7 +1170,7 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) find_symbol (sofile, globals, "plt_end", (gpointer*)&amodule->plt_end); if (make_unreadable) { -#ifndef PLATFORM_WIN32 +#ifndef TARGET_WIN32 guint8 *addr; guint8 *page_start; int pages, err, len; @@ -1115,15 +1197,32 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) mono_jit_info_add_aot_module (assembly->image, amodule->code, amodule->code_end); assembly->image->aot_module = amodule; + +#ifdef HAVE_DL_ITERATE_PHDR + /* Lookup the address of the .eh_frame_hdr () section if available */ + dl_iterate_phdr (dl_callback, amodule); +#endif + + if (mono_aot_only) { + if (mono_defaults.corlib) { + /* The second got slot contains the mscorlib got addr */ + MonoAotModule *mscorlib_amodule = mono_defaults.corlib->aot_module; + + amodule->got [1] = mscorlib_amodule->got; + } else { + amodule->got [1] = amodule->got; + } + } /* * Since we store methoddef and classdef tokens when referring to methods/classes in * referenced assemblies, we depend on the exact versions of the referenced assemblies. * MS calls this 'hard binding'. This means we have to load all referenced assemblies * non-lazily, since we can't handle out-of-date errors later. + * The cached class info also depends on the exact assemblies. */ for (i = 0; i < amodule->image_table_len; ++i) - load_image (amodule, i); + load_image (amodule, i, FALSE); if (amodule->out_of_date) { mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT Module %s is unusable because a dependency is out-of-date.\n", assembly->image->name); @@ -1145,7 +1244,7 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) void mono_aot_register_globals (gpointer *globals) { - TlsSetValue (globals_tls_id, globals); + g_assert_not_reached (); } /* @@ -1186,13 +1285,12 @@ mono_aot_init (void) { InitializeCriticalSection (&aot_mutex); aot_modules = g_hash_table_new (NULL, NULL); - globals_tls_id = TlsAlloc (); mono_install_assembly_load_hook (load_aot_module, NULL); - if (getenv ("MONO_LASTAOT")) - mono_last_aot_method = atoi (getenv ("MONO_LASTAOT")); - if (getenv ("MONO_AOT_CACHE")) + if (g_getenv ("MONO_LASTAOT")) + mono_last_aot_method = atoi (g_getenv ("MONO_LASTAOT")); + if (g_getenv ("MONO_AOT_CACHE")) use_aot_cache = TRUE; } @@ -1214,6 +1312,7 @@ decode_cached_class_info (MonoAotModule *module, MonoCachedClassInfo *info, guin info->has_references = (flags >> 5) & 0x1; info->has_static_refs = (flags >> 6) & 0x1; info->no_special_static_fields = (flags >> 7) & 0x1; + info->is_generic_container = (flags >> 8) & 0x1; if (info->has_cctor) { MonoImage *cctor_image = decode_method_ref (module, &info->cctor_token, NULL, NULL, buf, &buf); @@ -1252,7 +1351,7 @@ mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int sl if (MONO_CLASS_IS_INTERFACE (klass) || klass->rank || !aot_module) return NULL; - info = &aot_module->class_info [aot_module->class_info_offsets [mono_metadata_token_index (klass->type_token) - 1]]; + info = &aot_module->blob [mono_aot_get_offset (aot_module->class_info_offsets, mono_metadata_token_index (klass->type_token) - 1)]; p = info; err = decode_cached_class_info (aot_module, &class_info, p, &p); @@ -1284,7 +1383,7 @@ mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) if (klass->rank || !aot_module) return FALSE; - p = (guint8*)&aot_module->class_info [aot_module->class_info_offsets [mono_metadata_token_index (klass->type_token) - 1]]; + p = (guint8*)&aot_module->blob [mono_aot_get_offset (aot_module->class_info_offsets, mono_metadata_token_index (klass->type_token) - 1)]; err = decode_cached_class_info (aot_module, res, p, &p); if (!err) @@ -1349,7 +1448,7 @@ mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const ch full_name = g_strdup_printf ("%s.%s", name_space, name); } } - hash = g_str_hash (full_name) % table_size; + hash = mono_metadata_str_hash (full_name) % table_size; if (full_name != full_name_buf) g_free (full_name); @@ -1401,30 +1500,416 @@ mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const ch return TRUE; } +#define DW_EH_PE_omit 0xff +#define DW_EH_PE_uleb128 0x01 +#define DW_EH_PE_udata2 0x02 +#define DW_EH_PE_udata4 0x03 +#define DW_EH_PE_udata8 0x04 +#define DW_EH_PE_sleb128 0x09 +#define DW_EH_PE_sdata2 0x0A +#define DW_EH_PE_sdata4 0x0B +#define DW_EH_PE_sdata8 0x0C + +#define DW_EH_PE_absptr 0x00 +#define DW_EH_PE_pcrel 0x10 +#define DW_EH_PE_datarel 0x30 +#define DW_EH_PE_omit 0xff + +typedef struct +{ + guint8 version; + guint8 eh_frame_ptr_enc; + guint8 fde_count_enc; + guint8 table_enc; + guint8 rest; +} eh_frame_hdr; + +/* + * decode_eh_frame: + * + * Decode the exception handling information in the .eh_frame section of the AOT + * file belong to CODE, and construct a MonoJitInfo structure from it. + * LOCKING: Acquires the domain lock. + */ +static G_GNUC_UNUSED void +decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, + MonoMethod *method, guint8 *code, MonoJitInfo *jinfo) +{ + eh_frame_hdr *hdr; + guint8 *p; + guint8 *eh_frame, *unwind_info; + guint32 eh_frame_ptr; + int fde_count; + gint32 *table; + int i, pos, left, right, offset, offset1, offset2; + guint32 unw_len, code_len; + MonoJitExceptionInfo *ei; + guint32 ei_len; + + g_assert (amodule->eh_frame_hdr); + + // http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html + hdr = (eh_frame_hdr*)amodule->eh_frame_hdr; + g_assert (hdr->version == 1); + g_assert (hdr->eh_frame_ptr_enc == (DW_EH_PE_pcrel | DW_EH_PE_sdata4)); + g_assert (hdr->fde_count_enc == DW_EH_PE_udata4); + g_assert (hdr->table_enc == (DW_EH_PE_datarel | DW_EH_PE_sdata4)); + + p = &(hdr->rest); + eh_frame_ptr = *(guint32*)p; + p += 4; + fde_count = *(guint32*)p; + p += 4; + table = (gint32*)p; + + /* Binary search in the table to find the entry for code */ + offset = code - amodule->eh_frame_hdr; + + left = 0; + right = fde_count; + while (TRUE) { + pos = (left + right) / 2; + + offset1 = table [(pos * 2)]; + if (pos + 1 == fde_count) + /* FIXME: */ + offset2 = amodule->code_end - amodule->code; + else + offset2 = table [(pos + 1) * 2]; + + if (offset < offset1) + right = pos; + else if (offset >= offset2) + left = pos + 1; + else + break; + } + + g_assert (code >= amodule->eh_frame_hdr + table [(pos * 2)]); + if (pos < fde_count) + g_assert (code < amodule->eh_frame_hdr + table [(pos * 2) + 2]); + + eh_frame = amodule->eh_frame_hdr + table [(pos * 2) + 1]; + + unwind_info = mono_unwind_decode_fde (eh_frame, &unw_len, &code_len, &ei, &ei_len, NULL); + + jinfo->code_size = code_len; + jinfo->used_regs = mono_cache_unwind_info (unwind_info, unw_len); + jinfo->method = method; + jinfo->code_start = code; + jinfo->domain_neutral = 0; + /* This signals that used_regs points to a normal cached unwind info */ + jinfo->from_aot = 0; + + g_assert (ei_len == jinfo->num_clauses); + for (i = 0; i < jinfo->num_clauses; ++i) { + MonoJitExceptionInfo *jei = &jinfo->clauses [i]; + + jei->try_start = ei [i].try_start; + jei->try_end = ei [i].try_end; + jei->handler_start = ei [i].handler_start; + } +} + +#ifdef TARGET_ARM + +/* The offsets in the table are 31 bits long, have to extend them to 32 */ +#define EXTEND_PREL31(val) ((((gint32)(val)) << 1) >> 1) + +static inline guint32 +decode_uleb128 (guint8 *buf, guint8 **endbuf) +{ + guint8 *p = buf; + guint32 res = 0; + int shift = 0; + + while (TRUE) { + guint8 b = *p; + p ++; + + res = res | (((int)(b & 0x7f)) << shift); + if (!(b & 0x80)) + break; + shift += 7; + } + + *endbuf = p; + + return res; +} + +static GSList* +decode_arm_eh_ops (guint8 *unwind_ops, int nops) +{ + int i, vsp_reg, vsp_offset; + GSList *ops; + gint32 *reg_offsets; + + /* + * Have to convert the ARM unwind info into DWARF unwind info. + * The ARM unwind info specifies a simple set of instructions which need to be + * executed during unwinding. It manipulates a virtual stack pointer (vsp). The + * connection with DWARF unwind info is the following: after all ARM unwind + * opcodes have been executed, the stack should be completely unwound, i.e. + * vsp == DWARF CFA. This allows us to construct the DWARF opcodes corresponding + * to the ARM opcodes. + * The ARM unwind info is not instruction precise, i. e. it can't handle + * async exceptions etc. + */ + /* The reg used to compute the initial value of vsp */ + vsp_reg = ARMREG_SP; + /* The offset between vsp_reg and the CFA */ + vsp_offset = 0; + + /* The register save offsets from the initial value of vsp */ + reg_offsets = g_new0 (gint32, 16); + for (i = 0; i < 16; ++i) + reg_offsets [i] = -1; + + /* section 9.3 in the ehabi doc */ + for (i = 0; i < nops; ++i) { + guint8 op = unwind_ops [i]; + + if ((op >> 6) == 0) { + /* vsp = vsp + (xxxxxx << 2) + 4. */ + vsp_offset += ((op & 0x3f) << 2) + 4; + } else if ((op >> 6) == 1) { + /* vsp = vsp - (xxxxxx << 2) - 4. */ + vsp_offset -= ((op & 0x3f) << 2) + 4; + } else if (op == 0xb2) { + /* vsp = vsp = vsp + 0x204 + (uleb128 << 2) */ + guint8 *p = unwind_ops + i + 1; + guint32 v = decode_uleb128 (p, &p); + + vsp_offset += 0x204 + (v << 2); + i = (p - unwind_ops) - 1; + } else if (op >= 0x80 && op <= 0x8f) { + /* pop registers */ + guint8 op2; + GSList *regs; + int j; + + g_assert (i + 1 < nops); + op2 = unwind_ops [i + 1]; + + regs = NULL; + for (j = 0; j < 8; ++j) + if (op2 & (0x1 << j)) + regs = g_slist_append (regs, GUINT_TO_POINTER (ARMREG_R4 + j)); + for (j = 0; j < 4; ++j) + if (op & (0x1 << j)) + regs = g_slist_append (regs, GUINT_TO_POINTER (ARMREG_R12 + j)); + g_assert (regs); + + for (j = 0; j < g_slist_length (regs); ++j) + reg_offsets [GPOINTER_TO_UINT (g_slist_nth (regs, j)->data)] = vsp_offset + (j * 4); + + vsp_offset += g_slist_length (regs) * 4; + + g_slist_free (regs); + + i ++; + } else if (op >= 0xa8 && op <= 0xaf) { + GSList *regs; + int j; + + /* pop r4-r[4 + nnn], r14 */ + + regs = NULL; + for (j = 0; j <= (op & 0x7); ++j) + regs = g_slist_append (regs, GUINT_TO_POINTER (ARMREG_R4 + j)); + regs = g_slist_append (regs, GUINT_TO_POINTER (ARMREG_R14)); + + for (j = 0; j < g_slist_length (regs); ++j) + reg_offsets [GPOINTER_TO_UINT (g_slist_nth (regs, j)->data)] = vsp_offset + (j * 4); + + vsp_offset += g_slist_length (regs) * 4; + + g_slist_free (regs); + } else if (op == 0xb0) { + /* finish */ + break; + } else if (op >= 0x90 && op <= 0x9f && op != 0x9d && op != 0x9f) { + /* vsp = */ + vsp_reg = op & 0xf; + vsp_offset = 0; + } else { + int j; + + for (j = 0; j < nops; ++j) + printf ("%x ", unwind_ops [j]); + printf (" / %d\n", i); + g_assert_not_reached (); + } + } + + ops = NULL; + + /* vsp_reg + vsp_offset = CFA */ + mono_add_unwind_op_def_cfa (ops, (guint8*)NULL, (guint8*)NULL, vsp_reg, vsp_offset); + + for (i = 0; i < 16; ++i) { + if (reg_offsets [i] != -1) + /* The reg is saved at vsp_reg + reg_offset [i] == CFA - (vsp_offset - reg_offset [i]) */ + mono_add_unwind_op_offset (ops, (guint8*)NULL, (guint8*)NULL, i, - (vsp_offset - reg_offsets [i])); + } + + return ops; +} + +/* + * decode_arm_exidx: + * + * Decode the exception handling information in the .ARM.exidx section of the AOT + * file belong to CODE, and construct a MonoJitInfo structure from it. + * LOCKING: Acquires the domain lock. + */ +static void +decode_arm_exidx (MonoAotModule *amodule, MonoDomain *domain, + MonoMethod *method, guint8 *code, guint32 code_len, MonoJitInfo *jinfo) +{ + guint32 *table; + guint8 *base, *code1, *code2; + int i, pos, left, right, offset, offset1, offset2, count, nwords, nops; + guint32 entry; + guint8 unwind_ops [64]; + GSList *ops; + guint8 *unwind_info; + guint32 unw_len; + + g_assert (amodule->arm_exidx); + + table = (guint32*)amodule->arm_exidx; + + /* + * The table format is described in: + * infocenter.arm.com/help/topic/com.arm.doc.../IHI0038A_ehabi.pdf + */ + + base = amodule->arm_exidx; + count = amodule->arm_exidx_size / 8; + + /* Binary search in the table to find the entry for code */ + offset = code - base; + + left = 0; + right = count; + while (TRUE) { + pos = (left + right) / 2; + + if (left == right) + break; + + offset1 = EXTEND_PREL31 (table [(pos * 2)]); + code1 = (guint8*)&(table [pos * 2]) + offset1; + if (pos + 1 == count) + /* FIXME: */ + offset2 = amodule->code_end - amodule->code; + else + offset2 = EXTEND_PREL31 (table [(pos + 1) * 2]); + code2 = (guint8*)&(table [(pos + 1) * 2]) + offset2; + + if (code < code1) + right = pos; + else if (code >= code2) + left = pos + 1; + else + break; + } + + if (code >= code1) { + /* + * The linker might merge duplicate unwind table entries, so + * offset1 and offset2 might point to another method, but this is not a problem. + */ + code1 = (guint8*)&(table [pos * 2]) + offset1; + code2 = (guint8*)&(table [(pos + 1) * 2]) + offset2; + + g_assert (code >= code1); + if (pos < count) + g_assert (code < code2); + + entry = table [(pos * 2) + 1]; + + /* inline entry, compact model, personality routine 0 */ + if ((entry & 0xff000000) == 0x80000000) { + nops = 3; + unwind_ops [0] = (entry & 0x00ff0000) >> 16; + unwind_ops [1] = (entry & 0x0000ff00) >> 8; + unwind_ops [2] = (entry & 0x000000ff) >> 0; + + ops = decode_arm_eh_ops (unwind_ops, nops); + } else if ((entry & 0x80000000) == 0) { + /* non-inline entry */ + guint8 *data = (guint8*)&table [(pos * 2) + 1] + EXTEND_PREL31 (entry); + + entry = ((guint32*)data) [0]; + + /* compact model, personality routine 1 */ + g_assert ((entry & 0xff000000) == 0x81000000); + + nwords = (entry & 0x00ff0000) >> 16; + nops = nwords * 4 + 2; + g_assert (nops < 64); + + unwind_ops [0] = (entry & 0x0000ff00) >> 8; + unwind_ops [1] = (entry & 0x000000ff) >> 0; + + for (i = 0; i < nwords; ++i) { + entry = ((guint32*)data) [1 + i]; + unwind_ops [(i * 4) + 2] = (entry & 0xff000000) >> 24; + unwind_ops [(i * 4) + 2 + 1] = (entry & 0x00ff0000) >> 16; + unwind_ops [(i * 4) + 2 + 2] = (entry & 0x0000ff00) >> 8; + unwind_ops [(i * 4) + 2 + 3] = (entry & 0x000000ff) >> 0; + } + + ops = decode_arm_eh_ops (unwind_ops, nops); + } else { + NOT_IMPLEMENTED; + } + + unwind_info = mono_unwind_ops_encode (ops, &unw_len); + } else { + /* The method has no unwind info */ + unwind_info = NULL; + unw_len = 0; + } + + jinfo->code_size = code_len; + jinfo->used_regs = mono_cache_unwind_info (unwind_info, unw_len); + jinfo->method = method; + jinfo->code_start = code; + jinfo->domain_neutral = 0; + /* This signals that used_regs points to a normal cached unwind info */ + jinfo->from_aot = 0; +} +#endif + /* * LOCKING: Acquires the domain lock. */ static MonoJitInfo* -decode_exception_debug_info (MonoAotModule *aot_module, MonoDomain *domain, - MonoMethod *method, guint8* ex_info, guint8 *code) +decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, + MonoMethod *method, guint8* ex_info, guint8 *addr, + guint8 *code, guint32 code_len) { int i, buf_len; MonoJitInfo *jinfo; - guint code_len, used_int_regs, flags; - gboolean has_generic_jit_info, has_dwarf_unwind_info; + guint used_int_regs, flags; + gboolean has_generic_jit_info, has_dwarf_unwind_info, has_clauses, has_seq_points; + gboolean from_llvm; guint8 *p; - MonoMethodHeader *header; int generic_info_size; - header = mono_method_get_header (method); - /* Load the method info from the AOT file */ p = ex_info; - code_len = decode_value (p, &p); flags = decode_value (p, &p); has_generic_jit_info = (flags & 1) != 0; has_dwarf_unwind_info = (flags & 2) != 0; + has_clauses = (flags & 4) != 0; + has_seq_points = (flags & 8) != 0; + from_llvm = (flags & 16) != 0; if (has_dwarf_unwind_info) { guint32 offset; @@ -1440,22 +1925,25 @@ decode_exception_debug_info (MonoAotModule *aot_module, MonoDomain *domain, generic_info_size = 0; /* Exception table */ - if (header && header->num_clauses) { + if (has_clauses) { + int num_clauses = decode_value (p, &p); + jinfo = - mono_domain_alloc0 (domain, sizeof (MonoJitInfo) + (sizeof (MonoJitExceptionInfo) * header->num_clauses) + generic_info_size); - jinfo->num_clauses = header->num_clauses; + mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO + (sizeof (MonoJitExceptionInfo) * num_clauses) + generic_info_size); + jinfo->num_clauses = num_clauses; - for (i = 0; i < header->num_clauses; ++i) { - MonoExceptionClause *ec = &header->clauses [i]; + for (i = 0; i < num_clauses; ++i) { MonoJitExceptionInfo *ei = &jinfo->clauses [i]; - ei->flags = ec->flags; + ei->flags = decode_value (p, &p); ei->exvar_offset = decode_value (p, &p); if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) ei->data.filter = code + decode_value (p, &p); - else - ei->data.catch_class = ec->data.catch_class; + else { + if (decode_value (p, &p)) + ei->data.catch_class = decode_klass_ref (amodule, p, &p); + } ei->try_start = code + decode_value (p, &p); ei->try_end = code + decode_value (p, &p); @@ -1463,15 +1951,26 @@ decode_exception_debug_info (MonoAotModule *aot_module, MonoDomain *domain, } } else { - jinfo = mono_domain_alloc0 (domain, sizeof (MonoJitInfo) + generic_info_size); + jinfo = mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO + generic_info_size); } - jinfo->code_size = code_len; - jinfo->used_regs = used_int_regs; - jinfo->method = method; - jinfo->code_start = code; - jinfo->domain_neutral = 0; - jinfo->from_aot = 1; + if (from_llvm) { + /* LLVM compiled method */ + /* The info is in the .eh_frame section */ +#ifdef TARGET_ARM + decode_arm_exidx (amodule, domain, method, code, code_len, jinfo); +#else + decode_eh_frame (amodule, domain, method, code, jinfo); +#endif + jinfo->from_llvm = 1; + } else { + jinfo->code_size = code_len; + jinfo->used_regs = used_int_regs; + jinfo->method = method; + jinfo->code_start = code; + jinfo->domain_neutral = 0; + jinfo->from_aot = 1; + } if (has_generic_jit_info) { MonoGenericJitInfo *gi; @@ -1488,12 +1987,50 @@ decode_exception_debug_info (MonoAotModule *aot_module, MonoDomain *domain, /* This currently contains no data */ gi->generic_sharing_context = g_new0 (MonoGenericSharingContext, 1); - jinfo->method = decode_method_ref_2 (aot_module, p, &p); + jinfo->method = decode_method_ref_2 (amodule, p, &p); + } + + if (has_seq_points) { + MonoSeqPointInfo *seq_points; + int il_offset, native_offset, last_il_offset, last_native_offset, j; + + int len = decode_value (p, &p); + + seq_points = g_malloc0 (sizeof (MonoSeqPointInfo) + (len - MONO_ZERO_LEN_ARRAY) * sizeof (SeqPoint)); + last_il_offset = last_native_offset = 0; + for (i = 0; i < len; ++i) { + SeqPoint *sp = &seq_points->seq_points [i]; + il_offset = last_il_offset + decode_value (p, &p); + native_offset = last_native_offset + decode_value (p, &p); + + sp->il_offset = il_offset; + sp->native_offset = native_offset; + + sp->next_len = decode_value (p, &p); + sp->next = g_new (int, sp->next_len); + for (j = 0; j < sp->next_len; ++j) + sp->next [j] = decode_value (p, &p); + + last_il_offset = il_offset; + last_native_offset = native_offset; + } + + mono_domain_lock (domain); + g_hash_table_insert (domain_jit_info (domain)->seq_points, method, seq_points); + mono_domain_unlock (domain); } /* Load debug info */ buf_len = decode_value (p, &p); mono_debug_add_aot_method (domain, method, code, p, buf_len); + + if (amodule != jinfo->method->klass->image->aot_module) { + mono_aot_lock (); + if (!ji_to_amodule) + ji_to_amodule = g_hash_table_new (NULL, NULL); + g_hash_table_insert (ji_to_amodule, jinfo, amodule); + mono_aot_unlock (); + } return jinfo; } @@ -1508,28 +2045,45 @@ mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) { MonoAotModule *amodule = ji->method->klass->image->aot_module; guint8 *p; + guint8 *code = ji->code_start; g_assert (amodule); g_assert (ji->from_aot); + if (!(code >= amodule->code && code <= amodule->code_end)) { + /* ji belongs to a different aot module than amodule */ + mono_aot_lock (); + g_assert (ji_to_amodule); + amodule = g_hash_table_lookup (ji_to_amodule, ji); + g_assert (amodule); + g_assert (code >= amodule->code && code <= amodule->code_end); + } + p = amodule->unwind_info + ji->used_regs; *unwind_info_len = decode_value (p, &p); return p; } -MonoJitInfo * -mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) +static int +compare_ints (const void *a, const void *b) { + return *(gint32*)a - *(gint32*)b; +} - int pos, left, right, offset, offset1, offset2, last_offset, new_offset; - int page_index, method_index, table_len, is_wrapper; +MonoJitInfo * +mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) +{ + int pos, left, right, offset, offset1, offset2, code_len; + int method_index, table_len, is_wrapper; guint32 token; MonoAotModule *amodule = image->aot_module; MonoMethod *method; MonoJitInfo *jinfo; guint8 *code, *ex_info, *p; - guint32 *table, *ptr; - gboolean found; + guint32 *table; + int nmethods = amodule->info.nmethods; + gint32 *code_offsets; + int i; if (!amodule) return NULL; @@ -1540,71 +2094,36 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) offset = (guint8*)addr - amodule->code; - /* First search through the index */ - ptr = amodule->method_order; - last_offset = 0; - page_index = 0; - found = FALSE; - - if (*ptr == 0xffffff) - return NULL; - ptr ++; - - while (*ptr != 0xffffff) { - guint32 method_index = ptr [0]; - new_offset = amodule->code_offsets [method_index]; - - if (offset >= last_offset && offset < new_offset) { - found = TRUE; - break; + /* Compute a sorted table mapping code offsets to method indexes. */ + if (!amodule->sorted_code_offsets) { + code_offsets = g_new0 (gint32, nmethods * 2); + for (i = 0; i < nmethods; ++i) { + code_offsets [(i * 2)] = amodule->code_offsets [i]; + code_offsets [(i *2) + 1] = i; } + /* FIXME: Use a merge sort as this is mostly sorted */ + qsort (code_offsets, nmethods, sizeof (gint32) * 2, compare_ints); + for (i = 0; i < nmethods -1; ++i) + g_assert (code_offsets [(i * 2)] <= code_offsets [(i + 1) * 2]); - ptr ++; - last_offset = new_offset; - page_index ++; + if (InterlockedCompareExchangePointer ((gpointer*)&amodule->sorted_code_offsets, code_offsets, NULL) != NULL) + /* Somebody got in before us */ + g_free (code_offsets); } - /* Skip rest of index */ - while (*ptr != 0xffffff) - ptr ++; - ptr ++; + code_offsets = amodule->sorted_code_offsets; - table = ptr; - table_len = amodule->method_order_end - table; - - g_assert (table <= amodule->method_order_end); - - if (found) { - left = (page_index * 1024); - right = left + 1024; - - if (right > table_len) - right = table_len; - - offset1 = amodule->code_offsets [table [left]]; - g_assert (offset1 <= offset); - - //printf ("Found in index: 0x%x 0x%x 0x%x\n", offset, last_offset, new_offset); - } - else { - //printf ("Not found in index: 0x%x\n", offset); - left = 0; - right = table_len; - } - - /* Binary search inside the method_order table to find the method */ + /* Binary search in the sorted_code_offsets table */ + left = 0; + right = nmethods; while (TRUE) { pos = (left + right) / 2; - g_assert (table + pos <= amodule->method_order_end); - - //printf ("Pos: %5d < %5d < %5d Offset: 0x%05x < 0x%05x < 0x%05x\n", left, pos, right, amodule->code_offsets [table [left]], offset, amodule->code_offsets [table [right]]); - - offset1 = amodule->code_offsets [table [pos]]; - if (table + pos + 1 >= amodule->method_order_end) + offset1 = code_offsets [(pos * 2)]; + if (pos + 1 == nmethods) offset2 = amodule->code_end - amodule->code; else - offset2 = amodule->code_offsets [table [pos + 1]]; + offset2 = code_offsets [(pos + 1) * 2]; if (offset < offset1) right = pos; @@ -1614,7 +2133,20 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) break; } - method_index = table [pos]; + g_assert (offset >= code_offsets [(pos * 2)]); + if (pos + 1 < nmethods) + g_assert (offset < code_offsets [((pos + 1) * 2)]); + method_index = code_offsets [(pos * 2) + 1]; + + code = &amodule->code [amodule->code_offsets [method_index]]; + ex_info = &amodule->blob [mono_aot_get_offset (amodule->ex_info_offsets, method_index)]; + + if (pos == nmethods - 1) + code_len = amodule->code_end - code; + else + code_len = code_offsets [(pos + 1) * 2] - code_offsets [pos * 2]; + + g_assert ((guint8*)code <= (guint8*)addr && (guint8*)addr < (guint8*)code + code_len); /* Might be a wrapper/extra method */ if (amodule->extra_methods) { @@ -1651,7 +2183,7 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) break; } - p = amodule->extra_method_info + table [(pos * 2) + 1]; + p = amodule->blob + table [(pos * 2) + 1]; is_wrapper = decode_value (p, &p); g_assert (!is_wrapper); method = decode_method_ref_2 (amodule, p, &p); @@ -1666,11 +2198,8 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) g_assert (method); //printf ("F: %s\n", mono_method_full_name (method, TRUE)); - - code = &amodule->code [amodule->code_offsets [method_index]]; - ex_info = &amodule->ex_info [amodule->ex_info_offsets [method_index]]; - - jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, code); + + jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len); g_assert ((guint8*)addr >= (guint8*)jinfo->code_start); g_assert ((guint8*)addr < (guint8*)jinfo->code_start + jinfo->code_size); @@ -1681,29 +2210,6 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) return jinfo; } -/* Keep it in sync with the version in aot-compiler.c */ -static inline gboolean -is_shared_got_patch (MonoJumpInfo *patch_info) -{ - switch (patch_info->type) { - case MONO_PATCH_INFO_VTABLE: - case MONO_PATCH_INFO_CLASS: - case MONO_PATCH_INFO_IID: - case MONO_PATCH_INFO_ADJUSTED_IID: - case MONO_PATCH_INFO_FIELD: - case MONO_PATCH_INFO_SFLDA: - case MONO_PATCH_INFO_DECLSEC: - case MONO_PATCH_INFO_LDTOKEN: - case MONO_PATCH_INFO_TYPE_FROM_HANDLE: - case MONO_PATCH_INFO_RVA: - case MONO_PATCH_INFO_METHODCONST: - case MONO_PATCH_INFO_IMAGE: - return TRUE; - default: - return FALSE; - } -} - static gboolean decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guint8 *buf, guint8 **endbuf) { @@ -1725,9 +2231,8 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin if (!image) goto cleanup; -#ifdef MONO_ARCH_HAVE_CREATE_TRAMPOLINE_FROM_TOKEN if (!method && !mono_aot_only && !no_aot_trampoline && (ji->type == MONO_PATCH_INFO_METHOD) && (mono_metadata_token_table (token) == MONO_TABLE_METHOD)) { - ji->data.target = mono_create_jit_trampoline_from_token (image, token); + ji->data.target = mono_create_ftnptr (mono_domain_get (), mono_create_jit_trampoline_from_token (image, token)); ji->type = MONO_PATCH_INFO_ABS; } else { @@ -1738,12 +2243,6 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin g_assert (ji->data.method); mono_class_init (ji->data.method->klass); } -#else - ji->data.method = mono_get_method (image, token, NULL); - g_assert (ji->data.method); - mono_class_init (ji->data.method->klass); -#endif - break; } case MONO_PATCH_INFO_INTERNAL_METHOD: @@ -1776,7 +2275,7 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin goto cleanup; break; case MONO_PATCH_INFO_IMAGE: - ji->data.image = load_image (aot_module, decode_value (p, &p)); + ji->data.image = load_image (aot_module, decode_value (p, &p), TRUE); if (!ji->data.image) goto cleanup; break; @@ -1798,23 +2297,25 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin case MONO_PATCH_INFO_R4: { guint32 val; - ji->data.target = mono_mempool_alloc0 (mp, sizeof (float)); + ji->data.target = mono_domain_alloc0 (mono_domain_get (), sizeof (float)); val = decode_value (p, &p); *(float*)ji->data.target = *(float*)&val; break; } case MONO_PATCH_INFO_R8: { guint32 val [2]; + guint64 v; - ji->data.target = mono_mempool_alloc0 (mp, sizeof (double)); + ji->data.target = mono_domain_alloc0 (mono_domain_get (), sizeof (double)); val [0] = decode_value (p, &p); val [1] = decode_value (p, &p); - *(double*)ji->data.target = *(double*)val; + v = ((guint64)val [1] << 32) | ((guint64)val [0]); + *(double*)ji->data.target = *(double*)&v; break; } case MONO_PATCH_INFO_LDSTR: - image = load_image (aot_module, decode_value (p, &p)); + image = load_image (aot_module, decode_value (p, &p), TRUE); if (!image) goto cleanup; ji->data.token = mono_jump_info_token_new (mp, image, MONO_TOKEN_STRING + decode_value (p, &p)); @@ -1824,7 +2325,7 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin case MONO_PATCH_INFO_LDTOKEN: case MONO_PATCH_INFO_TYPE_FROM_HANDLE: /* Shared */ - image = load_image (aot_module, decode_value (p, &p)); + image = load_image (aot_module, decode_value (p, &p), TRUE); if (!image) goto cleanup; ji->data.token = mono_jump_info_token_new (mp, image, decode_value (p, &p)); @@ -1867,6 +2368,17 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin ji->data.rgctx_entry = entry; break; } + case MONO_PATCH_INFO_SEQ_POINT_INFO: + break; + case MONO_PATCH_INFO_LLVM_IMT_TRAMPOLINE: { + MonoJumpInfoImtTramp *imt_tramp = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoImtTramp)); + + imt_tramp->method = decode_method_ref_2 (aot_module, p, &p); + imt_tramp->vt_offset = decode_value (p, &p); + + ji->data.imt_tramp = imt_tramp; + break; + } default: g_warning ("unhandled type %d", ji->type); g_assert_not_reached (); @@ -1880,84 +2392,43 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin return FALSE; } -/* - * decode_got_entry: - * - * Decode a reference to a GOT entry. GOT_OFFSET is set to the index of the got - * entry. If that got entry is not already filled out, then JI is filled out with - * the information required to resolve the value of the GOT entry. - * FIXME: Clean up this confusing API. - */ -static gboolean -decode_got_entry (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guint8 *buf, guint8 **endbuf, guint32 *got_offset) -{ - guint8 *p = buf; - guint8 *shared_p; - gboolean res; - - if (is_shared_got_patch (ji)) { - *got_offset = decode_value (p, &p); - - if (aot_module->got [*got_offset]) { - /* Already loaded */ - //printf ("HIT!\n"); - } else { - shared_p = aot_module->got_info + aot_module->got_info_offsets [*got_offset]; - - res = decode_patch (aot_module, mp, ji, shared_p, &shared_p); - if (!res) - return FALSE; - } - } else { - res = decode_patch (aot_module, mp, ji, p, &p); - if (!res) - return FALSE; - } - - *endbuf = p; - return TRUE; -} - static MonoJumpInfo* load_patch_info (MonoAotModule *aot_module, MonoMemPool *mp, int n_patches, - guint32 got_index, guint32 **got_slots, + guint32 **got_slots, guint8 *buf, guint8 **endbuf) { MonoJumpInfo *patches; - MonoJumpInfo *patch_info = NULL; int pindex; - guint32 last_offset; guint8 *p; p = buf; - /* First load the type + offset table */ - last_offset = 0; patches = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo) * n_patches); - for (pindex = 0; pindex < n_patches; ++pindex) { - MonoJumpInfo *ji = &patches [pindex]; - - ji->type = *p; - p ++; - - //printf ("T: %d O: %d.\n", ji->type, ji->ip.i); - ji->next = patch_info; - patch_info = ji; - } - *got_slots = g_malloc (sizeof (guint32) * n_patches); - memset (*got_slots, 0xff, sizeof (guint32) * n_patches); - /* Then load the other data */ for (pindex = 0; pindex < n_patches; ++pindex) { MonoJumpInfo *ji = &patches [pindex]; + guint8 *shared_p; + gboolean res; + guint32 got_offset; - if (!decode_got_entry (aot_module, mp, ji, p, &p, (*got_slots) + pindex)) - goto cleanup; + got_offset = decode_value (p, &p); - if ((*got_slots) [pindex] == 0xffffffff) - (*got_slots) [pindex] = got_index ++; + if (aot_module->got [got_offset]) { + /* Already loaded */ + //printf ("HIT!\n"); + } else { + shared_p = aot_module->blob + mono_aot_get_offset (aot_module->got_info_offsets, got_offset); + + ji->type = decode_value (shared_p, &shared_p); + + res = decode_patch (aot_module, mp, ji, shared_p, &shared_p); + if (!res) + goto cleanup; + } + + (*got_slots) [pindex] = got_offset; } *endbuf = p; @@ -1999,28 +2470,28 @@ register_jump_target_got_slot (MonoDomain *domain, MonoMethod *method, gpointer * METHOD might not be set if the caller only has the image/token info. */ static gpointer -load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, MonoMethod *method, guint32 token, int method_index) +load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoMethod *method, guint32 token, int method_index) { MonoClass *klass; gboolean from_plt = method == NULL; MonoMemPool *mp; - int i, pindex, got_index = 0, n_patches, used_strings; + int i, pindex, n_patches, used_strings; gboolean keep_patches = TRUE; - guint8 *p, *ex_info; + guint8 *p; MonoJitInfo *jinfo = NULL; guint8 *code, *info; if (mono_profiler_get_events () & MONO_PROFILE_ENTER_LEAVE) return NULL; - if ((domain != mono_get_root_domain ()) && (!(aot_module->opts & MONO_OPT_SHARED))) + if ((domain != mono_get_root_domain ()) && (!(amodule->info.opts & MONO_OPT_SHARED))) /* Non shared AOT code can't be used in other appdomains */ return NULL; - if (aot_module->out_of_date) + if (amodule->out_of_date) return NULL; - if (aot_module->code_offsets [method_index] == 0xffffffff) { + if (amodule->code_offsets [method_index] == 0xffffffff) { if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) { char *full_name; @@ -2033,49 +2504,44 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo return NULL; } - code = &aot_module->code [aot_module->code_offsets [method_index]]; - info = &aot_module->method_info [aot_module->method_info_offsets [method_index]]; + code = &amodule->code [amodule->code_offsets [method_index]]; + + info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)]; mono_aot_lock (); - if (!aot_module->methods_loaded) - aot_module->methods_loaded = g_new0 (guint32, image->tables [MONO_TABLE_METHOD].rows + 1); + if (!amodule->methods_loaded) + amodule->methods_loaded = g_new0 (guint32, amodule->info.nmethods + 1); mono_aot_unlock (); - if ((aot_module->methods_loaded [method_index / 32] >> (method_index % 32)) & 0x1) + if ((amodule->methods_loaded [method_index / 32] >> (method_index % 32)) & 0x1) return code; if (mono_last_aot_method != -1) { - if (mono_jit_stats.methods_aot > mono_last_aot_method) + if (mono_jit_stats.methods_aot >= mono_last_aot_method) return NULL; - else - if (method && mono_jit_stats.methods_aot == mono_last_aot_method) - printf ("LAST AOT METHOD: %s.%s.%s.\n", method->klass->name_space, method->klass->name, method->name); + else if (mono_jit_stats.methods_aot == mono_last_aot_method - 1) { + if (!method) + method = mono_get_method (image, token, NULL); + if (method) { + char *name = mono_method_full_name (method, TRUE); + printf ("LAST AOT METHOD: %s.\n", name); + g_free (name); + } else { + printf ("LAST AOT METHOD: %p %d\n", code, method_index); + } + } } p = info; if (method) { klass = method->klass; - decode_klass_ref (aot_module, p, &p); + decode_klass_ref (amodule, p, &p); } else { - klass = decode_klass_ref (aot_module, p, &p); + klass = decode_klass_ref (amodule, p, &p); } - if (!use_loaded_code) { - guint8 *code2; - - if (!jinfo) { - ex_info = &aot_module->ex_info [aot_module->ex_info_offsets [mono_metadata_token_index (token) - 1]]; - jinfo = decode_exception_debug_info (aot_module, domain, method, ex_info, code); - } - - code2 = mono_domain_code_reserve (domain, jinfo->code_size); - memcpy (code2, code, jinfo->code_size); - mono_arch_flush_icache (code2, jinfo->code_size); - code = code2; - } - - if (aot_module->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) used_strings = decode_value (p, &p); else used_strings = 0; @@ -2085,7 +2551,7 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo mono_ldstr (mono_get_root_domain (), image, mono_metadata_token_index (token)); } - if (aot_module->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) keep_patches = FALSE; n_patches = decode_value (p, &p); @@ -2101,19 +2567,19 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo else mp = mono_mempool_new (); - got_index = decode_value (p, &p); - - patches = load_patch_info (aot_module, mp, n_patches, got_index, &got_slots, p, &p); + patches = load_patch_info (amodule, mp, n_patches, &got_slots, p, &p); if (patches == NULL) goto cleanup; for (pindex = 0; pindex < n_patches; ++pindex) { MonoJumpInfo *ji = &patches [pindex]; - if (!aot_module->got [got_slots [pindex]]) { - aot_module->got [got_slots [pindex]] = mono_resolve_patch_target (method, domain, code, ji, TRUE); + if (!amodule->got [got_slots [pindex]]) { + amodule->got [got_slots [pindex]] = mono_resolve_patch_target (method, domain, code, ji, TRUE); if (ji->type == MONO_PATCH_INFO_METHOD_JUMP) - register_jump_target_got_slot (domain, ji->data.method, &(aot_module->got [got_slots [pindex]])); + amodule->got [got_slots [pindex]] = mono_create_ftnptr (domain, amodule->got [got_slots [pindex]]); + if (ji->type == MONO_PATCH_INFO_METHOD_JUMP) + register_jump_target_got_slot (domain, ji->data.method, &(amodule->got [got_slots [pindex]])); } ji->type = MONO_PATCH_INFO_NONE; } @@ -2132,10 +2598,8 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo full_name = mono_method_full_name (method, TRUE); - if (!jinfo) { - ex_info = &aot_module->ex_info [aot_module->ex_info_offsets [method_index]]; - jinfo = decode_exception_debug_info (aot_module, domain, method, ex_info, code); - } + if (!jinfo) + jinfo = mono_aot_find_jit_info (domain, amodule->assembly->image, code); mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT FOUND AOT compiled code for %s %p - %p %p\n", full_name, code, code + jinfo->code_size, info); g_free (full_name); @@ -2145,15 +2609,28 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo mono_jit_stats.methods_aot++; - aot_module->methods_loaded [method_index / 32] |= 1 << (method_index % 32); + amodule->methods_loaded [method_index / 32] |= 1 << (method_index % 32); - init_plt (aot_module); + init_plt (amodule); if (method && method->wrapper_type) - g_hash_table_insert (aot_module->method_to_code, method, code); + g_hash_table_insert (amodule->method_to_code, method, code); mono_aot_unlock (); + if (mono_profiler_get_events () & MONO_PROFILE_JIT_COMPILATION) { + MonoJitInfo *jinfo; + + if (!method) { + method = mono_get_method (image, token, NULL); + g_assert (method); + } + mono_profiler_method_jit (method); + jinfo = mono_jit_info_table_find (domain, (char*)code); + g_assert (jinfo); + mono_profiler_method_end_jit (method, jinfo, MONO_PROFILE_OK); + } + if (from_plt && klass && !klass->generic_container) mono_runtime_class_init (mono_class_vtable (domain, klass)); @@ -2161,7 +2638,7 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo cleanup: /* FIXME: The space in domain->mp is wasted */ - if (aot_module->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) /* No need to cache patches */ mono_mempool_destroy (mp); @@ -2172,13 +2649,12 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo } static guint32 -find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) +find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method, const char *name) { guint32 table_size, entry_size, hash; guint32 *table, *entry; - char *name = NULL; - int num_checks = 0; guint32 index; + static guint32 n_extra_decodes; if (!amodule) return 0xffffff; @@ -2187,10 +2663,6 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) table = amodule->extra_method_table + 1; entry_size = 3; - if (method->wrapper_type) { - name = mono_aot_wrapper_name (method); - } - hash = mono_aot_method_hash (method) % table_size; entry = &table [hash * entry_size]; @@ -2207,7 +2679,7 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) guint8 *p; int is_wrapper_name; - p = amodule->extra_method_info + key; + p = amodule->blob + key; is_wrapper_name = decode_value (p, &p); if (is_wrapper_name) { int wrapper_type = decode_value (p, &p); @@ -2216,7 +2688,6 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) break; } } else if (can_method_ref_match_method (amodule, p, method)) { - num_checks ++; mono_aot_lock (); if (!amodule->method_ref_to_method) amodule->method_ref_to_method = g_hash_table_new (NULL, NULL); @@ -2231,10 +2702,6 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) mono_aot_unlock (); } } - /* - if (m) - printf ("%d %s %s\n", num_checks, mono_method_full_name (method, TRUE), mono_method_full_name (m, TRUE)); - */ if (m == method) { index = value; break; @@ -2251,6 +2718,13 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) break; } } + + /* Methods decoded needlessly */ + /* + if (m) + printf ("%d %s %s\n", n_extra_decodes, mono_method_full_name (method, TRUE), mono_method_full_name (m, TRUE)); + */ + n_extra_decodes ++; } if (next != 0) @@ -2259,7 +2733,6 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) break; } - g_free (name); return index; } @@ -2282,12 +2755,18 @@ find_extra_method (MonoMethod *method, MonoAotModule **out_amodule) guint32 index; GPtrArray *modules; int i; + char *name = NULL; + + if (method->wrapper_type) + name = mono_aot_wrapper_name (method); /* Try the method's module first */ *out_amodule = method->klass->image->aot_module; - index = find_extra_method_in_amodule (method->klass->image->aot_module, method); - if (index != 0xffffff) + index = find_extra_method_in_amodule (method->klass->image->aot_module, method, name); + if (index != 0xffffff) { + g_free (name); return index; + } /* * Try all other modules. @@ -2307,7 +2786,7 @@ find_extra_method (MonoMethod *method, MonoAotModule **out_amodule) MonoAotModule *amodule = g_ptr_array_index (modules, i); if (amodule != method->klass->image->aot_module) - index = find_extra_method_in_amodule (amodule, method); + index = find_extra_method_in_amodule (amodule, method, name); if (index != 0xffffff) { *out_amodule = amodule; break; @@ -2316,9 +2795,17 @@ find_extra_method (MonoMethod *method, MonoAotModule **out_amodule) g_ptr_array_free (modules, TRUE); + g_free (name); return index; } +/* + * mono_aot_get_method: + * + * Return a pointer to the AOTed native code for METHOD if it can be found, + * NULL otherwise. + * On platforms with function pointers, this doesn't return a function pointer. + */ gpointer mono_aot_get_method (MonoDomain *domain, MonoMethod *method) { @@ -2339,6 +2826,14 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method) (method->flags & METHOD_ATTRIBUTE_ABSTRACT)) return NULL; + /* + * Use the original method instead of its invoke-with-check wrapper. + * This is not a problem when using full-aot, since it doesn't support + * remoting. + */ + if (mono_aot_only && method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) + return mono_aot_get_method (domain, mono_marshal_method_from_wrapper (method)); + g_assert (klass->inited); /* Find method index */ @@ -2354,6 +2849,58 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method) return code; method_index = find_extra_method (method, &amodule); + /* + * Special case the ICollection wrappers for arrays, as they cannot + * be statically enumerated, and each wrapper ends up calling the same + * method in Array. + */ + if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && method->klass->rank && strstr (method->name, "System.Collections.Generic")) { + MonoMethod *m = mono_aot_get_array_helper_from_wrapper (method); + + code = mono_aot_get_method (domain, m); + if (code) { + if (mono_method_needs_static_rgctx_invoke (m, FALSE)) { + code = mono_create_static_rgctx_trampoline (m, mono_create_ftnptr (domain, code)); + /* The call above returns an ftnptr */ + code = mono_get_addr_from_ftnptr (code); + } + + return code; + } + } + + /* + * Special case Array.GetGenericValueImpl which is a generic icall. + * Generic sharing currently can't handle it, but the icall returns data using + * an out parameter, so the managed-to-native wrappers can share the same code. + */ + if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && method->klass == mono_defaults.array_class && !strcmp (method->name, "GetGenericValueImpl")) { + MonoMethod *m; + MonoGenericContext ctx; + MonoType *args [16]; + + if (mono_method_signature (method)->params [1]->type == MONO_TYPE_OBJECT) + /* Avoid recursion */ + return NULL; + + m = mono_class_get_method_from_name (mono_defaults.array_class, "GetGenericValueImpl", 2); + g_assert (m); + + memset (&ctx, 0, sizeof (ctx)); + args [0] = &mono_defaults.object_class->byval_arg; + ctx.method_inst = mono_metadata_get_generic_inst (1, args); + + m = mono_marshal_get_native_wrapper (mono_class_inflate_generic_method (m, &ctx), TRUE, TRUE); + + /* + * Get the code for the instantiation which should be emitted into + * the mscorlib aot image by the AOT compiler. + */ + code = mono_aot_get_method (domain, m); + if (code) + return code; + } + if (method_index == 0xffffff) { if (mono_aot_only && mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) { char *full_name; @@ -2411,7 +2958,7 @@ check_is_got_entry (gpointer key, gpointer value, gpointer user_data) IsGotEntryUserData *data = (IsGotEntryUserData*)user_data; MonoAotModule *aot_module = (MonoAotModule*)value; - if (aot_module->got && (data->addr >= (guint8*)(aot_module->got)) && (data->addr < (guint8*)(aot_module->got + aot_module->got_size))) + if (aot_module->got && (data->addr >= (guint8*)(aot_module->got)) && (data->addr < (guint8*)(aot_module->got + aot_module->info.got_size))) data->res = TRUE; } @@ -2474,6 +3021,7 @@ find_aot_module (guint8 *code) * * This function is called by the entries in the PLT to resolve the actual method that * needs to be called. It returns a trampoline to the method and patches the PLT entry. + * Returns NULL if the something cannot be loaded. */ gpointer mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code) @@ -2482,28 +3030,64 @@ mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code guint8 *p, *target, *plt_entry; MonoJumpInfo ji; MonoAotModule *module = (MonoAotModule*)aot_module; - gboolean res; + gboolean res, no_ftnptr = FALSE; MonoMemPool *mp; //printf ("DYN: %p %d\n", aot_module, plt_info_offset); - p = &module->got_info [plt_info_offset]; + p = &module->blob [plt_info_offset]; ji.type = decode_value (p, &p); mp = mono_mempool_new_size (512); res = decode_patch (module, mp, &ji, p, &p); - // FIXME: Error handling (how ?) - g_assert (res); - target = mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE); + if (!res) { + mono_mempool_destroy (mp); + return NULL; + } + + /* + * Avoid calling resolve_patch_target in the full-aot case if possible, since + * it would create a trampoline, and we don't need that. + * We could do this only if the method does not need the special handling + * in mono_magic_trampoline (). + */ + if (mono_aot_only && ji.type == MONO_PATCH_INFO_METHOD && !ji.data.method->is_generic && !mono_method_check_context_used (ji.data.method) && !(ji.data.method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) && + !mono_method_needs_static_rgctx_invoke (ji.data.method, FALSE)) { + target = mono_jit_compile_method (ji.data.method); + no_ftnptr = TRUE; + } else { + target = mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE); + } + + /* + * The trampoline expects us to return a function descriptor on platforms which use + * it, but resolve_patch_target returns a direct function pointer for some type of + * patches, so have to translate between the two. + * FIXME: Clean this up, but how ? + */ + if (ji.type == MONO_PATCH_INFO_ABS || ji.type == MONO_PATCH_INFO_INTERNAL_METHOD || ji.type == MONO_PATCH_INFO_CLASS_INIT || ji.type == MONO_PATCH_INFO_ICALL_ADDR || ji.type == MONO_PATCH_INFO_JIT_ICALL_ADDR || ji.type == MONO_PATCH_INFO_RGCTX_FETCH) { + /* These should already have a function descriptor */ +#ifdef PPC_USES_FUNCTION_DESCRIPTOR + /* Our function descriptors have a 0 environment, gcc created ones don't */ + if (ji.type != MONO_PATCH_INFO_INTERNAL_METHOD && ji.type != MONO_PATCH_INFO_JIT_ICALL_ADDR && ji.type != MONO_PATCH_INFO_ICALL_ADDR) + g_assert (((gpointer*)target) [2] == 0); +#endif + /* Empty */ + } else if (!no_ftnptr) { +#ifdef PPC_USES_FUNCTION_DESCRIPTOR + g_assert (((gpointer*)target) [2] != 0); +#endif + target = mono_create_ftnptr (mono_domain_get (), target); + } mono_mempool_destroy (mp); /* Patch the PLT entry with target which might be the actual method not a trampoline */ plt_entry = mono_aot_get_plt_entry (code); g_assert (plt_entry); - mono_arch_patch_plt_entry (plt_entry, target); + mono_arch_patch_plt_entry (plt_entry, module->got, NULL, target); return target; #else @@ -2520,41 +3104,48 @@ mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code * LOCKING: Assumes the AOT lock is held. */ static void -init_plt (MonoAotModule *info) +init_plt (MonoAotModule *amodule) { +#ifndef MONO_CROSS_COMPILE + #ifdef MONO_ARCH_AOT_SUPPORTED #ifdef __i386__ - guint8 *buf = info->plt; -#elif defined(__x86_64__) || defined(__arm__) + guint8 *buf = amodule->plt; +#elif defined(__x86_64__) || defined(__arm__) || defined(__mono_ppc__) int i; + gpointer plt_0; #endif gpointer tramp; - if (info->plt_inited) + if (amodule->plt_inited) return; - tramp = mono_create_specific_trampoline (info, MONO_TRAMPOLINE_AOT_PLT, mono_get_root_domain (), NULL); + tramp = mono_create_specific_trampoline (amodule, MONO_TRAMPOLINE_AOT_PLT, mono_get_root_domain (), NULL); #ifdef __i386__ /* Initialize the first PLT entry */ - make_writable (info->plt, info->plt_end - info->plt); + make_writable (amodule->plt, amodule->plt_end - amodule->plt); x86_jump_code (buf, tramp); -#elif defined(__x86_64__) || defined(__arm__) +#elif defined(__x86_64__) || defined(__arm__) || defined(__mono_ppc__) /* * Initialize the PLT entries in the GOT to point to the default targets. */ + tramp = mono_create_ftnptr (mono_domain_get (), tramp); + plt_0 = mono_create_ftnptr (mono_domain_get (), amodule->plt); /* The first entry points to the AOT trampoline */ - ((gpointer*)info->got)[info->plt_got_offset_base] = tramp; - for (i = 1; i < info->plt_size; ++i) + ((gpointer*)amodule->got)[amodule->info.plt_got_offset_base] = tramp; + for (i = 1; i < amodule->info.plt_size; ++i) /* All the default entries point to the first entry */ - ((gpointer*)info->got)[info->plt_got_offset_base + i] = info->plt; + ((gpointer*)amodule->got)[amodule->info.plt_got_offset_base + i] = plt_0; #else g_assert_not_reached (); #endif - info->plt_inited = TRUE; + amodule->plt_inited = TRUE; #endif + +#endif /* MONO_CROSS_COMPILE */ } /* @@ -2566,7 +3157,7 @@ guint8* mono_aot_get_plt_entry (guint8 *code) { MonoAotModule *aot_module = find_aot_module (code); -#if defined(__arm__) +#if defined(__arm__) || defined(__mono_ppc__) guint32 ins; #endif @@ -2592,6 +3183,17 @@ mono_aot_get_plt_entry (guint8 *code) if ((target >= (guint8*)(aot_module->plt)) && (target < (guint8*)(aot_module->plt_end))) return target; } +#elif defined(__mono_ppc__) + /* Should be a bl */ + ins = ((guint32*)(gpointer)code) [-1]; + + if ((ins >> 26 == 18) && ((ins & 1) == 1) && ((ins & 2) == 0)) { + gint32 disp = (((gint32)ins) >> 2) & 0xffffff; + guint8 *target = code - 4 + (disp * 4); + + if ((target >= (guint8*)(aot_module->plt)) && (target < (guint8*)(aot_module->plt_end))) + return target; + } #else g_assert_not_reached (); #endif @@ -2605,7 +3207,7 @@ mono_aot_get_plt_entry (guint8 *code) * Return the PLT info offset belonging to the plt entry called by CODE. */ guint32 -mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) +mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) { guint8 *plt_entry = mono_aot_get_plt_entry (code); @@ -2617,8 +3219,14 @@ mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) #elif defined(__x86_64__) return *(guint32*)(plt_entry + 6); #elif defined(__arm__) - /* The offset is stored as the 5th word of the plt entry */ - return ((guint32*)plt_entry) [4]; + /* The offset is stored as the 4th word of the plt entry */ + return ((guint32*)plt_entry) [3]; +#elif defined(__mono_ppc__) +#ifdef PPC_USES_FUNCTION_DESCRIPTOR + return ((guint32*)plt_entry) [8]; +#else + return ((guint32*)plt_entry) [6]; +#endif #else g_assert_not_reached (); return 0; @@ -2626,11 +3234,32 @@ mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) } static gpointer -load_named_code (MonoAotModule *amodule, const char *name) +mono_create_ftnptr_malloc (guint8 *code) +{ +#ifdef PPC_USES_FUNCTION_DESCRIPTOR + MonoPPCFunctionDescriptor *ftnptr = g_malloc0 (sizeof (MonoPPCFunctionDescriptor)); + + ftnptr->code = code; + ftnptr->toc = NULL; + ftnptr->env = NULL; + + return ftnptr; +#else + return code; +#endif +} + +/* + * load_function: + * + * Load the function named NAME from the aot image. + */ +static gpointer +load_function (MonoAotModule *amodule, const char *name) { char *symbol; guint8 *p; - int n_patches, got_index, pindex; + int n_patches, pindex; MonoMemPool *mp; gpointer code; @@ -2653,6 +3282,8 @@ load_named_code (MonoAotModule *amodule, const char *name) /* Nothing to patch */ return code; + p = amodule->blob + *(guint32*)p; + /* Similar to mono_aot_load_method () */ n_patches = decode_value (p, &p); @@ -2663,9 +3294,7 @@ load_named_code (MonoAotModule *amodule, const char *name) mp = mono_mempool_new (); - got_index = decode_value (p, &p); - - patches = load_patch_info (amodule, mp, n_patches, got_index, &got_slots, p, &p); + patches = load_patch_info (amodule, mp, n_patches, &got_slots, p, &p); g_assert (patches); for (pindex = 0; pindex < n_patches; ++pindex) { @@ -2676,7 +3305,7 @@ load_named_code (MonoAotModule *amodule, const char *name) continue; /* - * When this code is executed, the runtime may not yet initalized, so + * When this code is executed, the runtime may not be initalized yet, so * resolve the patch info by hand. */ if (ji->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) { @@ -2701,6 +3330,10 @@ load_named_code (MonoAotModule *amodule, const char *name) target = mono_arm_throw_exception; } else if (!strcmp (ji->data.name, "mono_arm_throw_exception_by_token")) { target = mono_arm_throw_exception_by_token; +#endif +#ifdef __mono_ppc__ + } else if (!strcmp (ji->data.name, "mono_ppc_throw_exception")) { + target = mono_ppc_throw_exception; #endif } else if (strstr (ji->data.name, "trampoline_func_") == ji->data.name) { int tramp_type2 = atoi (ji->data.name + strlen ("trampoline_func_")); @@ -2713,12 +3346,16 @@ load_named_code (MonoAotModule *amodule, const char *name) res = sscanf (ji->data.name, "specific_trampoline_lazy_fetch_%u", &slot); g_assert (res == 1); target = mono_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL); + target = mono_create_ftnptr_malloc (target); } else if (!strcmp (ji->data.name, "specific_trampoline_monitor_enter")) { target = mono_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_ENTER, mono_get_root_domain (), NULL); + target = mono_create_ftnptr_malloc (target); } else if (!strcmp (ji->data.name, "specific_trampoline_monitor_exit")) { target = mono_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_EXIT, mono_get_root_domain (), NULL); + target = mono_create_ftnptr_malloc (target); } else if (!strcmp (ji->data.name, "specific_trampoline_generic_class_init")) { target = mono_create_specific_trampoline (NULL, MONO_TRAMPOLINE_GENERIC_CLASS_INIT, mono_get_root_domain (), NULL); + target = mono_create_ftnptr_malloc (target); } else if (!strcmp (ji->data.name, "mono_thread_get_and_clear_pending_exception")) { target = mono_thread_get_and_clear_pending_exception; } else { @@ -2747,6 +3384,7 @@ load_named_code (MonoAotModule *amodule, const char *name) /* * Return the piece of code identified by NAME from the mscorlib AOT file. + * On ppc64, this returns a function descriptor. */ gpointer mono_aot_get_named_code (const char *name) @@ -2760,21 +3398,16 @@ mono_aot_get_named_code (const char *name) amodule = image->aot_module; g_assert (amodule); - return load_named_code (amodule, name); + return mono_create_ftnptr_malloc (load_function (amodule, name)); } -/* - * Return a specific trampoline from the AOT file. - */ -gpointer -mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +/* Return a given kind of trampoline */ +static gpointer +get_numerous_trampoline (MonoAotTrampoline tramp_type, int n_got_slots, MonoAotModule **out_amodule, guint32 *got_offset, guint32 *out_tramp_size) { MonoAotModule *amodule; int index, tramp_size; - guint8 *code, *tramp; - static gpointer generic_trampolines [MONO_TRAMPOLINE_NUM]; - static gboolean inited; - static guint32 num_trampolines; + MonoImage *image; /* Currently, we keep all trampolines in the mscorlib AOT image */ image = mono_defaults.corlib; @@ -2782,23 +3415,54 @@ mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampo mono_aot_lock (); - if (!inited) { - mono_counters_register ("Specific trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &num_trampolines); - inited = TRUE; - } - amodule = image->aot_module; g_assert (amodule); - if (amodule->specific_trampoline_index == amodule->num_specific_trampolines) - g_error ("Ran out of trampolines in '%s' (%d)\n", image->name, amodule->num_specific_trampolines); + *out_amodule = amodule; - index = amodule->specific_trampoline_index ++; + if (amodule->trampoline_index [tramp_type] == amodule->info.num_trampolines [tramp_type]) + g_error ("Ran out of trampolines of type %d in '%s' (%d)\n", tramp_type, image->name, amodule->info.num_trampolines [tramp_type]); - num_trampolines ++; + index = amodule->trampoline_index [tramp_type] ++; mono_aot_unlock (); + *got_offset = amodule->info.trampoline_got_offset_base [tramp_type] + (index * n_got_slots); + + tramp_size = amodule->info.trampoline_size [tramp_type]; + + if (out_tramp_size) + *out_tramp_size = tramp_size; + + return amodule->trampolines [tramp_type] + (index * tramp_size); +} + +/* + * Return a specific trampoline from the AOT file. + */ +gpointer +mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +{ + MonoAotModule *amodule; + guint32 got_offset, tramp_size; + guint8 *code, *tramp; + static gpointer generic_trampolines [MONO_TRAMPOLINE_NUM]; + static gboolean inited; + static guint32 num_trampolines; + + if (!inited) { + mono_aot_lock (); + + if (!inited) { + mono_counters_register ("Specific trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &num_trampolines); + inited = TRUE; + } + + mono_aot_unlock (); + } + + num_trampolines ++; + if (!generic_trampolines [tramp_type]) { char *symbol; @@ -2810,12 +3474,11 @@ mono_aot_create_specific_trampoline (MonoImage *image, gpointer arg1, MonoTrampo tramp = generic_trampolines [tramp_type]; g_assert (tramp); - amodule->got [amodule->specific_trampoline_got_offset_base + (index *2)] = tramp; - amodule->got [amodule->specific_trampoline_got_offset_base + (index *2) + 1] = arg1; + code = get_numerous_trampoline (MONO_AOT_TRAMP_SPECIFIC, 2, &amodule, &got_offset, &tramp_size); - tramp_size = amodule->specific_trampoline_size; + amodule->got [got_offset] = tramp; + amodule->got [got_offset + 1] = arg1; - code = amodule->specific_trampolines + (index * tramp_size); if (code_len) *code_len = tramp_size; @@ -2826,34 +3489,16 @@ gpointer mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr) { MonoAotModule *amodule; - int index, tramp_size; guint8 *code; - MonoImage *image; - - /* Currently, we keep all trampolines in the mscorlib AOT image */ - image = mono_defaults.corlib; - g_assert (image); + guint32 got_offset; - mono_aot_lock (); + code = get_numerous_trampoline (MONO_AOT_TRAMP_STATIC_RGCTX, 2, &amodule, &got_offset, NULL); - amodule = image->aot_module; - g_assert (amodule); - - if (amodule->static_rgctx_trampoline_index == amodule->num_static_rgctx_trampolines) - g_error ("Ran out of trampolines in '%s' (%d)\n", image->name, amodule->num_static_rgctx_trampolines); + amodule->got [got_offset] = ctx; + amodule->got [got_offset + 1] = addr; - index = amodule->static_rgctx_trampoline_index ++; - - mono_aot_unlock (); - - amodule->got [amodule->static_rgctx_trampoline_got_offset_base + (index *2)] = ctx; - amodule->got [amodule->static_rgctx_trampoline_got_offset_base + (index *2) + 1] = addr; - - tramp_size = amodule->static_rgctx_trampoline_size; - - code = amodule->static_rgctx_trampolines + (index * tramp_size); - - return code; + /* The caller expects an ftnptr */ + return mono_create_ftnptr (mono_domain_get (), code); } gpointer @@ -2864,9 +3509,8 @@ mono_aot_get_unbox_trampoline (MonoMethod *method) char *symbol; gpointer code; - if (method->is_inflated) { + if (method->is_inflated && !mono_method_is_generic_sharable_impl (method, FALSE)) { guint32 index = find_extra_method (method, &amodule); - g_assert (index != 0xffffff); symbol = g_strdup_printf ("ut_e_%d", index); @@ -2876,9 +3520,11 @@ mono_aot_get_unbox_trampoline (MonoMethod *method) symbol = g_strdup_printf ("ut_%d", method_index); } - code = load_named_code (amodule, symbol); + code = load_function (amodule, symbol); g_free (symbol); - return code; + + /* The caller expects an ftnptr */ + return mono_create_ftnptr (mono_domain_get (), code); } gpointer @@ -2888,8 +3534,40 @@ mono_aot_get_lazy_fetch_trampoline (guint32 slot) gpointer code; symbol = g_strdup_printf ("rgctx_fetch_trampoline_%u", slot); - code = load_named_code (mono_defaults.corlib->aot_module, symbol); + code = load_function (mono_defaults.corlib->aot_module, symbol); g_free (symbol); + /* The caller expects an ftnptr */ + return mono_create_ftnptr (mono_domain_get (), code); +} + +gpointer +mono_aot_get_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) +{ + guint32 got_offset; + gpointer code; + gpointer *buf; + int i; + MonoAotModule *amodule; + + code = get_numerous_trampoline (MONO_AOT_TRAMP_IMT_THUNK, 1, &amodule, &got_offset, NULL); + + /* Save the entries into an array */ + buf = mono_domain_alloc (domain, (count + 1) * 2 * sizeof (gpointer)); + for (i = 0; i < count; ++i) { + MonoIMTCheckItem *item = imt_entries [i]; + + g_assert (item->key); + /* FIXME: */ + g_assert (!item->has_target_code); + + buf [(i * 2)] = item->key; + buf [(i * 2) + 1] = &(vtable->vtable [item->value.vtable_slot]); + } + buf [(count * 2)] = NULL; + buf [(count * 2) + 1] = fail_tramp; + + amodule->got [got_offset] = buf; + return code; } @@ -2956,7 +3634,7 @@ mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int sl } guint32 -mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) +mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) { g_assert_not_reached (); @@ -2998,4 +3676,18 @@ mono_aot_get_lazy_fetch_trampoline (guint32 slot) return NULL; } +gpointer +mono_aot_get_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) +{ + g_assert_not_reached (); + return NULL; +} + +guint8* +mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) +{ + g_assert_not_reached (); + return NULL; +} + #endif