X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Faot-runtime.c;h=af8894e170c20fcad0dc0839688690423a23186f;hb=fda9d8949d2a03de8b2e1492bfa253bb1567e78e;hp=530ac947ed97a185fd47659908a1dae87ab1f8e2;hpb=795b738e43c346ffb1e183c2c3184c3512b74cca;p=mono.git diff --git a/mono/mini/aot-runtime.c b/mono/mini/aot-runtime.c index 530ac947ed9..af8894e170c 100644 --- a/mono/mini/aot-runtime.c +++ b/mono/mini/aot-runtime.c @@ -74,8 +74,6 @@ typedef struct MonoAotModule { char *aot_name; - /* Optimization flags used to compile the module */ - guint32 opts; /* Pointer to the Global Offset Table */ gpointer *got; GHashTable *name_cache; @@ -97,28 +95,28 @@ typedef struct MonoAotModule { guint8 *code_end; guint8 *plt; guint8 *plt_end; + 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; - guint8 *method_info; guint32 *method_info_offsets; - guint8 *got_info; guint32 *got_info_offsets; - guint8 *ex_info; guint32 *ex_info_offsets; - 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; - /* Points to the the GNU .eh_frame_hdr section, if it exists */ + /* 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 */ @@ -176,37 +174,48 @@ init_plt (MonoAotModule *info); /* 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) { @@ -237,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); @@ -308,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); @@ -322,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)); @@ -372,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); @@ -389,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; @@ -571,6 +623,19 @@ decode_method_ref (MonoAotModule *module, guint32 *token, MonoMethod **method, g *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 (); } @@ -581,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) { @@ -599,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; @@ -654,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; } @@ -831,20 +896,55 @@ 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]; - *value = NULL; - for (i = 0; globals [i]; i+= 2) { - if (strcmp (globals [i], name) == 0) { - *value = globals [i + 1]; + /* 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; + } + + 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) @@ -856,6 +956,10 @@ dl_callback (struct dl_phdr_info *info, size_t size, void *data) 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 { @@ -961,14 +1065,7 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) find_symbol (sofile, globals, "mono_aot_file_info", (gpointer*)&file_info); g_assert (file_info); - { - char *full_aot_str; - - find_symbol (sofile, globals, "mono_aot_full_aot", (gpointer *)&full_aot_str); - - 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); @@ -1008,8 +1105,6 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) 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; @@ -1052,20 +1147,16 @@ 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, "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->trampolines [MONO_AOT_TRAMP_SPECIFIC])); find_symbol (sofile, globals, "static_rgctx_trampolines", (gpointer*)&(amodule->trampolines [MONO_AOT_TRAMP_STATIC_RGCTX])); @@ -1128,9 +1219,10 @@ load_aot_module (MonoAssembly *assembly, gpointer user_data) * 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); @@ -1220,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); @@ -1258,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); @@ -1290,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) @@ -1355,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 = mono_aot_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); @@ -1438,7 +1531,7 @@ typedef struct * file belong to CODE, and construct a MonoJitInfo structure from it. * LOCKING: Acquires the domain lock. */ -static void +static G_GNUC_UNUSED void decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, MonoMethod *method, guint8 *code, MonoJitInfo *jinfo) { @@ -1448,8 +1541,10 @@ decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, guint32 eh_frame_ptr; int fde_count; gint32 *table; - int pos, left, right, offset, offset1, offset2; + int i, pos, left, right, offset, offset1, offset2; guint32 unw_len, code_len; + MonoJitExceptionInfo *ei; + guint32 ei_len; g_assert (amodule->eh_frame_hdr); @@ -1496,7 +1591,289 @@ decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, eh_frame = amodule->eh_frame_hdr + table [(pos * 2) + 1]; - unwind_info = mono_unwind_get_ops_from_fde (eh_frame, &unw_len, &code_len); + 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); @@ -1506,6 +1883,7 @@ decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, /* This signals that used_regs points to a normal cached unwind info */ jinfo->from_aot = 0; } +#endif /* * LOCKING: Acquires the domain lock. @@ -1513,24 +1891,25 @@ decode_eh_frame (MonoAotModule *amodule, MonoDomain *domain, static MonoJitInfo* decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, MonoMethod *method, guint8* ex_info, guint8 *addr, - guint8 *code) + guint8 *code, guint32 code_len) { int i, buf_len; MonoJitInfo *jinfo; - guint code_len, used_int_regs, flags; + guint used_int_regs, flags; gboolean has_generic_jit_info, has_dwarf_unwind_info, has_clauses, has_seq_points; + gboolean from_llvm; guint8 *p; int generic_info_size; /* 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; @@ -1575,10 +1954,15 @@ decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, jinfo = mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO + generic_info_size); } - if (code_len == 0) { + if (from_llvm) { /* LLVM compiled method */ /* The info is in the .eh_frame section */ - decode_eh_frame (amodule, domain, method, code, jinfo); +#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; @@ -1607,19 +1991,25 @@ decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, } if (has_seq_points) { - GPtrArray *seq_points; - int il_offset, native_offset, last_il_offset, last_native_offset; + MonoSeqPointInfo *seq_points; + int il_offset, native_offset, last_il_offset, last_native_offset, j; int len = decode_value (p, &p); - seq_points = g_ptr_array_new (); + 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 += 2) { + 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); - g_ptr_array_add (seq_points, GINT_TO_POINTER (il_offset)); - g_ptr_array_add (seq_points, GINT_TO_POINTER (native_offset)); + 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; @@ -1683,7 +2073,7 @@ compare_ints (const void *a, const void *b) MonoJitInfo * mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) { - int pos, left, right, offset, offset1, offset2; + int pos, left, right, offset, offset1, offset2, code_len; int method_index, table_len, is_wrapper; guint32 token; MonoAotModule *amodule = image->aot_module; @@ -1748,6 +2138,16 @@ mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) 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) { mono_aot_lock (); @@ -1783,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); @@ -1798,13 +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]]; - - g_assert ((guint8*)code <= (guint8*)addr); - jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, 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); @@ -1880,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; @@ -1915,13 +2310,12 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin val [0] = decode_value (p, &p); val [1] = decode_value (p, &p); - // FIXME: Is this correct ? 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)); @@ -1931,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)); @@ -2025,7 +2419,7 @@ load_patch_info (MonoAotModule *aot_module, MonoMemPool *mp, int n_patches, /* Already loaded */ //printf ("HIT!\n"); } else { - shared_p = aot_module->got_info + aot_module->got_info_offsets [got_offset]; + shared_p = aot_module->blob + mono_aot_get_offset (aot_module->got_info_offsets, got_offset); ji->type = decode_value (shared_p, &shared_p); @@ -2083,14 +2477,14 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM MonoMemPool *mp; 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 ()) && (!(amodule->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; @@ -2111,7 +2505,8 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM } code = &amodule->code [amodule->code_offsets [method_index]]; - info = &amodule->method_info [amodule->method_info_offsets [method_index]]; + + info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)]; mono_aot_lock (); if (!amodule->methods_loaded) @@ -2125,10 +2520,15 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM if (mono_jit_stats.methods_aot >= mono_last_aot_method) return NULL; else if (mono_jit_stats.methods_aot == mono_last_aot_method - 1) { - if (method) - printf ("LAST AOT METHOD: %s%s%s.%s.\n", method->klass->name_space, method->klass->name_space [0] ? "." : "", method->klass->name, method->name); - else + 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); + } } } @@ -2141,7 +2541,7 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM klass = decode_klass_ref (amodule, p, &p); } - if (amodule->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) used_strings = decode_value (p, &p); else used_strings = 0; @@ -2151,7 +2551,7 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM mono_ldstr (mono_get_root_domain (), image, mono_metadata_token_index (token)); } - if (amodule->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) keep_patches = FALSE; n_patches = decode_value (p, &p); @@ -2198,10 +2598,8 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM full_name = mono_method_full_name (method, TRUE); - if (!jinfo) { - ex_info = &amodule->ex_info [amodule->ex_info_offsets [method_index]]; - jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, code, 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); @@ -2240,7 +2638,7 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM cleanup: /* FIXME: The space in domain->mp is wasted */ - if (amodule->opts & MONO_OPT_SHARED) + if (amodule->info.opts & MONO_OPT_SHARED) /* No need to cache patches */ mono_mempool_destroy (mp); @@ -2251,11 +2649,10 @@ load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoM } 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; guint32 index; static guint32 n_extra_decodes; @@ -2266,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]; @@ -2286,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); @@ -2340,7 +2733,6 @@ find_extra_method_in_amodule (MonoAotModule *amodule, MonoMethod *method) break; } - g_free (name); return index; } @@ -2363,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. @@ -2388,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; @@ -2397,6 +2795,7 @@ find_extra_method (MonoMethod *method, MonoAotModule **out_amodule) g_ptr_array_free (modules, TRUE); + g_free (name); return index; } @@ -2460,8 +2859,11 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *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, 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; } @@ -2619,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) @@ -2632,14 +3035,17 @@ mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code //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); + + if (!res) { + mono_mempool_destroy (mp); + return NULL; + } /* * Avoid calling resolve_patch_target in the full-aot case if possible, since @@ -2655,8 +3061,21 @@ mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code target = mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE); } - // 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_GENERIC_CLASS_INIT && ji.type != MONO_PATCH_INFO_ICALL_ADDR && ji.type != MONO_PATCH_INFO_JIT_ICALL_ADDR && !no_ftnptr) { + /* + * 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 @@ -2863,6 +3282,8 @@ load_function (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); @@ -3115,7 +3536,8 @@ mono_aot_get_lazy_fetch_trampoline (guint32 slot) symbol = g_strdup_printf ("rgctx_fetch_trampoline_%u", slot); code = load_function (mono_defaults.corlib->aot_module, symbol); g_free (symbol); - return code; + /* The caller expects an ftnptr */ + return mono_create_ftnptr (mono_domain_get (), code); } gpointer