#define ENABLE_AOT_CACHE
#endif
+/* Number of got entries shared between the JIT and LLVM GOT */
+#define N_COMMON_GOT_ENTRIES 4
+
#define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
#define ALIGN_PTR_TO(ptr,align) (gpointer)((((gssize)(ptr)) + (align - 1)) & (~(align - 1)))
#define ROUND_DOWN(VALUE,SIZE) ((VALUE) & ~((SIZE) - 1))
/* Pointer to the Global Offset Table */
gpointer *got;
gpointer *llvm_got;
+ gpointer shared_got [N_COMMON_GOT_ENTRIES];
GHashTable *name_cache;
GHashTable *extra_methods;
/* Maps methods to their code */
gboolean plt_inited;
guint8 *mem_begin;
guint8 *mem_end;
- /* Points to either the start of JIT compiler or LLVM compiled code */
- guint8 *code;
guint8 *jit_code_start;
guint8 *jit_code_end;
guint8 *llvm_code_start;
guint8 *plt;
guint8 *plt_end;
guint8 *blob;
- gint32 *code_offsets;
- gpointer *method_addresses;
- /* This contains <offset, index> pairs sorted by offset */
- /* This is needed because LLVM emitted methods can be in any order */
- gint32 *sorted_code_offsets;
- gint32 sorted_code_offsets_len;
+ /* Maps method indexes to their code */
+ gpointer *methods;
+ /* Sorted array of method addresses */
+ gpointer *sorted_methods;
+ /* Method indexes for each method in sorted_methods */
+ int *sorted_method_indexes;
+ /* The length of the two tables above */
+ int sorted_methods_len;
guint32 *method_info_offsets;
guint32 *ex_info_offsets;
guint32 *class_info_offsets;
#define mono_aot_page_unlock() mono_mutex_unlock (&aot_page_mutex)
static mono_mutex_t aot_page_mutex;
+static MonoAotModule *mscorlib_aot_module;
+
static void
init_plt (MonoAotModule *info);
compute_llvm_code_range (MonoAotModule *amodule, guint8 **code_start, guint8 **code_end);
static gboolean
-mono_aot_init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass **klass);
+init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass **klass);
/*****************************************************/
/* AOT RUNTIME */
#endif
}
+static void
+init_gots (MonoAotModule *amodule)
+{
+ int i;
+
+ if (amodule->got) {
+ for (i = 0; i < N_COMMON_GOT_ENTRIES; ++i)
+ amodule->got [i] = amodule->shared_got [i];
+ }
+ if (amodule->llvm_got) {
+ for (i = 0; i < N_COMMON_GOT_ENTRIES; ++i)
+ amodule->llvm_got [i] = amodule->shared_got [i];
+ }
+}
+
static void
load_aot_module (MonoAssembly *assembly, gpointer user_data)
{
memcpy (&amodule->info, info, sizeof (*info));
- amodule->got = amodule->info.got;
+ amodule->got = amodule->info.jit_got;
amodule->llvm_got = amodule->info.llvm_got;
amodule->globals = globals;
amodule->sofile = sofile;
}
}
- amodule->method_addresses = info->method_addresses;
- amodule->code = info->methods;
-#ifdef TARGET_ARM
- /* Mask out thumb interop bit */
- amodule->code = (void*)((mgreg_t)amodule->code & ~1);
-#endif
amodule->jit_code_start = info->jit_code_start;
amodule->jit_code_end = info->jit_code_end;
amodule->method_info_offsets = info->method_info_offsets;
amodule->unbox_trampolines_end = info->unbox_trampolines_end;
amodule->unbox_trampoline_addresses = info->unbox_trampoline_addresses;
amodule->unwind_info = info->unwind_info;
+ amodule->mem_begin = amodule->jit_code_start;
amodule->mem_end = info->mem_end;
- amodule->mem_begin = amodule->code;
amodule->plt = info->plt;
amodule->plt_end = info->plt_end;
amodule->mono_eh_frame = info->mono_eh_frame;
amodule->trampolines [MONO_AOT_TRAMP_IMT_THUNK] = info->imt_thunks;
amodule->trampolines [MONO_AOT_TRAMP_GSHAREDVT_ARG] = info->gsharedvt_arg_trampolines;
- /* Compute code_offsets from the method addresses */
- amodule->code_offsets = g_malloc0 (amodule->info.nmethods * sizeof (gint32));
+ if (!strcmp (assembly->aname.name, "mscorlib"))
+ mscorlib_aot_module = amodule;
+
+ /* Compute method addresses */
+ amodule->methods = g_malloc0 (amodule->info.nmethods * sizeof (gpointer));
for (i = 0; i < amodule->info.nmethods; ++i) {
- /* method_addresses () contains a table of branches, since the ios linker can update those correctly */
- void *addr;
+ void *addr = NULL;
- addr = get_call_table_entry (amodule->method_addresses, i);
- g_assert (addr);
- if (addr == amodule->method_addresses)
- amodule->code_offsets [i] = 0xffffffff;
+ /* method_addresses () contains a table of branches, since the ios linker can update those correctly */
+ if (!addr && amodule->info.method_addresses) {
+ addr = get_call_table_entry (amodule->info.method_addresses, i);
+ g_assert (addr);
+ if (addr == amodule->info.method_addresses)
+ addr = NULL;
+ }
+ if (addr == NULL)
+ amodule->methods [i] = GINT_TO_POINTER (-1);
else
- amodule->code_offsets [i] = (char*)addr - (char*)amodule->code;
+ amodule->methods [i] = addr;
}
if (make_unreadable) {
int err, len;
addr = amodule->mem_begin;
+ g_assert (addr);
len = amodule->mem_end - amodule->mem_begin;
/* Round down in both directions to avoid modifying data which is not ours */
mono_aot_lock ();
- aot_code_low_addr = MIN (aot_code_low_addr, (gsize)amodule->jit_code_start);
- aot_code_high_addr = MAX (aot_code_high_addr, (gsize)amodule->jit_code_end);
+ if (amodule->jit_code_start) {
+ aot_code_low_addr = MIN (aot_code_low_addr, (gsize)amodule->jit_code_start);
+ aot_code_high_addr = MAX (aot_code_high_addr, (gsize)amodule->jit_code_end);
+ }
if (amodule->llvm_code_start) {
aot_code_low_addr = MIN (aot_code_low_addr, (gsize)amodule->llvm_code_start);
aot_code_high_addr = MAX (aot_code_high_addr, (gsize)amodule->llvm_code_end);
g_hash_table_insert (aot_modules, assembly, amodule);
mono_aot_unlock ();
- mono_jit_info_add_aot_module (assembly->image, amodule->jit_code_start, amodule->jit_code_end);
+ if (amodule->jit_code_start)
+ mono_jit_info_add_aot_module (assembly->image, amodule->jit_code_start, amodule->jit_code_end);
if (amodule->llvm_code_start)
mono_jit_info_add_aot_module (assembly->image, amodule->llvm_code_start, amodule->llvm_code_end);
assembly->image->aot_module = amodule;
- amodule->got [0] = assembly->image;
+ amodule->shared_got [0] = assembly->image;
if (mono_aot_only) {
char *code;
/* The second got slot contains the mscorlib got addr */
MonoAotModule *mscorlib_amodule = mono_defaults.corlib->aot_module;
- amodule->got [1] = mscorlib_amodule->got;
+ amodule->shared_got [1] = mscorlib_amodule->got;
} else {
- amodule->got [1] = amodule->got;
+ amodule->shared_got [1] = amodule->got;
}
}
memset (&ji, 0, sizeof (ji));
ji.type = MONO_PATCH_INFO_GC_CARD_TABLE_ADDR;
- amodule->got [2] = mono_resolve_patch_target (NULL, mono_get_root_domain (), NULL, &ji, FALSE);
+ amodule->shared_got [2] = mono_resolve_patch_target (NULL, mono_get_root_domain (), NULL, &ji, FALSE);
memset (&ji, 0, sizeof (ji));
ji.type = MONO_PATCH_INFO_GC_NURSERY_START;
- amodule->got [3] = mono_resolve_patch_target (NULL, mono_get_root_domain (), NULL, &ji, FALSE);
+ amodule->shared_got [3] = mono_resolve_patch_target (NULL, mono_get_root_domain (), NULL, &ji, FALSE);
}
- if (amodule->llvm_got) {
- amodule->llvm_got [0] = amodule->got [0];
- amodule->llvm_got [1] = amodule->got [1];
- amodule->llvm_got [2] = amodule->got [2];
- amodule->llvm_got [3] = amodule->got [3];
- }
+ init_gots (amodule);
/*
* Since we store methoddef and classdef tokens when referring to methods/classes in
if (fde_count > 1) {
/* mono_aot_personality () */
g_assert (table [0] == -1);
- *code_start = amodule->code + amodule->code_offsets [table [2]];
- *code_end = amodule->code + amodule->code_offsets [table [(fde_count - 1) * 2]] + table [fde_count * 2];
+ *code_start = amodule->methods [table [2]];
+ *code_end = (guint8*)amodule->methods [table [(fde_count - 1) * 2]] + table [fde_count * 2];
} else {
*code_start = NULL;
*code_end = NULL;
}
}
+static gboolean
+is_llvm_code (MonoAotModule *amodule, guint8 *code)
+{
+ if ((guint8*)code >= amodule->llvm_code_start && (guint8*)code < amodule->llvm_code_end)
+ return TRUE;
+ else
+ return FALSE;
+}
+
static gboolean
is_thumb_code (MonoAotModule *amodule, guint8 *code)
{
- if ((amodule->info.flags & MONO_AOT_FILE_FLAG_LLVM_THUMB) && (guint8*)code >= amodule->llvm_code_start && (guint8*)code < amodule->llvm_code_end)
+ if (is_llvm_code (amodule, code) && (amodule->info.flags & MONO_AOT_FILE_FLAG_LLVM_THUMB))
return TRUE;
else
return FALSE;
}
/*
- * decode_mono_eh_frame:
+ * decode_llvm_mono_eh_frame:
*
* Decode the EH information emitted by our modified LLVM compiler and construct a
* MonoJitInfo structure from it.
GSList **nesting,
int *this_reg, int *this_offset)
{
- guint8 *p;
+ guint8 *p, *code1, *code2;
guint8 *fde, *cie, *code_start, *code_end;
int version, fde_count;
gint32 *table;
- int i, j, pos, left, right, offset, offset1, offset2, code_len;
+ int i, pos, left, right, code_len;
MonoJitExceptionInfo *ei;
guint32 fde_len, ei_len, nested_len, nindex;
gpointer *type_info;
cie = p + ((fde_count + 1) * 8);
/* Binary search in the table to find the entry for code */
- offset = code - amodule->code;
left = 0;
right = fde_count;
while (TRUE) {
/* The table contains method index/fde offset pairs */
g_assert (table [(pos * 2)] != -1);
- offset1 = amodule->code_offsets [table [(pos * 2)]];
+ code1 = amodule->methods [table [(pos * 2)]];
if (pos + 1 == fde_count) {
- offset2 = amodule->llvm_code_end - amodule->llvm_code_start;
+ code2 = amodule->llvm_code_end;
} else {
g_assert (table [(pos + 1) * 2] != -1);
- offset2 = amodule->code_offsets [table [(pos + 1) * 2]];
+ code2 = amodule->methods [table [(pos + 1) * 2]];
}
- if (offset < offset1)
+ if (code < code1)
right = pos;
- else if (offset >= offset2)
+ else if (code >= code2)
left = pos + 1;
else
break;
}
- code_start = amodule->code + amodule->code_offsets [table [(pos * 2)]];
+ code_start = amodule->methods [table [(pos * 2)]];
if (pos + 1 == fde_count) {
/* The +1 entry in the table contains the length of the last method */
int len = table [(pos + 1) * 2];
code_end = code_start + len;
} else {
- code_end = amodule->code + amodule->code_offsets [table [(pos + 1) * 2]];
+ code_end = amodule->methods [table [(pos + 1) * 2]];
}
code_len = code_end - code_start;
gint32 cindex1 = read32 (type_info [i]);
GSList *l;
- for (l = nesting [cindex1]; l; l = l->next) {
- gint32 nesting_cindex = GPOINTER_TO_INT (l->data);
-
- for (j = 0; j < ei_len; ++j) {
- gint32 cindex2 = read32 (type_info [j]);
-
- if (cindex2 == nesting_cindex)
- nested_len ++;
- }
- }
+ for (l = nesting [cindex1]; l; l = l->next)
+ nested_len ++;
}
/*
for (l = nesting [cindex1]; l; l = l->next) {
gint32 nesting_cindex = GPOINTER_TO_INT (l->data);
+ MonoJitExceptionInfo *nesting_ei;
+ MonoJitExceptionInfo *nesting_clause = &clauses [nesting_cindex];
- for (j = 0; j < ei_len; ++j) {
- gint32 cindex2 = read32 (type_info [j]);
+ nesting_ei = &jinfo->clauses [nindex];
+ nindex ++;
- if (cindex2 == nesting_cindex) {
- memcpy (&jinfo->clauses [nindex], &jinfo->clauses [j], sizeof (MonoJitExceptionInfo));
- jinfo->clauses [nindex].try_start = jinfo->clauses [i].try_start;
- jinfo->clauses [nindex].try_end = jinfo->clauses [i].try_end;
- jinfo->clauses [nindex].handler_start = jinfo->clauses [i].handler_start;
- jinfo->clauses [nindex].exvar_offset = jinfo->clauses [i].exvar_offset;
- nindex ++;
- }
- }
+ memcpy (nesting_ei, &jinfo->clauses [i], sizeof (MonoJitExceptionInfo));
+ nesting_ei->flags = nesting_clause->flags;
+ nesting_ei->data.catch_class = nesting_clause->data.catch_class;
+ nesting_ei->clause_index = nesting_cindex;
}
}
g_assert (nindex == ei_len + nested_len);
gi->generic_sharing_context = g_new0 (MonoGenericSharingContext, 1);
if (decode_value (p, &p)) {
/* gsharedvt */
- int i, n;
MonoGenericSharingContext *gsctx = gi->generic_sharing_context;
- n = decode_value (p, &p);
- if (n) {
- gsctx->var_is_vt = alloc0_jit_info_data (domain, sizeof (gboolean) * n, async);
- for (i = 0; i < n; ++i)
- gsctx->var_is_vt [i] = decode_value (p, &p);
- }
- n = decode_value (p, &p);
- if (n) {
- gsctx->mvar_is_vt = alloc0_jit_info_data (domain, sizeof (gboolean) * n, async);
- for (i = 0; i < n; ++i)
- gsctx->mvar_is_vt [i] = decode_value (p, &p);
- }
+ gsctx->is_gsharedvt = TRUE;
}
}
return p;
}
-static G_GNUC_UNUSED int
-compare_ints (const void *a, const void *b)
-{
- return *(gint32*)a - *(gint32*)b;
-}
-
static void
-msort_code_offsets_internal (gint32 *array, int lo, int hi, gint32 *scratch)
+msort_method_addresses_internal (gpointer *array, int *indexes, int lo, int hi, gpointer *scratch, int *scratch_indexes)
{
int mid = (lo + hi) / 2;
int i, t_lo, t_hi;
if (hi - lo < 32) {
for (i = lo; i < hi; ++i)
- if (array [(i * 2)] > array [(i * 2) + 2])
+ if (array [i] > array [i + 1])
break;
if (i == hi)
/* Already sorted */
return;
}
- msort_code_offsets_internal (array, lo, mid, scratch);
- msort_code_offsets_internal (array, mid + 1, hi, scratch);
+ msort_method_addresses_internal (array, indexes, lo, mid, scratch, scratch_indexes);
+ msort_method_addresses_internal (array, indexes, mid + 1, hi, scratch, scratch_indexes);
- if (array [mid * 2] < array [(mid + 1) * 2])
+ if (array [mid] < array [mid + 1])
return;
/* Merge */
t_lo = lo;
t_hi = mid + 1;
for (i = lo; i <= hi; i ++) {
- if (t_lo <= mid && ((t_hi > hi) || array [t_lo * 2] < array [t_hi * 2])) {
- scratch [(i * 2)] = array [t_lo * 2];
- scratch [(i * 2) + 1] = array [(t_lo *2) + 1];
+ if (t_lo <= mid && ((t_hi > hi) || array [t_lo] < array [t_hi])) {
+ scratch [i] = array [t_lo];
+ scratch_indexes [i] = indexes [t_lo];
t_lo ++;
} else {
- scratch [(i * 2)] = array [t_hi * 2];
- scratch [(i * 2) + 1] = array [(t_hi *2) + 1];
+ scratch [i] = array [t_hi];
+ scratch_indexes [i] = indexes [t_hi];
t_hi ++;
}
}
for (i = lo; i <= hi; ++i) {
- array [(i * 2)] = scratch [i * 2];
- array [(i * 2) + 1] = scratch [(i * 2) + 1];
+ array [i] = scratch [i];
+ indexes [i] = scratch_indexes [i];
}
}
static void
-msort_code_offsets (gint32 *array, int len)
+msort_method_addresses (gpointer *array, int *indexes, int len)
{
- gint32 *scratch;
+ gpointer *scratch;
+ int *scratch_indexes;
- scratch = g_new (gint32, len * 2);
- msort_code_offsets_internal (array, 0, len - 1, scratch);
+ scratch = g_new (gpointer, len);
+ scratch_indexes = g_new (int, len);
+ msort_method_addresses_internal (array, indexes, 0, len - 1, scratch, scratch_indexes);
g_free (scratch);
+ g_free (scratch_indexes);
}
/*
MonoJitInfo *
mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr)
{
- int pos, left, right, offset, offset1, offset2, code_len;
+ int pos, left, right, code_len;
int method_index, table_len;
guint32 token;
MonoAotModule *amodule = image->aot_module;
guint8 *code, *ex_info, *p;
guint32 *table;
int nmethods;
- gint32 *code_offsets;
- int offsets_len, i;
+ gpointer *methods;
+ guint8 *code1, *code2;
+ int methods_len, i;
gboolean async;
if (!amodule)
async = mono_thread_info_is_async_context ();
- offset = (guint8*)addr - amodule->code;
-
- /* Compute a sorted table mapping code offsets to method indexes. */
- if (!amodule->sorted_code_offsets) {
+ /* Compute a sorted table mapping code to method indexes. */
+ if (!amodule->sorted_methods) {
// FIXME: async
- code_offsets = g_new0 (gint32, nmethods * 2);
- offsets_len = 0;
+ gpointer *methods = g_new0 (gpointer, nmethods);
+ int *method_indexes = g_new0 (int, nmethods);
+ int methods_len = 0;
+
for (i = 0; i < nmethods; ++i) {
/* Skip the -1 entries to speed up sorting */
- if (amodule->code_offsets [i] == 0xffffffff)
+ if (amodule->methods [i] == GINT_TO_POINTER (-1))
continue;
- code_offsets [(offsets_len * 2)] = amodule->code_offsets [i];
- code_offsets [(offsets_len *2) + 1] = i;
- offsets_len ++;
+ methods [methods_len] = amodule->methods [i];
+ method_indexes [methods_len] = i;
+ methods_len ++;
}
/* Use a merge sort as this is mostly sorted */
- msort_code_offsets (code_offsets, offsets_len);
- //qsort (code_offsets, offsets_len, sizeof (gint32) * 2, compare_ints);
- for (i = 0; i < offsets_len -1; ++i)
- g_assert (code_offsets [(i * 2)] <= code_offsets [(i + 1) * 2]);
-
- amodule->sorted_code_offsets_len = offsets_len;
- mono_memory_barrier ();
- if (InterlockedCompareExchangePointer ((gpointer*)&amodule->sorted_code_offsets, code_offsets, NULL) != NULL)
+ msort_method_addresses (methods, method_indexes, methods_len);
+ for (i = 0; i < methods_len -1; ++i)
+ g_assert (methods [i] <= methods [i + 1]);
+ amodule->sorted_methods_len = methods_len;
+ if (InterlockedCompareExchangePointer ((gpointer*)&amodule->sorted_methods, methods, NULL) != NULL)
+ /* Somebody got in before us */
+ g_free (methods);
+ if (InterlockedCompareExchangePointer ((gpointer*)&amodule->sorted_method_indexes, method_indexes, NULL) != NULL)
/* Somebody got in before us */
- g_free (code_offsets);
+ g_free (method_indexes);
}
- code_offsets = amodule->sorted_code_offsets;
- offsets_len = amodule->sorted_code_offsets_len;
-
- /* Binary search in the sorted_code_offsets table */
+ /* Binary search in the sorted_methods table */
+ methods = amodule->sorted_methods;
+ methods_len = amodule->sorted_methods_len;
+ code = addr;
left = 0;
- right = offsets_len;
+ right = methods_len;
while (TRUE) {
pos = (left + right) / 2;
- offset1 = code_offsets [(pos * 2)];
- if (pos + 1 == offsets_len) {
- if (amodule->code + offset1 >= amodule->jit_code_start && amodule->code + offset1 < amodule->jit_code_end)
- offset2 = amodule->jit_code_end - amodule->code;
+ code1 = methods [pos];
+ if (pos + 1 == methods_len) {
+ if (code1 >= amodule->jit_code_start && code1 < amodule->jit_code_end)
+ code2 = amodule->jit_code_end;
else
- offset2 = amodule->llvm_code_end - amodule->code;
+ code2 = amodule->llvm_code_end;
} else {
- offset2 = code_offsets [(pos + 1) * 2];
+ code2 = methods [pos + 1];
}
- if (offset < offset1)
+ if (code < code1)
right = pos;
- else if (offset >= offset2)
+ else if (code >= code2)
left = pos + 1;
else
break;
}
- g_assert (offset >= code_offsets [(pos * 2)]);
- if (pos + 1 < offsets_len)
- g_assert (offset < code_offsets [((pos + 1) * 2)]);
- method_index = code_offsets [(pos * 2) + 1];
+ g_assert (addr >= methods [pos]);
+ if (pos + 1 < methods_len)
+ g_assert (addr < methods [pos + 1]);
+ method_index = amodule->sorted_method_indexes [pos];
/* In async mode, jinfo is not added to the normal jit info table, so have to cache it ourselves */
if (async) {
}
}
- code = &amodule->code [amodule->code_offsets [method_index]];
+ code = amodule->methods [method_index];
ex_info = &amodule->blob [mono_aot_get_offset (amodule->ex_info_offsets, method_index)];
- if (pos == offsets_len - 1) {
+ if (pos == methods_len - 1) {
if (code >= amodule->jit_code_start && code < amodule->jit_code_end)
code_len = amodule->jit_code_end - code;
else
code_len = amodule->llvm_code_end - code;
} else {
- code_len = code_offsets [(pos + 1) * 2] - code_offsets [pos * 2];
+ code_len = (guint8*)methods [pos + 1] - (guint8*)methods [pos];
}
g_assert ((guint8*)code <= (guint8*)addr && (guint8*)addr < (guint8*)code + code_len);
case MONO_PATCH_INFO_CLASS:
case MONO_PATCH_INFO_IID:
case MONO_PATCH_INFO_ADJUSTED_IID:
- case MONO_PATCH_INFO_CLASS_INIT:
/* Shared */
ji->data.klass = decode_klass_ref (aot_module, p, &p);
if (!ji->data.klass)
MonoClass *klass;
gboolean from_plt = method == NULL;
MonoJitInfo *jinfo = NULL;
- guint8 *code, *info;
+ guint8 *code = NULL, *info;
gboolean res;
if (mono_profiler_get_events () & MONO_PROFILE_ENTER_LEAVE) {
if (amodule->out_of_date)
return NULL;
- if (amodule->code_offsets [method_index] == 0xffffffff) {
- if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) {
- char *full_name;
+ if (!code) {
+ if (amodule->methods [method_index] == GINT_TO_POINTER (-1)) {
+ if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) {
+ char *full_name;
- if (!method)
- method = mono_get_method (image, token, NULL);
- full_name = mono_method_full_name (method, TRUE);
- mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: NOT FOUND: %s.", full_name);
- g_free (full_name);
+ if (!method)
+ method = mono_get_method (image, token, NULL);
+ full_name = mono_method_full_name (method, TRUE);
+ mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: NOT FOUND: %s.", full_name);
+ g_free (full_name);
+ }
+ return NULL;
}
- return NULL;
}
- code = &amodule->code [amodule->code_offsets [method_index]];
+ code = amodule->methods [method_index];
info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
}
}
- res = mono_aot_init_method (amodule, method_index, method, &klass);
+ res = init_method (amodule, method_index, method, &klass);
if (!res)
goto cleanup;
}
static guint32
-find_aot_method_in_amodule (MonoAotModule *amodule, MonoMethod *method)
+find_aot_method_in_amodule (MonoAotModule *amodule, MonoMethod *method, guint32 hash_full)
{
guint32 table_size, entry_size, hash;
guint32 *table, *entry;
return 0xffffff;
table_size = amodule->extra_method_table [0];
+ hash = hash_full % table_size;
table = amodule->extra_method_table + 1;
entry_size = 3;
- hash = mono_aot_method_hash (method) % table_size;
-
entry = &table [hash * entry_size];
if (entry [0] == 0)
guint32 index;
GPtrArray *modules;
int i;
+ guint32 hash = mono_aot_method_hash (method);
/* Try the method's module first */
*out_amodule = method->klass->image->aot_module;
- index = find_aot_method_in_amodule (method->klass->image->aot_module, method);
+ index = find_aot_method_in_amodule (method->klass->image->aot_module, method, hash);
if (index != 0xffffff)
return index;
MonoAotModule *amodule = g_ptr_array_index (modules, i);
if (amodule != method->klass->image->aot_module)
- index = find_aot_method_in_amodule (amodule, method);
+ index = find_aot_method_in_amodule (amodule, method, hash);
if (index != 0xffffff) {
*out_amodule = amodule;
break;
}
static gboolean
-mono_aot_init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass **klass)
+init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass **klass)
{
MonoDomain *domain = mono_domain_get ();
MonoMemPool *mp;
MonoJitInfo *jinfo = NULL;
guint8 *code, *info;
- code = &amodule->code [amodule->code_offsets [method_index]];
+ code = amodule->methods [method_index];
info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
p = info;
/* Find method index */
method_index = 0xffffff;
- if (method->is_inflated && !method->wrapper_type && mono_method_is_generic_sharable_full (method, FALSE, FALSE, FALSE)) {
+ if (method->is_inflated && !method->wrapper_type && mono_method_is_generic_sharable_full (method, TRUE, FALSE, FALSE)) {
/*
* For generic methods, we store the fully shared instance in place of the
* original method.
* 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) {
+ if (ji.type == MONO_PATCH_INFO_ABS || ji.type == MONO_PATCH_INFO_INTERNAL_METHOD || 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 */
} 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 if (!strcmp (ji->data.name, "debugger_agent_single_step_from_context")) {
return load_function_full (amodule, name, NULL);
}
+static MonoAotModule*
+get_mscorlib_aot_module (void)
+{
+ MonoImage *image;
+ MonoAotModule *amodule;
+
+ image = mono_defaults.corlib;
+ if (image)
+ amodule = image->aot_module;
+ else
+ amodule = mscorlib_aot_module;
+ g_assert (amodule);
+ return amodule;
+}
+
/*
* Return the trampoline identified by NAME from the mscorlib AOT file.
* On ppc64, this returns a function descriptor.
gpointer
mono_aot_get_trampoline_full (const char *name, MonoTrampInfo **out_tinfo)
{
- MonoImage *image;
- MonoAotModule *amodule;
-
- image = mono_defaults.corlib;
- g_assert (image);
-
- amodule = image->aot_module;
- g_assert (amodule);
+ MonoAotModule *amodule = get_mscorlib_aot_module ();
return mono_create_ftnptr_malloc (load_function_full (amodule, name, out_tinfo));
}
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;
MonoImage *image;
+ MonoAotModule *amodule = get_mscorlib_aot_module ();
+ int index, tramp_size;
/* Currently, we keep all trampolines in the mscorlib AOT image */
image = mono_defaults.corlib;
- g_assert (image);
-
- mono_aot_lock ();
-
- amodule = image->aot_module;
- g_assert (amodule);
*out_amodule = amodule;
+ mono_aot_lock ();
+
#ifdef MONOTOUCH
#define MONOTOUCH_TRAMPOLINES_ERROR ". See http://docs.xamarin.com/ios/troubleshooting for instructions on how to fix this condition."
#else
#endif
if (amodule->trampoline_index [tramp_type] == amodule->info.num_trampolines [tramp_type]) {
g_error ("Ran out of trampolines of type %d in '%s' (%d)%s\n",
- tramp_type, image->name, amodule->info.num_trampolines [tramp_type], MONOTOUCH_TRAMPOLINES_ERROR);
+ tramp_type, image ? image->name : "mscorlib", amodule->info.num_trampolines [tramp_type], MONOTOUCH_TRAMPOLINES_ERROR);
}
index = amodule->trampoline_index [tramp_type] ++;
projects / mono.git / blobdiff