?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[arm] Fix branch island disassembly for arm64 and thumb. (#19189)
[mono-project.git] / mono / mini / aot-runtime.c
blob5e6fc01242837d0480813838f590c5415abf354f
1 /**
2 * \file
3 * mono Ahead of Time compiler
4 *
5 * Author:
6 * Dietmar Maurer (dietmar@ximian.com)
7 * Zoltan Varga (vargaz@gmail.com)
8 *
9 * (C) 2002 Ximian, Inc.
10 * Copyright 2003-2011 Novell, Inc.
11 * Copyright 2011 Xamarin, Inc.
12 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
13 */
14
15 #include "config.h"
16 #include <sys/types.h>
17 #ifdef HAVE_UNISTD_H
18 #include <unistd.h>
19 #endif
20 #include <fcntl.h>
21 #include <string.h>
22 #ifdef HAVE_SYS_MMAN_H
23 #include <sys/mman.h>
24 #endif
25
26 #if HOST_WIN32
27 #include <winsock2.h>
28 #include <windows.h>
29 #endif
30
31 #ifdef HAVE_EXECINFO_H
32 #include <execinfo.h>
33 #endif
34
35 #include <errno.h>
36 #include <sys/stat.h>
37
38 #ifdef HAVE_SYS_WAIT_H
39 #include <sys/wait.h> /* for WIFEXITED, WEXITSTATUS */
40 #endif
41
42 #include <mono/metadata/abi-details.h>
43 #include <mono/metadata/tabledefs.h>
44 #include <mono/metadata/class.h>
45 #include <mono/metadata/object.h>
46 #include <mono/metadata/tokentype.h>
47 #include <mono/metadata/appdomain.h>
48 #include <mono/metadata/debug-helpers.h>
49 #include <mono/metadata/assembly.h>
50 #include <mono/metadata/assembly-internals.h>
51 #include <mono/metadata/metadata-internals.h>
52 #include <mono/metadata/exception-internals.h>
53 #include <mono/metadata/marshal.h>
54 #include <mono/metadata/gc-internals.h>
55 #include <mono/metadata/threads-types.h>
56 #include <mono/metadata/mono-endian.h>
57 #include <mono/utils/mono-logger-internals.h>
58 #include <mono/utils/mono-mmap.h>
59 #include <mono/utils/mono-compiler.h>
60 #include <mono/utils/mono-counters.h>
61 #include <mono/utils/mono-digest.h>
62 #include <mono/utils/mono-threads-coop.h>
63 #include <mono/utils/bsearch.h>
64 #include <mono/utils/mono-tls-inline.h>
65
66 #include "mini.h"
67 #include "seq-points.h"
68 #include "version.h"
69 #include "debugger-agent.h"
70 #include "aot-compiler.h"
71 #include "aot-runtime.h"
72 #include "jit-icalls.h"
73 #include "mini-runtime.h"
74 #include "llvmonly-runtime.h"
75
76 #ifndef DISABLE_AOT
77
78 #ifdef TARGET_OSX
79 #define ENABLE_AOT_CACHE
80 #endif
81
82 #define ROUND_DOWN(VALUE,SIZE) ((VALUE) & ~((SIZE) - 1))
83
84 typedef struct {
85 int method_index;
86 MonoJitInfo *jinfo;
87 } JitInfoMap;
88
89 #define GOT_INITIALIZING 1
90 #define GOT_INITIALIZED 2
91
92 struct MonoAotModule {
93 char *aot_name;
94 /* Pointer to the Global Offset Table */
95 gpointer *got;
96 gpointer *llvm_got;
97 gpointer *shared_got;
98 GHashTable *name_cache;
99 GHashTable *extra_methods;
100 /* Maps methods to their code */
101 GHashTable *method_to_code;
102 /* Maps pointers into the method info to the methods themselves */
103 GHashTable *method_ref_to_method;
104 MonoAssemblyName *image_names;
105 char **image_guids;
106 MonoAssembly *assembly;
107 MonoImage **image_table;
108 guint32 image_table_len;
109 gboolean out_of_date;
110 gboolean plt_inited;
111 int got_initialized;
112 guint8 *mem_begin;
113 guint8 *mem_end;
114 guint8 *jit_code_start;
115 guint8 *jit_code_end;
116 guint8 *llvm_code_start;
117 guint8 *llvm_code_end;
118 guint8 *plt;
119 guint8 *plt_end;
120 guint8 *blob;
121 gpointer weak_field_indexes;
122 /* Maps method indexes to their code */
123 gpointer *methods;
124 /* Sorted array of method addresses */
125 gpointer *sorted_methods;
126 /* Method indexes for each method in sorted_methods */
127 int *sorted_method_indexes;
128 /* The length of the two tables above */
129 int sorted_methods_len;
130 guint32 *method_info_offsets;
131 guint32 *ex_info_offsets;
132 guint32 *class_info_offsets;
133 guint32 *got_info_offsets;
134 guint32 *llvm_got_info_offsets;
135 guint32 *methods_loaded;
136 guint16 *class_name_table;
137 guint32 *extra_method_table;
138 guint32 *extra_method_info_offsets;
139 guint32 *unbox_trampolines;
140 guint32 *unbox_trampolines_end;
141 guint32 *unbox_trampoline_addresses;
142 guint8 *unwind_info;
143
144 /* Points to the mono EH data created by LLVM */
145 guint8 *mono_eh_frame;
146
147 /* Points to the data tables if MONO_AOT_FILE_FLAG_SEPARATE_DATA is set */
148 gpointer tables [MONO_AOT_TABLE_NUM];
149 /* Points to the trampolines */
150 guint8 *trampolines [MONO_AOT_TRAMP_NUM];
151 /* The first unused trampoline of each kind */
152 guint32 trampoline_index [MONO_AOT_TRAMP_NUM];
153
154 gboolean use_page_trampolines;
155
156 MonoAotFileInfo info;
157
158 gpointer *globals;
159 MonoDl *sofile;
160
161 JitInfoMap *async_jit_info_table;
162 mono_mutex_t mutex;
163 };
164
165 typedef struct {
166 void *next;
167 unsigned char *trampolines;
168 unsigned char *trampolines_end;
169 } TrampolinePage;
170
171 static GHashTable *aot_modules;
172 #define mono_aot_lock() mono_os_mutex_lock (&aot_mutex)
173 #define mono_aot_unlock() mono_os_mutex_unlock (&aot_mutex)
174 static mono_mutex_t aot_mutex;
175
176 /*
177 * Maps assembly names to the mono_aot_module_<NAME>_info symbols in the
178 * AOT modules registered by mono_aot_register_module ().
179 */
180 static GHashTable *static_aot_modules;
181 /*
182 * Same as above, but tracks module that must be loaded before others are
183 * This allows us to have a "container" module which contains resources for
184 * other modules. Since it doesn't provide methods for a managed assembly,
185 * and it needs to be fully loaded by the time the other code needs it, it
186 * must be eagerly loaded before other modules.
187 */
188 static char *container_assm_name;
189 static MonoAotModule *container_amodule;
190
191 /*
192 * Maps MonoJitInfo* to the aot module they belong to, this can be different
193 * from ji->method->klass->image's aot module for generic instances.
194 */
195 static GHashTable *ji_to_amodule;
196
197 /* Maps method addresses to MonoAotMethodFlags */
198 static GHashTable *code_to_method_flags;
199
200 /*
201 * Whenever to AOT compile loaded assemblies on demand and store them in
202 * a cache.
203 */
204 static gboolean enable_aot_cache = FALSE;
205
206 static gboolean mscorlib_aot_loaded;
207
208 /* For debugging */
209 static gint32 mono_last_aot_method = -1;
210
211 static gboolean make_unreadable = FALSE;
212 static guint32 name_table_accesses = 0;
213 static guint32 n_pagefaults = 0;
214
215 /* Used to speed-up find_aot_module () */
216 static gsize aot_code_low_addr = (gssize)-1;
217 static gsize aot_code_high_addr = 0;
218
219 /* Stats */
220 static gint32 async_jit_info_size;
221
222 #ifdef MONOTOUCH
223 #define USE_PAGE_TRAMPOLINES (mscorlib_aot_module->use_page_trampolines)
224 #else
225 #define USE_PAGE_TRAMPOLINES 0
226 #endif
227
228 #define mono_aot_page_lock() mono_os_mutex_lock (&aot_page_mutex)
229 #define mono_aot_page_unlock() mono_os_mutex_unlock (&aot_page_mutex)
230 static mono_mutex_t aot_page_mutex;
231
232 static MonoAotModule *mscorlib_aot_module;
233
234 /* Embedding API hooks to load the AOT data for AOT images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */
235 static MonoLoadAotDataFunc aot_data_load_func;
236 static MonoFreeAotDataFunc aot_data_free_func;
237 static gpointer aot_data_func_user_data;
238
239 static void
240 init_plt (MonoAotModule *info);
241
242 static void
243 compute_llvm_code_range (MonoAotModule *amodule, guint8 **code_start, guint8 **code_end);
244
245 static gboolean
246 init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass *init_class, MonoError *error);
247
248 static MonoJumpInfo*
249 decode_patches (MonoAotModule *amodule, MonoMemPool *mp, int n_patches, gboolean llvm, guint32 *got_offsets);
250
251 static void
252 amodule_lock (MonoAotModule *amodule)
253 {
254 mono_os_mutex_lock (&amodule->mutex);
255 }
256
257 static void
258 amodule_unlock (MonoAotModule *amodule)
259 {
260 mono_os_mutex_unlock (&amodule->mutex);
261 }
262
263 /*
264 * load_image:
265 *
266 * Load one of the images referenced by AMODULE. Returns NULL if the image is not
267 * found, and sets @error for what happened
268 */
269 static MonoImage *
270 load_image (MonoAotModule *amodule, int index, MonoError *error)
271 {
272 MonoAssembly *assembly;
273 MonoImageOpenStatus status;
274 MonoAssemblyLoadContext *alc = mono_domain_ambient_alc (mono_domain_get ());
275
276 g_assert (index < amodule->image_table_len);
277
278 error_init (error);
279
280 if (amodule->image_table [index])
281 return amodule->image_table [index];
282 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: module %s wants to load image %d: %s", amodule->aot_name, index, amodule->image_names[index].name);
283 if (amodule->out_of_date) {
284 mono_error_set_bad_image_by_name (error, amodule->aot_name, "Image out of date");
285 return NULL;
286 }
287
288 /*
289 * LoadFile allows loading more than one assembly with the same name.
290 * That means that just calling mono_assembly_load is unlikely to find
291 * the correct assembly (it'll just return the first one loaded). But
292 * we shouldn't hardcode the full assembly filepath into the AOT image,
293 * so it's not obvious that we can call mono_assembly_open_predicate.
294 *
295 * In the JIT, an assembly opened with LoadFile is supposed to only
296 * refer to already-loaded assemblies (or to GAC & MONO_PATH)
297 * assemblies - so nothing new should be loading. And for the
298 * LoadFile'd assembly itself, we can check if the name and guid of the
299 * current AOT module matches the wanted name and guid and just return
300 * the AOT module's assembly.
301 */
302 if (!strcmp (amodule->assembly->image->guid, amodule->image_guids [index])) {
303 assembly = amodule->assembly;
304 } else if (mono_get_corlib () && !strcmp (mono_get_corlib ()->guid, amodule->image_guids [index])) {
305 /* This might be called before corlib is added to the root domain */
306 assembly = mono_get_corlib ()->assembly;
307 } else {
308 MonoAssemblyByNameRequest req;
309 mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, alc);
310 req.basedir = amodule->assembly->basedir;
311 assembly = mono_assembly_request_byname (&amodule->image_names [index], &req, &status);
312 }
313 if (!assembly) {
314 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: module %s is unusable because dependency %s is not found.", amodule->aot_name, amodule->image_names [index].name);
315 mono_error_set_bad_image_by_name (error, amodule->aot_name, "module is unusable because dependency %s is not found (error %d).\n", amodule->image_names [index].name, status);
316 amodule->out_of_date = TRUE;
317 return NULL;
318 }
319
320 if (strcmp (assembly->image->guid, amodule->image_guids [index])) {
321 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: module %s is unusable (GUID of dependent assembly %s doesn't match (expected '%s', got '%s')).", amodule->aot_name, amodule->image_names [index].name, amodule->image_guids [index], assembly->image->guid);
322 mono_error_set_bad_image_by_name (error, amodule->aot_name, "module is unusable (GUID of dependent assembly %s doesn't match (expected '%s', got '%s')).", amodule->image_names [index].name, amodule->image_guids [index], assembly->image->guid);
323 amodule->out_of_date = TRUE;
324 return NULL;
325 }
326
327 amodule->image_table [index] = assembly->image;
328 return assembly->image;
329 }
330
331 static gint32
332 decode_value (guint8 *ptr, guint8 **rptr)
333 {
334 guint8 b = *ptr;
335 gint32 len;
336
337 if ((b & 0x80) == 0){
338 len = b;
339 ++ptr;
340 } else if ((b & 0x40) == 0){
341 len = ((b & 0x3f) << 8 | ptr [1]);
342 ptr += 2;
343 } else if (b != 0xff) {
344 len = ((b & 0x1f) << 24) |
345 (ptr [1] << 16) |
346 (ptr [2] << 8) |
347 ptr [3];
348 ptr += 4;
349 }
350 else {
351 len = (ptr [1] << 24) | (ptr [2] << 16) | (ptr [3] << 8) | ptr [4];
352 ptr += 5;
353 }
354 if (rptr)
355 *rptr = ptr;
356
357 //printf ("DECODE: %d.\n", len);
358 return len;
359 }
360
361 /*
362 * mono_aot_get_offset:
363 *
364 * Decode an offset table emitted by emit_offset_table (), returning the INDEXth
365 * entry.
366 */
367 static guint32
368 mono_aot_get_offset (guint32 *table, int index)
369 {
370 int i, group, ngroups, index_entry_size;
371 int start_offset, offset, group_size;
372 guint8 *data_start, *p;
373 guint32 *index32 = NULL;
374 guint16 *index16 = NULL;
375
376 /* noffsets = table [0]; */
377 group_size = table [1];
378 ngroups = table [2];
379 index_entry_size = table [3];
380 group = index / group_size;
381
382 if (index_entry_size == 2) {
383 index16 = (guint16*)&table [4];
384 data_start = (guint8*)&index16 [ngroups];
385 p = data_start + index16 [group];
386 } else {
387 index32 = (guint32*)&table [4];
388 data_start = (guint8*)&index32 [ngroups];
389 p = data_start + index32 [group];
390 }
391
392 /* offset will contain the value of offsets [group * group_size] */
393 offset = start_offset = decode_value (p, &p);
394 for (i = group * group_size + 1; i <= index; ++i) {
395 offset += decode_value (p, &p);
396 }
397
398 //printf ("Offset lookup: %d -> %d, start=%d, p=%d\n", index, offset, start_offset, table [3 + group]);
399
400 return offset;
401 }
402
403 static MonoMethod*
404 decode_resolve_method_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error);
405
406 static MonoClass*
407 decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error);
408
409 static MonoType*
410 decode_type (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error);
411
412 static MonoGenericInst*
413 decode_generic_inst (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error)
414 {
415 int type_argc, i;
416 MonoType **type_argv;
417 MonoGenericInst *inst;
418 guint8 *p = buf;
419
420 error_init (error);
421 type_argc = decode_value (p, &p);
422 type_argv = g_new0 (MonoType*, type_argc);
423
424 for (i = 0; i < type_argc; ++i) {
425 MonoClass *pclass = decode_klass_ref (module, p, &p, error);
426 if (!pclass) {
427 g_free (type_argv);
428 return NULL;
429 }
430 type_argv [i] = m_class_get_byval_arg (pclass);
431 }
432
433 inst = mono_metadata_get_generic_inst (type_argc, type_argv);
434 g_free (type_argv);
435
436 *endbuf = p;
437
438 return inst;
439 }
440
441 static gboolean
442 decode_generic_context (MonoAotModule *amodule, MonoGenericContext *ctx, guint8 *buf, guint8 **endbuf, MonoError *error)
443 {
444 guint8 *p = buf;
445 guint8 *p2;
446 guint32 offset, flags;
447
448 /* Either the class_inst or method_inst offset */
449 flags = decode_value (p, &p);
450
451 if (flags & 1) {
452 offset = decode_value (p, &p);
453 p2 = amodule->blob + offset;
454 ctx->class_inst = decode_generic_inst (amodule, p2, &p2, error);
455 if (!ctx->class_inst)
456 return FALSE;
457 }
458 if (flags & 2) {
459 offset = decode_value (p, &p);
460 p2 = amodule->blob + offset;
461 ctx->method_inst = decode_generic_inst (amodule, p2, &p2, error);
462 if (!ctx->method_inst)
463 return FALSE;
464 }
465
466 *endbuf = p;
467 return TRUE;
468 }
469
470 static MonoClass*
471 decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error)
472 {
473 MonoImage *image;
474 MonoClass *klass = NULL, *eklass;
475 guint32 token, rank, idx;
476 guint8 *p = buf;
477 int reftype;
478
479 error_init (error);
480 reftype = decode_value (p, &p);
481 if (reftype == 0) {
482 *endbuf = p;
483 mono_error_set_bad_image_by_name (error, module->aot_name, "Decoding a null class ref");
484 return NULL;
485 }
486
487 switch (reftype) {
488 case MONO_AOT_TYPEREF_TYPEDEF_INDEX:
489 idx = decode_value (p, &p);
490 image = load_image (module, 0, error);
491 if (!image)
492 return NULL;
493 klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF + idx, error);
494 break;
495 case MONO_AOT_TYPEREF_TYPEDEF_INDEX_IMAGE:
496 idx = decode_value (p, &p);
497 image = load_image (module, decode_value (p, &p), error);
498 if (!image)
499 return NULL;
500 klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF + idx, error);
501 break;
502 case MONO_AOT_TYPEREF_TYPESPEC_TOKEN:
503 token = decode_value (p, &p);
504 image = module->assembly->image;
505 if (!image) {
506 mono_error_set_bad_image_by_name (error, module->aot_name, "No image associated with the aot module");
507 return NULL;
508 }
509 klass = mono_class_get_checked (image, token, error);
510 break;
511 case MONO_AOT_TYPEREF_GINST: {
512 MonoClass *gclass;
513 MonoGenericContext ctx;
514 MonoType *type;
515
516 gclass = decode_klass_ref (module, p, &p, error);
517 if (!gclass)
518 return NULL;
519 g_assert (mono_class_is_gtd (gclass));
520
521 memset (&ctx, 0, sizeof (ctx));
522 guint32 offset = decode_value (p, &p);
523 guint8 *p2 = module->blob + offset;
524 ctx.class_inst = decode_generic_inst (module, p2, &p2, error);
525 if (!ctx.class_inst)
526 return NULL;
527 type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (gclass), &ctx, error);
528 if (!type)
529 return NULL;
530 klass = mono_class_from_mono_type_internal (type);
531 mono_metadata_free_type (type);
532 break;
533 }
534 case MONO_AOT_TYPEREF_VAR: {
535 MonoType *t = NULL;
536 MonoGenericContainer *container = NULL;
537 gboolean has_constraint = decode_value (p, &p);
538
539 if (has_constraint) {
540 MonoClass *par_klass;
541 MonoType *gshared_constraint;
542
543 gshared_constraint = decode_type (module, p, &p, error);
544 if (!gshared_constraint)
545 return NULL;
546
547 par_klass = decode_klass_ref (module, p, &p, error);
548 if (!par_klass)
549 return NULL;
550
551 t = mini_get_shared_gparam (m_class_get_byval_arg (par_klass), gshared_constraint);
552 mono_metadata_free_type (gshared_constraint);
553 klass = mono_class_from_mono_type_internal (t);
554 } else {
555 int type = decode_value (p, &p);
556 int num = decode_value (p, &p);
557 gboolean is_not_anonymous = decode_value (p, &p);
558
559 if (is_not_anonymous) {
560 gboolean is_method = decode_value (p, &p);
561
562 if (is_method) {
563 MonoMethod *method_def;
564 g_assert (type == MONO_TYPE_MVAR);
565 method_def = decode_resolve_method_ref (module, p, &p, error);
566 if (!method_def)
567 return NULL;
568
569 container = mono_method_get_generic_container (method_def);
570 } else {
571 MonoClass *class_def;
572 g_assert (type == MONO_TYPE_VAR);
573 class_def = decode_klass_ref (module, p, &p, error);
574 if (!class_def)
575 return NULL;
576
577 container = mono_class_try_get_generic_container (class_def); //FIXME is this a case for a try_get?
578 }
579 } else {
580 // We didn't decode is_method, so we have to infer it from type enum.
581 container = mono_get_anonymous_container_for_image (module->assembly->image, type == MONO_TYPE_MVAR);
582 }
583
584 t = g_new0 (MonoType, 1);
585 t->type = (MonoTypeEnum)type;
586 if (is_not_anonymous) {
587 t->data.generic_param = mono_generic_container_get_param (container, num);
588 } else {
589 /* Anonymous */
590 MonoGenericParam *par = mono_metadata_create_anon_gparam (module->assembly->image, num, type == MONO_TYPE_MVAR);
591 t->data.generic_param = par;
592 // FIXME: maybe do this for all anon gparams?
593 ((MonoGenericParamFull*)par)->info.name = mono_make_generic_name_string (module->assembly->image, num);
594 }
595 // FIXME: Maybe use types directly to avoid
596 // the overhead of creating MonoClass-es
597 klass = mono_class_from_mono_type_internal (t);
598
599 g_free (t);
600 }
601 break;
602 }
603 case MONO_AOT_TYPEREF_ARRAY:
604 /* Array */
605 rank = decode_value (p, &p);
606 eklass = decode_klass_ref (module, p, &p, error);
607 if (!eklass)
608 return NULL;
609 klass = mono_class_create_array (eklass, rank);
610 break;
611 case MONO_AOT_TYPEREF_PTR: {
612 MonoType *t;
613
614 t = decode_type (module, p, &p, error);
615 if (!t)
616 return NULL;
617 klass = mono_class_from_mono_type_internal (t);
618 g_free (t);
619 break;
620 }
621 case MONO_AOT_TYPEREF_BLOB_INDEX: {
622 guint32 offset = decode_value (p, &p);
623 guint8 *p2;
624
625 p2 = module->blob + offset;
626 klass = decode_klass_ref (module, p2, &p2, error);
627 break;
628 }
629 default:
630 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid klass reftype %d", reftype);
631 }
632 //g_assert (klass);
633 //printf ("BLA: %s\n", mono_type_full_name (m_class_get_byval_arg (klass)));
634 *endbuf = p;
635 return klass;
636 }
637
638 static MonoClassField*
639 decode_field_info (MonoAotModule *module, guint8 *buf, guint8 **endbuf)
640 {
641 ERROR_DECL (error);
642 MonoClass *klass = decode_klass_ref (module, buf, &buf, error);
643 guint32 token;
644 guint8 *p = buf;
645
646 if (!klass) {
647 mono_error_cleanup (error); /* FIXME don't swallow the error */
648 return NULL;
649 }
650
651 token = MONO_TOKEN_FIELD_DEF + decode_value (p, &p);
652
653 *endbuf = p;
654
655 return mono_class_get_field (klass, token);
656 }
657
658 /*
659 * Parse a MonoType encoded by encode_type () in aot-compiler.c. Return malloc-ed
660 * memory.
661 */
662 static MonoType*
663 decode_type (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error)
664 {
665 guint8 *p = buf;
666 MonoType *t;
667
668 if (*p == MONO_TYPE_CMOD_REQD) {
669 ++p;
670
671 int count = decode_value (p, &p);
672
673 /* TODO: encode aggregate cmods differently than simple cmods and make it possible to use the more compact encoding here. */
674 t = (MonoType*)g_malloc0 (mono_sizeof_type_with_mods (count, TRUE));
675 mono_type_with_mods_init (t, count, TRUE);
676
677 /* Try not to blow up the stack. See comment on MONO_MAX_EXPECTED_CMODS */
678 g_assert (count < MONO_MAX_EXPECTED_CMODS);
679 MonoAggregateModContainer *cm = g_alloca (mono_sizeof_aggregate_modifiers (count));
680 cm->count = count;
681 for (int i = 0; i < count; ++i) {
682 MonoSingleCustomMod *cmod = &cm->modifiers [i];
683 cmod->required = decode_value (p, &p);
684 cmod->type = decode_type (module, p, &p, error);
685 goto_if_nok (error, fail);
686 }
687
688 mono_type_set_amods (t, mono_metadata_get_canonical_aggregate_modifiers (cm));
689 for (int i = 0; i < count; ++i)
690 mono_metadata_free_type (cm->modifiers [i].type);
691 } else {
692 t = (MonoType *) g_malloc0 (MONO_SIZEOF_TYPE);
693 }
694
695 while (TRUE) {
696 if (*p == MONO_TYPE_PINNED) {
697 t->pinned = TRUE;
698 ++p;
699 } else if (*p == MONO_TYPE_BYREF) {
700 t->byref = TRUE;
701 ++p;
702 } else {
703 break;
704 }
705 }
706
707 t->type = (MonoTypeEnum)*p;
708 ++p;
709
710 switch (t->type) {
711 case MONO_TYPE_VOID:
712 case MONO_TYPE_BOOLEAN:
713 case MONO_TYPE_CHAR:
714 case MONO_TYPE_I1:
715 case MONO_TYPE_U1:
716 case MONO_TYPE_I2:
717 case MONO_TYPE_U2:
718 case MONO_TYPE_I4:
719 case MONO_TYPE_U4:
720 case MONO_TYPE_I8:
721 case MONO_TYPE_U8:
722 case MONO_TYPE_R4:
723 case MONO_TYPE_R8:
724 case MONO_TYPE_I:
725 case MONO_TYPE_U:
726 case MONO_TYPE_STRING:
727 case MONO_TYPE_OBJECT:
728 case MONO_TYPE_TYPEDBYREF:
729 break;
730 case MONO_TYPE_VALUETYPE:
731 case MONO_TYPE_CLASS:
732 t->data.klass = decode_klass_ref (module, p, &p, error);
733 if (!t->data.klass)
734 goto fail;
735 break;
736 case MONO_TYPE_SZARRAY:
737 t->data.klass = decode_klass_ref (module, p, &p, error);
738
739 if (!t->data.klass)
740 goto fail;
741 break;
742 case MONO_TYPE_PTR:
743 t->data.type = decode_type (module, p, &p, error);
744 if (!t->data.type)
745 goto fail;
746 break;
747 case MONO_TYPE_GENERICINST: {
748 MonoClass *gclass;
749 MonoGenericContext ctx;
750 MonoType *type;
751 MonoClass *klass;
752
753 gclass = decode_klass_ref (module, p, &p, error);
754 if (!gclass)
755 goto fail;
756 g_assert (mono_class_is_gtd (gclass));
757
758 memset (&ctx, 0, sizeof (ctx));
759 ctx.class_inst = decode_generic_inst (module, p, &p, error);
760 if (!ctx.class_inst)
761 goto fail;
762 type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (gclass), &ctx, error);
763 if (!type)
764 goto fail;
765 klass = mono_class_from_mono_type_internal (type);
766 t->data.generic_class = mono_class_get_generic_class (klass);
767 break;
768 }
769 case MONO_TYPE_ARRAY: {
770 MonoArrayType *array;
771 int i;
772
773 // FIXME: memory management
774 array = g_new0 (MonoArrayType, 1);
775 array->eklass = decode_klass_ref (module, p, &p, error);
776 if (!array->eklass)
777 goto fail;
778 array->rank = decode_value (p, &p);
779 array->numsizes = decode_value (p, &p);
780
781 if (array->numsizes)
782 array->sizes = (int *)g_malloc0 (sizeof (int) * array->numsizes);
783 for (i = 0; i < array->numsizes; ++i)
784 array->sizes [i] = decode_value (p, &p);
785
786 array->numlobounds = decode_value (p, &p);
787 if (array->numlobounds)
788 array->lobounds = (int *)g_malloc0 (sizeof (int) * array->numlobounds);
789 for (i = 0; i < array->numlobounds; ++i)
790 array->lobounds [i] = decode_value (p, &p);
791 t->data.array = array;
792 break;
793 }
794 case MONO_TYPE_VAR:
795 case MONO_TYPE_MVAR: {
796 MonoClass *klass = decode_klass_ref (module, p, &p, error);
797 if (!klass)
798 goto fail;
799 t->data.generic_param = m_class_get_byval_arg (klass)->data.generic_param;
800 break;
801 }
802 default:
803 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid encoded type %d", t->type);
804 goto fail;
805 }
806
807 *endbuf = p;
808
809 return t;
810 fail:
811 g_free (t);
812 return NULL;
813 }
814
815 // FIXME: Error handling, memory management
816
817 static MonoMethodSignature*
818 decode_signature_with_target (MonoAotModule *module, MonoMethodSignature *target, guint8 *buf, guint8 **endbuf)
819 {
820 ERROR_DECL (error);
821 MonoMethodSignature *sig;
822 guint32 flags;
823 int i, gen_param_count = 0, param_count, call_conv;
824 guint8 *p = buf;
825 gboolean hasthis, explicit_this, has_gen_params;
826
827 flags = *p;
828 p ++;
829 has_gen_params = (flags & 0x10) != 0;
830 hasthis = (flags & 0x20) != 0;
831 explicit_this = (flags & 0x40) != 0;
832 call_conv = flags & 0x0F;
833
834 if (has_gen_params)
835 gen_param_count = decode_value (p, &p);
836 param_count = decode_value (p, &p);
837 if (target && param_count != target->param_count)
838 return NULL;
839 sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + param_count * sizeof (MonoType *));
840 sig->param_count = param_count;
841 sig->sentinelpos = -1;
842 sig->hasthis = hasthis;
843 sig->explicit_this = explicit_this;
844 sig->call_convention = call_conv;
845 sig->generic_param_count = gen_param_count;
846 sig->ret = decode_type (module, p, &p, error);
847 if (!sig->ret)
848 goto fail;
849 for (i = 0; i < param_count; ++i) {
850 if (*p == MONO_TYPE_SENTINEL) {
851 g_assert (sig->call_convention == MONO_CALL_VARARG);
852 sig->sentinelpos = i;
853 p ++;
854 }
855 sig->params [i] = decode_type (module, p, &p, error);
856 if (!sig->params [i])
857 goto fail;
858 }
859
860 if (sig->call_convention == MONO_CALL_VARARG && sig->sentinelpos == -1)
861 sig->sentinelpos = sig->param_count;
862
863 *endbuf = p;
864
865 return sig;
866 fail:
867 mono_error_cleanup (error); /* FIXME don't swallow the error */
868 g_free (sig);
869 return NULL;
870 }
871
872 static MonoMethodSignature*
873 decode_signature (MonoAotModule *module, guint8 *buf, guint8 **endbuf)
874 {
875 return decode_signature_with_target (module, NULL, buf, endbuf);
876 }
877
878 static gboolean
879 sig_matches_target (MonoAotModule *module, MonoMethod *target, guint8 *buf, guint8 **endbuf)
880 {
881 MonoMethodSignature *sig;
882 gboolean res;
883 guint8 *p = buf;
884
885 sig = decode_signature_with_target (module, mono_method_signature_internal (target), p, &p);
886 res = sig && mono_metadata_signature_equal (mono_method_signature_internal (target), sig);
887 g_free (sig);
888 *endbuf = p;
889 return res;
890 }
891
892 /* Stores information returned by decode_method_ref () */
893 typedef struct {
894 MonoImage *image;
895 guint32 token;
896 MonoMethod *method;
897 gboolean no_aot_trampoline;
898 } MethodRef;
899
900 /*
901 * decode_method_ref_with_target:
902 *
903 * Decode a method reference, storing the image/token into a MethodRef structure.
904 * This avoids loading metadata for the method if the caller does not need it. If the method has
905 * no token, then it is loaded from metadata and ref->method is set to the method instance.
906 * If TARGET is non-NULL, abort decoding if it can be determined that the decoded method
907 * couldn't resolve to TARGET, and return FALSE.
908 * There are some kinds of method references which only support a non-null TARGET.
909 * This means that its not possible to decode this into a method, only to check
910 * that the method reference matches a given method. This is normally not a problem
911 * as these wrappers only occur in the extra_methods table, where we already have
912 * a method we want to lookup.
913 *
914 * If there was a decoding error, we return FALSE and set @error
915 */
916 static gboolean
917 decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod *target, guint8 *buf, guint8 **endbuf, MonoError *error)
918 {
919 guint32 image_index, value;
920 MonoImage *image = NULL;
921 guint8 *p = buf;
922
923 memset (ref, 0, sizeof (MethodRef));
924 error_init (error);
925
926 value = decode_value (p, &p);
927 image_index = value >> 24;
928
929 if (image_index == MONO_AOT_METHODREF_NO_AOT_TRAMPOLINE) {
930 ref->no_aot_trampoline = TRUE;
931 value = decode_value (p, &p);
932 image_index = value >> 24;
933 }
934
935 if (image_index < MONO_AOT_METHODREF_MIN || image_index == MONO_AOT_METHODREF_METHODSPEC ||
936 image_index == MONO_AOT_METHODREF_GINST || image_index == MONO_AOT_METHODREF_BLOB_INDEX) {
937 if (target && target->wrapper_type) {
938 return FALSE;
939 }
940 }
941
942 if (image_index == MONO_AOT_METHODREF_WRAPPER) {
943 WrapperInfo *info;
944 guint32 wrapper_type;
945
946 wrapper_type = decode_value (p, &p);
947
948 if (target && target->wrapper_type != wrapper_type)
949 return FALSE;
950
951 /* Doesn't matter */
952 image = mono_defaults.corlib;
953
954 switch (wrapper_type) {
955 #ifndef DISABLE_REMOTING
956 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK: {
957 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
958 if (!m)
959 return FALSE;
960 mono_class_init_internal (m->klass);
961 if (mono_aot_only)
962 ref->method = m;
963 else {
964 ref->method = mono_marshal_get_remoting_invoke_with_check (m, error);
965 return_val_if_nok (error, FALSE);
966 }
967 break;
968 }
969 case MONO_WRAPPER_PROXY_ISINST: {
970 MonoClass *klass = decode_klass_ref (module, p, &p, error);
971 if (!klass)
972 return FALSE;
973 ref->method = mono_marshal_get_proxy_cancast (klass);
974 break;
975 }
976 case MONO_WRAPPER_LDFLD:
977 case MONO_WRAPPER_LDFLDA:
978 case MONO_WRAPPER_STFLD: {
979 MonoClass *klass = decode_klass_ref (module, p, &p, error);
980 if (!klass)
981 return FALSE;
982 MonoType *type = m_class_get_byval_arg (klass);
983 if (wrapper_type == MONO_WRAPPER_LDFLD)
984 ref->method = mono_marshal_get_ldfld_wrapper (type);
985 else if (wrapper_type == MONO_WRAPPER_LDFLDA)
986 ref->method = mono_marshal_get_ldflda_wrapper (type);
987 else if (wrapper_type == MONO_WRAPPER_STFLD)
988 ref->method = mono_marshal_get_stfld_wrapper (type);
989 else {
990 mono_error_set_bad_image_by_name (error, module->aot_name, "Unknown AOT wrapper type %d", wrapper_type);
991 return FALSE;
992 }
993 break;
994 }
995 #endif
996 case MONO_WRAPPER_ALLOC: {
997 int atype = decode_value (p, &p);
998 ManagedAllocatorVariant variant =
999 mono_profiler_allocations_enabled () ?
1000 MANAGED_ALLOCATOR_PROFILER : MANAGED_ALLOCATOR_REGULAR;
1001
1002 ref->method = mono_gc_get_managed_allocator_by_type (atype, variant);
1003 /* Try to fallback to the slow path version */
1004 if (!ref->method)
1005 ref->method = mono_gc_get_managed_allocator_by_type (atype, MANAGED_ALLOCATOR_SLOW_PATH);
1006 if (!ref->method) {
1007 mono_error_set_bad_image_by_name (error, module->aot_name, "Error: No managed allocator, but we need one for AOT.\nAre you using non-standard GC options?\n");
1008 return FALSE;
1009 }
1010 break;
1011 }
1012 case MONO_WRAPPER_WRITE_BARRIER: {
1013 ref->method = mono_gc_get_write_barrier ();
1014 break;
1015 }
1016 case MONO_WRAPPER_STELEMREF: {
1017 int subtype = decode_value (p, &p);
1018
1019 if (subtype == WRAPPER_SUBTYPE_NONE) {
1020 ref->method = mono_marshal_get_stelemref ();
1021 } else if (subtype == WRAPPER_SUBTYPE_VIRTUAL_STELEMREF) {
1022 int kind;
1023
1024 kind = decode_value (p, &p);
1025
1026 /* Can't decode this */
1027 if (!target)
1028 return FALSE;
1029 if (target->wrapper_type == MONO_WRAPPER_STELEMREF) {
1030 info = mono_marshal_get_wrapper_info (target);
1031
1032 g_assert (info);
1033 if (info->subtype == subtype && info->d.virtual_stelemref.kind == kind)
1034 ref->method = target;
1035 else
1036 return FALSE;
1037 } else {
1038 return FALSE;
1039 }
1040 } else {
1041 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid STELEMREF subtype %d", subtype);
1042 return FALSE;
1043 }
1044 break;
1045 }
1046 case MONO_WRAPPER_SYNCHRONIZED: {
1047 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
1048 if (!m)
1049 return FALSE;
1050 ref->method = mono_marshal_get_synchronized_wrapper (m);
1051 break;
1052 }
1053 case MONO_WRAPPER_OTHER: {
1054 int subtype = decode_value (p, &p);
1055
1056 if (subtype == WRAPPER_SUBTYPE_PTR_TO_STRUCTURE || subtype == WRAPPER_SUBTYPE_STRUCTURE_TO_PTR) {
1057 MonoClass *klass = decode_klass_ref (module, p, &p, error);
1058 if (!klass)
1059 return FALSE;
1060
1061 if (!target)
1062 return FALSE;
1063 if (klass != target->klass)
1064 return FALSE;
1065
1066 if (subtype == WRAPPER_SUBTYPE_PTR_TO_STRUCTURE) {
1067 if (strcmp (target->name, "PtrToStructure"))
1068 return FALSE;
1069 ref->method = mono_marshal_get_ptr_to_struct (klass);
1070 } else {
1071 if (strcmp (target->name, "StructureToPtr"))
1072 return FALSE;
1073 ref->method = mono_marshal_get_struct_to_ptr (klass);
1074 }
1075 } else if (subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER) {
1076 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
1077 if (!m)
1078 return FALSE;
1079 ref->method = mono_marshal_get_synchronized_inner_wrapper (m);
1080 } else if (subtype == WRAPPER_SUBTYPE_ARRAY_ACCESSOR) {
1081 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
1082 if (!m)
1083 return FALSE;
1084 ref->method = mono_marshal_get_array_accessor_wrapper (m);
1085 } else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN) {
1086 ref->method = mono_marshal_get_gsharedvt_in_wrapper ();
1087 } else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT) {
1088 ref->method = mono_marshal_get_gsharedvt_out_wrapper ();
1089 } else if (subtype == WRAPPER_SUBTYPE_INTERP_IN) {
1090 MonoMethodSignature *sig = decode_signature (module, p, &p);
1091 if (!sig)
1092 return FALSE;
1093 ref->method = mini_get_interp_in_wrapper (sig);
1094 g_free (sig);
1095 } else if (subtype == WRAPPER_SUBTYPE_INTERP_LMF) {
1096 MonoJitICallInfo *info = mono_find_jit_icall_info ((MonoJitICallId)decode_value (p, &p));
1097 ref->method = mini_get_interp_lmf_wrapper (info->name, (gpointer) info->func);
1098 } else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG) {
1099 MonoMethodSignature *sig = decode_signature (module, p, &p);
1100 if (!sig)
1101 return FALSE;
1102 ref->method = mini_get_gsharedvt_in_sig_wrapper (sig);
1103 g_free (sig);
1104 } else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG) {
1105 MonoMethodSignature *sig = decode_signature (module, p, &p);
1106 if (!sig)
1107 return FALSE;
1108 ref->method = mini_get_gsharedvt_out_sig_wrapper (sig);
1109 g_free (sig);
1110 } else if (subtype == WRAPPER_SUBTYPE_AOT_INIT) {
1111 guint32 init_type = decode_value (p, &p);
1112 ref->method = mono_marshal_get_aot_init_wrapper ((MonoAotInitSubtype) init_type);
1113 } else if (subtype == WRAPPER_SUBTYPE_LLVM_FUNC) {
1114 guint32 init_type = decode_value (p, &p);
1115 ref->method = mono_marshal_get_llvm_func_wrapper ((MonoLLVMFuncWrapperSubtype) init_type);
1116 } else {
1117 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid UNKNOWN wrapper subtype %d", subtype);
1118 return FALSE;
1119 }
1120 break;
1121 }
1122 case MONO_WRAPPER_MANAGED_TO_MANAGED: {
1123 int subtype = decode_value (p, &p);
1124
1125 if (subtype == WRAPPER_SUBTYPE_ELEMENT_ADDR) {
1126 int rank = decode_value (p, &p);
1127 int elem_size = decode_value (p, &p);
1128
1129 ref->method = mono_marshal_get_array_address (rank, elem_size);
1130 } else if (subtype == WRAPPER_SUBTYPE_STRING_CTOR) {
1131 MonoMethod *m;
1132
1133 m = decode_resolve_method_ref (module, p, &p, error);
1134 if (!m)
1135 return FALSE;
1136
1137 if (!target)
1138 return FALSE;
1139 g_assert (target->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED);
1140
1141 info = mono_marshal_get_wrapper_info (target);
1142 if (info && info->subtype == subtype && info->d.string_ctor.method == m)
1143 ref->method = target;
1144 else
1145 return FALSE;
1146 }
1147 break;
1148 }
1149 case MONO_WRAPPER_MANAGED_TO_NATIVE: {
1150 MonoMethod *m;
1151 int subtype = decode_value (p, &p);
1152
1153 if (subtype == WRAPPER_SUBTYPE_ICALL_WRAPPER) {
1154 MonoJitICallInfo *info = mono_find_jit_icall_info ((MonoJitICallId)decode_value (p, &p));
1155 ref->method = mono_icall_get_wrapper_method (info);
1156 } else {
1157 m = decode_resolve_method_ref (module, p, &p, error);
1158 if (!m)
1159 return FALSE;
1160
1161 /* This should only happen when looking for an extra method */
1162 if (!target)
1163 return FALSE;
1164 if (mono_marshal_method_from_wrapper (target) == m)
1165 ref->method = target;
1166 else
1167 return FALSE;
1168 }
1169 break;
1170 }
1171 case MONO_WRAPPER_CASTCLASS: {
1172 int subtype = decode_value (p, &p);
1173
1174 if (subtype == WRAPPER_SUBTYPE_CASTCLASS_WITH_CACHE)
1175 ref->method = mono_marshal_get_castclass_with_cache ();
1176 else if (subtype == WRAPPER_SUBTYPE_ISINST_WITH_CACHE)
1177 ref->method = mono_marshal_get_isinst_with_cache ();
1178 else {
1179 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid CASTCLASS wrapper subtype %d", subtype);
1180 return FALSE;
1181 }
1182 break;
1183 }
1184 case MONO_WRAPPER_RUNTIME_INVOKE: {
1185 int subtype = decode_value (p, &p);
1186
1187 if (!target)
1188 return FALSE;
1189
1190 if (subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_DYNAMIC) {
1191 if (strcmp (target->name, "runtime_invoke_dynamic") != 0)
1192 return FALSE;
1193 ref->method = target;
1194 } else if (subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT) {
1195 /* Direct wrapper */
1196 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
1197 if (!m)
1198 return FALSE;
1199 ref->method = mono_marshal_get_runtime_invoke (m, FALSE);
1200 } else if (subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL) {
1201 /* Virtual direct wrapper */
1202 MonoMethod *m = decode_resolve_method_ref (module, p, &p, error);
1203 if (!m)
1204 return FALSE;
1205 ref->method = mono_marshal_get_runtime_invoke (m, TRUE);
1206 } else {
1207 MonoMethodSignature *sig;
1208
1209 sig = decode_signature_with_target (module, NULL, p, &p);
1210 info = mono_marshal_get_wrapper_info (target);
1211 g_assert (info);
1212
1213 if (info->subtype != subtype) {
1214 g_free (sig);
1215 return FALSE;
1216 }
1217 g_assert (info->d.runtime_invoke.sig);
1218 const gboolean same_sig = mono_metadata_signature_equal (sig, info->d.runtime_invoke.sig);
1219 g_free (sig);
1220 if (same_sig)
1221 ref->method = target;
1222 else
1223 return FALSE;
1224 }
1225 break;
1226 }
1227 case MONO_WRAPPER_DELEGATE_INVOKE:
1228 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
1229 case MONO_WRAPPER_DELEGATE_END_INVOKE: {
1230 gboolean is_inflated = decode_value (p, &p);
1231 WrapperSubtype subtype;
1232
1233 if (is_inflated) {
1234 MonoClass *klass;
1235 MonoMethod *invoke, *wrapper;
1236
1237 klass = decode_klass_ref (module, p, &p, error);
1238 if (!klass)
1239 return FALSE;
1240
1241 switch (wrapper_type) {
1242 case MONO_WRAPPER_DELEGATE_INVOKE:
1243 invoke = mono_get_delegate_invoke_internal (klass);
1244 wrapper = mono_marshal_get_delegate_invoke (invoke, NULL);
1245 break;
1246 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
1247 invoke = mono_get_delegate_begin_invoke_internal (klass);
1248 wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
1249 break;
1250 case MONO_WRAPPER_DELEGATE_END_INVOKE:
1251 invoke = mono_get_delegate_end_invoke_internal (klass);
1252 wrapper = mono_marshal_get_delegate_end_invoke (invoke);
1253 break;
1254 default:
1255 g_assert_not_reached ();
1256 break;
1257 }
1258 if (target) {
1259 /*
1260 * Due to the way mini_get_shared_method_full () works, we could end up with
1261 * multiple copies of the same wrapper.
1262 */
1263 if (wrapper->klass != target->klass)
1264 return FALSE;
1265 ref->method = target;
1266 } else {
1267 ref->method = wrapper;
1268 }
1269 } else {
1270 /*
1271 * These wrappers are associated with a signature, not with a method.
1272 * Since we can't decode them into methods, they need a target method.
1273 */
1274 if (!target)
1275 return FALSE;
1276
1277 if (wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE) {
1278 subtype = (WrapperSubtype)decode_value (p, &p);
1279 info = mono_marshal_get_wrapper_info (target);
1280 if (info) {
1281 if (info->subtype != subtype)
1282 return FALSE;
1283 } else {
1284 if (subtype != WRAPPER_SUBTYPE_NONE)
1285 return FALSE;
1286 }
1287 }
1288 if (sig_matches_target (module, target, p, &p))
1289 ref->method = target;
1290 else
1291 return FALSE;
1292 }
1293 break;
1294 }
1295 case MONO_WRAPPER_NATIVE_TO_MANAGED: {
1296 MonoMethod *m;
1297 MonoClass *klass;
1298
1299 m = decode_resolve_method_ref (module, p, &p, error);
1300 if (!m)
1301 return FALSE;
1302 klass = decode_klass_ref (module, p, &p, error);
1303 if (!klass)
1304 return FALSE;
1305 ref->method = mono_marshal_get_managed_wrapper (m, klass, 0, error);
1306 if (!is_ok (error))
1307 return FALSE;
1308 break;
1309 }
1310 default:
1311 g_assert_not_reached ();
1312 }
1313 } else if (image_index == MONO_AOT_METHODREF_METHODSPEC) {
1314 image_index = decode_value (p, &p);
1315 ref->token = decode_value (p, &p);
1316
1317 image = load_image (module, image_index, error);
1318 if (!image)
1319 return FALSE;
1320 } else if (image_index == MONO_AOT_METHODREF_BLOB_INDEX) {
1321 guint32 offset = decode_value (p, &p);
1322
1323 guint8 *p2;
1324
1325 p2 = module->blob + offset;
1326 if (!decode_method_ref_with_target (module, ref, target, p2, &p2, error))
1327 return FALSE;
1328 image = ref->image;
1329 if (!image)
1330 return FALSE;
1331 } else if (image_index == MONO_AOT_METHODREF_GINST) {
1332 MonoClass *klass;
1333 MonoGenericContext ctx;
1334 guint32 token_index;
1335
1336 /*
1337 * These methods do not have a token which resolves them, so we
1338 * resolve them immediately.
1339 */
1340 klass = decode_klass_ref (module, p, &p, error);
1341 if (!klass)
1342 return FALSE;
1343
1344 if (target && target->klass != klass)
1345 return FALSE;
1346
1347 image_index = decode_value (p, &p);
1348 token_index = decode_value (p, &p);
1349 ref->token = mono_metadata_make_token (MONO_TABLE_METHOD, token_index);
1350
1351 image = load_image (module, image_index, error);
1352 if (!image)
1353 return FALSE;
1354
1355 ref->method = mono_get_method_checked (image, ref->token, NULL, NULL, error);
1356 if (!ref->method)
1357 return FALSE;
1358
1359 memset (&ctx, 0, sizeof (ctx));
1360
1361 if (FALSE && mono_class_is_ginst (klass)) {
1362 ctx.class_inst = mono_class_get_generic_class (klass)->context.class_inst;
1363 ctx.method_inst = NULL;
1364
1365 ref->method = mono_class_inflate_generic_method_full_checked (ref->method, klass, &ctx, error);
1366 if (!ref->method)
1367 return FALSE;
1368 }
1369
1370 memset (&ctx, 0, sizeof (ctx));
1371
1372 if (!decode_generic_context (module, &ctx, p, &p, error))
1373 return FALSE;
1374
1375 ref->method = mono_class_inflate_generic_method_full_checked (ref->method, klass, &ctx, error);
1376 if (!ref->method)
1377 return FALSE;
1378
1379 } else if (image_index == MONO_AOT_METHODREF_ARRAY) {
1380 MonoClass *klass;
1381 int method_type;
1382
1383 klass = decode_klass_ref (module, p, &p, error);
1384 if (!klass)
1385 return FALSE;
1386 method_type = decode_value (p, &p);
1387 switch (method_type) {
1388 case 0:
1389 ref->method = mono_class_get_method_from_name_checked (klass, ".ctor", m_class_get_rank (klass), 0, error);
1390 return_val_if_nok (error, FALSE);
1391 break;
1392 case 1:
1393 ref->method = mono_class_get_method_from_name_checked (klass, ".ctor", m_class_get_rank (klass) * 2, 0, error);
1394 return_val_if_nok (error, FALSE);
1395 break;
1396 case 2:
1397 ref->method = mono_class_get_method_from_name_checked (klass, "Get", -1, 0, error);
1398 return_val_if_nok (error, FALSE);
1399 break;
1400 case 3:
1401 ref->method = mono_class_get_method_from_name_checked (klass, "Address", -1, 0, error);
1402 return_val_if_nok (error, FALSE);
1403 break;
1404 case 4:
1405 ref->method = mono_class_get_method_from_name_checked (klass, "Set", -1, 0, error);
1406 return_val_if_nok (error, FALSE);
1407 break;
1408 default:
1409 mono_error_set_bad_image_by_name (error, module->aot_name, "Invalid METHODREF_ARRAY method type %d", method_type);
1410 return FALSE;
1411 }
1412 } else {
1413 if (image_index == MONO_AOT_METHODREF_LARGE_IMAGE_INDEX) {
1414 image_index = decode_value (p, &p);
1415 value = decode_value (p, &p);
1416 }
1417
1418 ref->token = MONO_TOKEN_METHOD_DEF | (value & 0xffffff);
1419
1420 image = load_image (module, image_index, error);
1421 if (!image)
1422 return FALSE;
1423 }
1424
1425 *endbuf = p;
1426
1427 ref->image = image;
1428
1429 return TRUE;
1430 }
1431
1432 static gboolean
1433 decode_method_ref (MonoAotModule *module, MethodRef *ref, guint8 *buf, guint8 **endbuf, MonoError *error)
1434 {
1435 return decode_method_ref_with_target (module, ref, NULL, buf, endbuf, error);
1436 }
1437
1438 /*
1439 * decode_resolve_method_ref_with_target:
1440 *
1441 * Similar to decode_method_ref, but resolve and return the method itself.
1442 */
1443 static MonoMethod*
1444 decode_resolve_method_ref_with_target (MonoAotModule *module, MonoMethod *target, guint8 *buf, guint8 **endbuf, MonoError *error)
1445 {
1446 MethodRef ref;
1447
1448 error_init (error);
1449
1450 if (!decode_method_ref_with_target (module, &ref, target, buf, endbuf, error))
1451 return NULL;
1452 if (ref.method)
1453 return ref.method;
1454 if (!ref.image) {
1455 mono_error_set_bad_image_by_name (error, module->aot_name, "No image found for methodref with target");
1456 return NULL;
1457 }
1458 return mono_get_method_checked (ref.image, ref.token, NULL, NULL, error);
1459 }
1460
1461 static MonoMethod*
1462 decode_resolve_method_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *error)
1463 {
1464 return decode_resolve_method_ref_with_target (module, NULL, buf, endbuf, error);
1465 }
1466
1467 #ifdef ENABLE_AOT_CACHE
1468
1469 /* AOT CACHE */
1470
1471 /*
1472 * FIXME:
1473 * - Add options for controlling the cache size
1474 * - Handle full cache by deleting old assemblies lru style
1475 * - Maybe add a threshold after an assembly is AOT compiled
1476 * - Add options for enabling this for specific main assemblies
1477 */
1478
1479 /* The cache directory */
1480 static char *cache_dir;
1481
1482 /* The number of assemblies AOTed in this run */
1483 static int cache_count;
1484
1485 /* Whenever to AOT in-process */
1486 static gboolean in_process;
1487
1488 static void
1489 collect_assemblies (gpointer data, gpointer user_data)
1490 {
1491 MonoAssembly *ass = (MonoAssembly*)data;
1492 GSList **l = (GSList**)user_data;
1493
1494 *l = g_slist_prepend (*l, ass);
1495 }
1496
1497 #define SHA1_DIGEST_LENGTH 20
1498
1499 /*
1500 * get_aot_config_hash:
1501 *
1502 * Return a hash for all the version information an AOT module depends on.
1503 */
1504 static G_GNUC_UNUSED char*
1505 get_aot_config_hash (MonoAssembly *assembly)
1506 {
1507 char *build_info;
1508 GSList *l, *assembly_list = NULL;
1509 GString *s;
1510 int i;
1511 guint8 digest [SHA1_DIGEST_LENGTH];
1512 char *digest_str;
1513
1514 build_info = mono_get_runtime_build_info ();
1515
1516 s = g_string_new (build_info);
1517
1518 mono_assembly_foreach (collect_assemblies, &assembly_list);
1519
1520 /*
1521 * The assembly list includes the current assembly as well, no need
1522 * to add it.
1523 */
1524 for (l = assembly_list; l; l = l->next) {
1525 MonoAssembly *ass = (MonoAssembly*)l->data;
1526
1527 g_string_append (s, "_");
1528 g_string_append (s, ass->aname.name);
1529 g_string_append (s, "_");
1530 g_string_append (s, ass->image->guid);
1531 }
1532
1533 for (i = 0; i < s->len; ++i) {
1534 if (!isalnum (s->str [i]) && s->str [i] != '-')
1535 s->str [i] = '_';
1536 }
1537
1538 mono_sha1_get_digest ((guint8*)s->str, s->len, digest);
1539
1540 digest_str = g_malloc0 ((SHA1_DIGEST_LENGTH * 2) + 1);
1541 for (i = 0; i < SHA1_DIGEST_LENGTH; ++i)
1542 sprintf (digest_str + (i * 2), "%02x", digest [i]);
1543
1544 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: file dependencies: %s, hash %s", s->str, digest_str);
1545
1546 g_string_free (s, TRUE);
1547
1548 return digest_str;
1549 }
1550
1551 static void
1552 aot_cache_init (void)
1553 {
1554 if (mono_aot_only)
1555 return;
1556 enable_aot_cache = TRUE;
1557 in_process = TRUE;
1558 }
1559
1560 /*
1561 * aot_cache_load_module:
1562 *
1563 * Load the AOT image corresponding to ASSEMBLY from the aot cache, AOTing it if neccessary.
1564 */
1565 static MonoDl*
1566 aot_cache_load_module (MonoAssembly *assembly, char **aot_name)
1567 {
1568 MonoAotCacheConfig *config;
1569 GSList *l;
1570 char *fname, *tmp2, *aot_options, *failure_fname;
1571 const char *home;
1572 MonoDl *module;
1573 gboolean res;
1574 gint exit_status;
1575 char *hash;
1576 int pid;
1577 gboolean enabled;
1578 FILE *failure_file;
1579
1580 *aot_name = NULL;
1581
1582 if (image_is_dynamic (assembly->image))
1583 return NULL;
1584
1585 /* Check in the list of assemblies enabled for aot caching */
1586 config = mono_get_aot_cache_config ();
1587
1588 enabled = FALSE;
1589 if (config->apps) {
1590 MonoDomain *domain = mono_domain_get ();
1591 MonoAssembly *entry_assembly = domain->entry_assembly;
1592
1593 // FIXME: This cannot be used for mscorlib during startup, since entry_assembly is not set yet
1594 for (l = config->apps; l; l = l->next) {
1595 char *n = (char*)l->data;
1596
1597 if ((entry_assembly && !strcmp (entry_assembly->aname.name, n)) || (!entry_assembly && !strcmp (assembly->aname.name, n)))
1598 break;
1599 }
1600 if (l)
1601 enabled = TRUE;
1602 }
1603
1604 if (!enabled) {
1605 for (l = config->assemblies; l; l = l->next) {
1606 char *n = (char*)l->data;
1607
1608 if (!strcmp (assembly->aname.name, n))
1609 break;
1610 }
1611 if (l)
1612 enabled = TRUE;
1613 }
1614 if (!enabled)
1615 return NULL;
1616
1617 if (!cache_dir) {
1618 home = g_get_home_dir ();
1619 if (!home)
1620 return NULL;
1621 cache_dir = g_strdup_printf ("%s/Library/Caches/mono/aot-cache", home);
1622 if (!g_file_test (cache_dir, (GFileTest)(G_FILE_TEST_EXISTS|G_FILE_TEST_IS_DIR)))
1623 g_mkdir_with_parents (cache_dir, 0777);
1624 }
1625
1626 /*
1627 * The same assembly can be used in multiple configurations, i.e. multiple
1628 * versions of the runtime, with multiple versions of dependent assemblies etc.
1629 * To handle this, we compute a version string containing all this information, hash it,
1630 * and use the hash as a filename suffix.
1631 */
1632 hash = get_aot_config_hash (assembly);
1633
1634 tmp2 = g_strdup_printf ("%s-%s%s", assembly->image->assembly_name, hash, MONO_SOLIB_EXT);
1635 fname = g_build_filename (cache_dir, tmp2, (const char*)NULL);
1636 *aot_name = fname;
1637 g_free (tmp2);
1638
1639 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: loading from cache: '%s'.", fname);
1640 module = mono_dl_open (fname, MONO_DL_LAZY, NULL);
1641
1642 if (module) {
1643 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: found in cache: '%s'.", fname);
1644 return module;
1645 }
1646
1647 if (mono_is_corlib_image (assembly->image) && !mscorlib_aot_loaded)
1648 /*
1649 * Can't AOT this during startup, so we AOT it when called later from
1650 * mono_aot_get_method ().
1651 */
1652 return NULL;
1653
1654 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: not found.");
1655
1656 /* Only AOT one assembly per run to avoid slowing down execution too much */
1657 if (cache_count > 0)
1658 return NULL;
1659 cache_count ++;
1660
1661 /* Check for previous failure */
1662 failure_fname = g_strdup_printf ("%s.failure", fname);
1663 failure_file = fopen (failure_fname, "r");
1664 if (failure_file) {
1665 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: assembly '%s' previously failed to compile '%s' ('%s')... ", assembly->image->name, fname, failure_fname);
1666 g_free (failure_fname);
1667 return NULL;
1668 } else {
1669 g_free (failure_fname);
1670 fclose (failure_file);
1671 }
1672
1673 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: compiling assembly '%s', logfile: '%s.log'... ", assembly->image->name, fname);
1674
1675 /*
1676 * We need to invoke the AOT compiler here. There are multiple approaches:
1677 * - spawn a new runtime process. This can be hard when running with mkbundle, and
1678 * its hard to make the new process load the same set of assemblies.
1679 * - doing it in-process. This exposes the current process to bugs/leaks/side effects of
1680 * the AOT compiler.
1681 * - fork a new process and do the work there.
1682 */
1683 if (in_process) {
1684 aot_options = g_strdup_printf ("outfile=%s,internal-logfile=%s.log%s%s", fname, fname, config->aot_options ? "," : "", config->aot_options ? config->aot_options : "");
1685 /* Maybe due this in another thread ? */
1686 res = mono_compile_assembly (assembly, mono_parse_default_optimizations (NULL), aot_options, NULL);
1687 if (res) {
1688 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: compilation failed.");
1689 failure_fname = g_strdup_printf ("%s.failure", fname);
1690 failure_file = fopen (failure_fname, "a+");
1691 fclose (failure_file);
1692 g_free (failure_fname);
1693 } else {
1694 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: compilation succeeded.");
1695 }
1696 } else {
1697 /*
1698 * - Avoid waiting for the aot process to finish ?
1699 * (less overhead, but multiple processes could aot the same assembly at the same time)
1700 */
1701 pid = fork ();
1702 if (pid == 0) {
1703 FILE *logfile;
1704 char *logfile_name;
1705
1706 /* Child */
1707
1708 logfile_name = g_strdup_printf ("%s/aot.log", cache_dir);
1709 logfile = fopen (logfile_name, "a+");
1710 g_free (logfile_name);
1711
1712 dup2 (fileno (logfile), 1);
1713 dup2 (fileno (logfile), 2);
1714
1715 aot_options = g_strdup_printf ("outfile=%s", fname);
1716 res = mono_compile_assembly (assembly, mono_parse_default_optimizations (NULL), aot_options, NULL);
1717 if (!res) {
1718 exit (1);
1719 } else {
1720 exit (0);
1721 }
1722 } else {
1723 /* Parent */
1724 waitpid (pid, &exit_status, 0);
1725 if (!WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) == 0))
1726 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: failed.");
1727 else
1728 mono_trace (G_LOG_LEVEL_MESSAGE, MONO_TRACE_AOT, "AOT: succeeded.");
1729 }
1730 }
1731
1732 module = mono_dl_open (fname, MONO_DL_LAZY, NULL);
1733
1734 return module;
1735 }
1736
1737 #else
1738
1739 static void
1740 aot_cache_init (void)
1741 {
1742 }
1743
1744 static MonoDl*
1745 aot_cache_load_module (MonoAssembly *assembly, char **aot_name)
1746 {
1747 return NULL;
1748 }
1749
1750 #endif
1751
1752 static void
1753 find_symbol (MonoDl *module, gpointer *globals, const char *name, gpointer *value)
1754 {
1755 if (globals) {
1756 int global_index;
1757 guint16 *table, *entry;
1758 guint16 table_size;
1759 guint32 hash;
1760 char *symbol = (char*)name;
1761
1762 #ifdef TARGET_MACH
1763 symbol = g_strdup_printf ("_%s", name);
1764 #endif
1765
1766 /* The first entry points to the hash */
1767 table = (guint16 *)globals [0];
1768 globals ++;
1769
1770 table_size = table [0];
1771 table ++;
1772
1773 hash = mono_metadata_str_hash (symbol) % table_size;
1774
1775 entry = &table [hash * 2];
1776
1777 /* Search the hash for the index into the globals table */
1778 global_index = -1;
1779 while (entry [0] != 0) {
1780 guint32 index = entry [0] - 1;
1781 guint32 next = entry [1];
1782
1783 //printf ("X: %s %s\n", (char*)globals [index * 2], name);
1784
1785 if (!strcmp ((const char*)globals [index * 2], symbol)) {
1786 global_index = index;
1787 break;
1788 }
1789
1790 if (next != 0) {
1791 entry = &table [next * 2];
1792 } else {
1793 break;
1794 }
1795 }
1796
1797 if (global_index != -1)
1798 *value = globals [global_index * 2 + 1];
1799 else
1800 *value = NULL;
1801
1802 if (symbol != name)
1803 g_free (symbol);
1804 } else {
1805 char *err = mono_dl_symbol (module, name, value);
1806
1807 if (err)
1808 g_free (err);
1809 }
1810 }
1811
1812 static void
1813 find_amodule_symbol (MonoAotModule *amodule, const char *name, gpointer *value)
1814 {
1815 g_assert (!(amodule->info.flags & MONO_AOT_FILE_FLAG_LLVM_ONLY));
1816
1817 find_symbol (amodule->sofile, amodule->globals, name, value);
1818 }
1819
1820 void
1821 mono_install_load_aot_data_hook (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, gpointer user_data)
1822 {
1823 aot_data_load_func = load_func;
1824 aot_data_free_func = free_func;
1825 aot_data_func_user_data = user_data;
1826 }
1827
1828 /* Load the separate aot data file for ASSEMBLY */
1829 static guint8*
1830 open_aot_data (MonoAssembly *assembly, MonoAotFileInfo *info, void **ret_handle)
1831 {
1832 MonoFileMap *map;
1833 char *filename;
1834 guint8 *data;
1835
1836 if (aot_data_load_func) {
1837 data = aot_data_load_func (assembly, info->datafile_size, aot_data_func_user_data, ret_handle);
1838 g_assert (data);
1839 return data;
1840 }
1841
1842 /*
1843 * Use <assembly name>.aotdata as the default implementation if no callback is given
1844 */
1845 filename = g_strdup_printf ("%s.aotdata", assembly->image->name);
1846 map = mono_file_map_open (filename);
1847 g_assert (map);
1848 data = (guint8*)mono_file_map (info->datafile_size, MONO_MMAP_READ, mono_file_map_fd (map), 0, ret_handle);
1849 g_assert (data);
1850
1851 return data;
1852 }
1853
1854 static gboolean
1855 check_usable (MonoAssembly *assembly, MonoAotFileInfo *info, guint8 *blob, char **out_msg)
1856 {
1857 char *build_info;
1858 char *msg = NULL;
1859 gboolean usable = TRUE;
1860 gboolean full_aot, interp, safepoints;
1861 guint32 excluded_cpu_optimizations;
1862
1863 if (strcmp (assembly->image->guid, (const char*)info->assembly_guid)) {
1864 msg = g_strdup_printf ("doesn't match assembly");
1865 usable = FALSE;
1866 }
1867
1868 build_info = mono_get_runtime_build_info ();
1869 if (strlen ((const char *)info->runtime_version) > 0 && strcmp (info->runtime_version, build_info)) {
1870 msg = g_strdup_printf ("compiled against runtime version '%s' while this runtime has version '%s'", info->runtime_version, build_info);
1871 usable = FALSE;
1872 }
1873 g_free (build_info);
1874
1875 full_aot = info->flags & MONO_AOT_FILE_FLAG_FULL_AOT;
1876 interp = info->flags & MONO_AOT_FILE_FLAG_INTERP;
1877
1878 if (mono_aot_only && !full_aot) {
1879 if (!interp) {
1880 msg = g_strdup_printf ("not compiled with --aot=full");
1881 usable = FALSE;
1882 }
1883 }
1884 if (!mono_aot_only && full_aot) {
1885 msg = g_strdup_printf ("compiled with --aot=full");
1886 usable = FALSE;
1887 }
1888 if (mono_use_interpreter && !interp && !strcmp (assembly->aname.name, "mscorlib")) {
1889 /* mscorlib contains necessary interpreter trampolines */
1890 msg = g_strdup_printf ("not compiled with --aot=interp");
1891 usable = FALSE;
1892 }
1893 if (mono_llvm_only && !(info->flags & MONO_AOT_FILE_FLAG_LLVM_ONLY)) {
1894 msg = g_strdup_printf ("not compiled with --aot=llvmonly");
1895 usable = FALSE;
1896 }
1897 if (mono_use_llvm && !(info->flags & MONO_AOT_FILE_FLAG_WITH_LLVM)) {
1898 /* Prefer LLVM JITted code when using --llvm */
1899 msg = g_strdup_printf ("not compiled with --aot=llvm");
1900 usable = FALSE;
1901 }
1902 if (mini_debug_options.mdb_optimizations && !(info->flags & MONO_AOT_FILE_FLAG_DEBUG) && !full_aot && !interp) {
1903 msg = g_strdup_printf ("not compiled for debugging");
1904 usable = FALSE;
1905 }
1906
1907 mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
1908 if (info->opts & excluded_cpu_optimizations) {
1909 msg = g_strdup_printf ("compiled with unsupported CPU optimizations");
1910 usable = FALSE;
1911 }
1912
1913 if (!mono_aot_only && (info->simd_opts & ~mono_arch_cpu_enumerate_simd_versions ())) {
1914 msg = g_strdup_printf ("compiled with unsupported SIMD extensions");
1915 usable = FALSE;
1916 }
1917
1918 if (info->gc_name_index != -1) {
1919 char *gc_name = (char*)&blob [info->gc_name_index];
1920 const char *current_gc_name = mono_gc_get_gc_name ();
1921
1922 if (strcmp (current_gc_name, gc_name) != 0) {
1923 msg = g_strdup_printf ("compiled against GC %s, while the current runtime uses GC %s.\n", gc_name, current_gc_name);
1924 usable = FALSE;
1925 }
1926 }
1927
1928 safepoints = info->flags & MONO_AOT_FILE_FLAG_SAFEPOINTS;
1929
1930 if (!safepoints && mono_threads_are_safepoints_enabled ()) {
1931 msg = g_strdup_printf ("not compiled with safepoints");
1932 usable = FALSE;
1933 }
1934
1935 *out_msg = msg;
1936 return usable;
1937 }
1938
1939 /*
1940 * TABLE should point to a table of call instructions. Return the address called by the INDEXth entry.
1941 */
1942 static void*
1943 get_call_table_entry (void *table, int index, int entry_size)
1944 {
1945 #if defined(TARGET_ARM)
1946 guint32 *ins_addr;
1947 guint32 ins;
1948 gint32 offset;
1949
1950 if (entry_size == 8) {
1951 ins_addr = (guint32 *)table + (index * 2);
1952 g_assert ((guint32) *ins_addr == (guint32 ) 0xe51ff004); // ldr pc, =<label>
1953 return *((char **) (ins_addr + 1));
1954 }
1955
1956 g_assert (entry_size == 4);
1957 ins_addr = (guint32*)table + index;
1958 ins = *ins_addr;
1959 if ((ins >> ARMCOND_SHIFT) == ARMCOND_NV) {
1960 /* blx */
1961 offset = (((int)(((ins & 0xffffff) << 1) | ((ins >> 24) & 0x1))) << 7) >> 7;
1962 return (char*)ins_addr + (offset * 2) + 8 + 1;
1963 } else {
1964 g_assert ((ins >> ARMCOND_SHIFT) == ARMCOND_AL);
1965 /* bl */
1966 offset = (((int)ins & 0xffffff) << 8) >> 8;
1967 return (char*)ins_addr + (offset * 4) + 8;
1968 }
1969 #elif defined(TARGET_ARM64)
1970 return mono_arch_get_call_target ((guint8*)table + (index * 4) + 4);
1971 #elif defined(TARGET_X86) || defined(TARGET_AMD64)
1972 /* The callee expects an ip which points after the call */
1973 return mono_arch_get_call_target ((guint8*)table + (index * 5) + 5);
1974 #else
1975 g_assert_not_reached ();
1976 return NULL;
1977 #endif
1978 }
1979
1980 /*
1981 * init_amodule_got:
1982 *
1983 * Initialize the shared got entries for AMODULE.
1984 */
1985 static void
1986 init_amodule_got (MonoAotModule *amodule, gboolean preinit)
1987 {
1988 MonoJumpInfo *ji;
1989 MonoMemPool *mp;
1990 MonoJumpInfo *patches;
1991 guint32 got_offsets [128];
1992 ERROR_DECL (error);
1993 int i, npatches;
1994
1995 /* These can't be initialized in load_aot_module () */
1996 if (amodule->got_initialized == GOT_INITIALIZED)
1997 return;
1998
1999 mono_loader_lock ();
2000
2001 /*
2002 * If it is initialized some other thread did it in the meantime. If it is
2003 * initializing it means the current thread is initializing it since we are
2004 * holding the loader lock, skip it.
2005 */
2006 if (amodule->got_initialized) {
2007 mono_loader_unlock ();
2008 return;
2009 }
2010
2011 if (!preinit)
2012 amodule->got_initialized = GOT_INITIALIZING;
2013
2014 mp = mono_mempool_new ();
2015 npatches = amodule->info.nshared_got_entries;
2016 for (i = 0; i < npatches; ++i)
2017 got_offsets [i] = i;
2018 if (amodule->got)
2019 patches = decode_patches (amodule, mp, npatches, FALSE, got_offsets);
2020 else
2021 patches = decode_patches (amodule, mp, npatches, TRUE, got_offsets);
2022 g_assert (patches);
2023 for (i = 0; i < npatches; ++i) {
2024 ji = &patches [i];
2025
2026 if (amodule->shared_got [i]) {
2027 } else if (ji->type == MONO_PATCH_INFO_AOT_MODULE) {
2028 amodule->shared_got [i] = amodule;
2029 } else if (preinit) {
2030 /*
2031 * This is called from init_amodule () during startup, so some things might not
2032 * be setup. Initialize just the slots needed to make method initialization work.
2033 */
2034 if (ji->type == MONO_PATCH_INFO_JIT_ICALL_ID) {
2035 if (ji->data.jit_icall_id == MONO_JIT_ICALL_mini_llvm_init_method)
2036 amodule->shared_got [i] = (gpointer)mini_llvm_init_method;
2037 }
2038 } else if (ji->type == MONO_PATCH_INFO_GC_CARD_TABLE_ADDR && !mono_gc_is_moving ()) {
2039 amodule->shared_got [i] = NULL;
2040 } else if (ji->type == MONO_PATCH_INFO_GC_NURSERY_START && !mono_gc_is_moving ()) {
2041 amodule->shared_got [i] = NULL;
2042 } else if (ji->type == MONO_PATCH_INFO_GC_NURSERY_BITS && !mono_gc_is_moving ()) {
2043 amodule->shared_got [i] = NULL;
2044 } else if (ji->type == MONO_PATCH_INFO_IMAGE) {
2045 amodule->shared_got [i] = amodule->assembly->image;
2046 } else if (ji->type == MONO_PATCH_INFO_MSCORLIB_GOT_ADDR) {
2047 if (mono_defaults.corlib) {
2048 MonoAotModule *mscorlib_amodule = mono_defaults.corlib->aot_module;
2049
2050 if (mscorlib_amodule)
2051 amodule->shared_got [i] = mscorlib_amodule->got;
2052 } else {
2053 amodule->shared_got [i] = amodule->got;
2054 }
2055 } else if (ji->type == MONO_PATCH_INFO_AOT_MODULE) {
2056 amodule->shared_got [i] = amodule;
2057 } else if (ji->type == MONO_PATCH_INFO_NONE) {
2058 } else {
2059 amodule->shared_got [i] = mono_resolve_patch_target (NULL, mono_get_root_domain (), NULL, ji, FALSE, error);
2060 mono_error_assert_ok (error);
2061 }
2062 }
2063
2064 if (amodule->got) {
2065 for (i = 0; i < npatches; ++i)
2066 amodule->got [i] = amodule->shared_got [i];
2067 }
2068 if (amodule->llvm_got) {
2069 for (i = 0; i < npatches; ++i)
2070 amodule->llvm_got [i] = amodule->shared_got [i];
2071 }
2072
2073 mono_mempool_destroy (mp);
2074
2075 if (!preinit) {
2076 mono_memory_barrier ();
2077 amodule->got_initialized = GOT_INITIALIZED;
2078 }
2079 mono_loader_unlock ();
2080 }
2081
2082 #ifdef MONOTOUCH
2083 // Follow branch islands on ARM iOS machines.
2084 static inline guint8 *
2085 method_address_resolve (guint8 *code_addr) {
2086 #if defined(TARGET_ARM)
2087 // Skip branches to thumb destinations; the convention used is that the
2088 // lowest bit is set if the destination is thumb. See
2089 // get_call_table_entry.
2090 if (((uintptr_t) code_addr) & 0x1)
2091 return code_addr;
2092 #endif
2093 for (;;) {
2094 // `mono_arch_get_call_target` takes the IP after the branch
2095 // instruction, not before. Add 4 bytes to compensate.
2096 guint8 *next = mono_arch_get_call_target (code_addr + 4);
2097 if (next == NULL) return code_addr;
2098 code_addr = next;
2099 }
2100 }
2101 #else
2102 static inline guint8 *
2103 method_address_resolve (guint8 *code_addr) {
2104 return code_addr;
2105 }
2106 #endif
2107
2108 static void
2109 load_aot_module (MonoAssemblyLoadContext *alc, MonoAssembly *assembly, gpointer user_data, MonoError *error)
2110 {
2111 char *aot_name, *found_aot_name;
2112 MonoAotModule *amodule;
2113 MonoDl *sofile;
2114 gboolean usable = TRUE;
2115 char *version_symbol = NULL;
2116 char *msg = NULL;
2117 gpointer *globals = NULL;
2118 MonoAotFileInfo *info = NULL;
2119 int i, version;
2120 gboolean do_load_image = TRUE;
2121 int align_double, align_int64;
2122 guint8 *aot_data = NULL;
2123
2124 if (mono_compile_aot)
2125 return;
2126
2127 if (mono_aot_mode == MONO_AOT_MODE_NONE)
2128 return;
2129
2130 if (assembly->image->aot_module)
2131 /*
2132 * Already loaded. This can happen because the assembly loading code might invoke
2133 * the assembly load hooks multiple times for the same assembly.
2134 */
2135 return;
2136
2137 if (image_is_dynamic (assembly->image) || mono_asmctx_get_kind (&assembly->context) == MONO_ASMCTX_REFONLY || mono_domain_get () != mono_get_root_domain ())
2138 return;
2139
2140 mono_aot_lock ();
2141
2142 if (static_aot_modules)
2143 info = (MonoAotFileInfo *)g_hash_table_lookup (static_aot_modules, assembly->aname.name);
2144
2145 mono_aot_unlock ();
2146
2147 sofile = NULL;
2148
2149 found_aot_name = NULL;
2150
2151 if (info) {
2152 /* Statically linked AOT module */
2153 aot_name = g_strdup_printf ("%s", assembly->aname.name);
2154 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "Found statically linked AOT module '%s'.", aot_name);
2155 if (!(info->flags & MONO_AOT_FILE_FLAG_LLVM_ONLY)) {
2156 globals = (void **)info->globals;
2157 g_assert (globals);
2158 }
2159 found_aot_name = g_strdup (aot_name);
2160 } else {
2161 char *err;
2162
2163 if (enable_aot_cache)
2164 sofile = aot_cache_load_module (assembly, &aot_name);
2165 if (!sofile) {
2166 aot_name = g_strdup_printf ("%s%s", assembly->image->name, MONO_SOLIB_EXT);
2167
2168 sofile = mono_dl_open (aot_name, MONO_DL_LAZY, &err);
2169 if (sofile) {
2170 found_aot_name = g_strdup (aot_name);
2171 } else {
2172 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: image '%s' not found: %s", aot_name, err);
2173 g_free (err);
2174 }
2175 g_free (aot_name);
2176 }
2177 #ifndef PLATFORM_ANDROID
2178 if (!sofile) {
2179 char *basename = g_path_get_basename (assembly->image->name);
2180 aot_name = g_strdup_printf ("%s/mono/aot-cache/%s/%s%s", mono_assembly_getrootdir(), MONO_ARCHITECTURE, basename, MONO_SOLIB_EXT);
2181 g_free (basename);
2182 sofile = mono_dl_open (aot_name, MONO_DL_LAZY, &err);
2183 if (!sofile) {
2184 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: image '%s' not found: %s", aot_name, err);
2185 g_free (err);
2186 }
2187 g_free (aot_name);
2188 }
2189 #endif
2190 if (!sofile) {
2191 GList *l;
2192
2193 for (l = mono_aot_paths; l; l = l->next) {
2194 char *path = (char*)l->data;
2195
2196 char *basename = g_path_get_basename (assembly->image->name);
2197 aot_name = g_strdup_printf ("%s/%s%s", path, basename, MONO_SOLIB_EXT);
2198 sofile = mono_dl_open (aot_name, MONO_DL_LAZY, &err);
2199 if (sofile) {
2200 found_aot_name = g_strdup (aot_name);
2201 } else {
2202 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: image '%s' not found: %s", aot_name, err);
2203 g_free (err);
2204 }
2205 g_free (basename);
2206 g_free (aot_name);
2207 if (sofile)
2208 break;
2209 }
2210 }
2211 if (!sofile) {
2212 if (mono_aot_only && !mono_use_interpreter && assembly->image->tables [MONO_TABLE_METHOD].rows) {
2213 aot_name = g_strdup_printf ("%s%s", assembly->image->name, MONO_SOLIB_EXT);
2214 g_error ("Failed to load AOT module '%s' in aot-only mode.\n", aot_name);
2215 g_free (aot_name);
2216 }
2217 return;
2218 }
2219 }
2220
2221 if (!info) {
2222 find_symbol (sofile, globals, "mono_aot_version", (gpointer *) &version_symbol);
2223 find_symbol (sofile, globals, "mono_aot_file_info", (gpointer*)&info);
2224 }
2225
2226 // Copy aotid to MonoImage
2227 memcpy(&assembly->image->aotid, info->aotid, 16);
2228
2229 if (version_symbol) {
2230 /* Old file format */
2231 version = atoi (version_symbol);
2232 } else {
2233 g_assert (info);
2234 version = info->version;
2235 }
2236
2237 if (version != MONO_AOT_FILE_VERSION) {
2238 msg = g_strdup_printf ("wrong file format version (expected %d got %d)", MONO_AOT_FILE_VERSION, version);
2239 usable = FALSE;
2240 } else {
2241 guint8 *blob;
2242 void *handle;
2243
2244 if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA) {
2245 aot_data = open_aot_data (assembly, info, &handle);
2246
2247 blob = aot_data + info->table_offsets [MONO_AOT_TABLE_BLOB];
2248 } else {
2249 blob = (guint8 *)info->blob;
2250 }
2251
2252 usable = check_usable (assembly, info, blob, &msg);
2253 }
2254
2255 if (!usable) {
2256 if (mono_aot_only) {
2257 g_error ("Failed to load AOT module '%s' while running in aot-only mode: %s.\n", found_aot_name, msg);
2258 } else {
2259 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: module %s is unusable: %s.", found_aot_name, msg);
2260 }
2261 g_free (msg);
2262 g_free (found_aot_name);
2263 if (sofile)
2264 mono_dl_close (sofile);
2265 assembly->image->aot_module = NULL;
2266 return;
2267 }
2268
2269 /* Sanity check */
2270 align_double = MONO_ABI_ALIGNOF (double);
2271 align_int64 = MONO_ABI_ALIGNOF (gint64);
2272 int card_table_shift_bits = 0;
2273 gpointer card_table_mask = NULL;
2274 mono_gc_get_card_table (&card_table_shift_bits, &card_table_mask);
2275
2276 g_assert (info->double_align == align_double);
2277 g_assert (info->long_align == align_int64);
2278 g_assert (info->generic_tramp_num == MONO_TRAMPOLINE_NUM);
2279 g_assert (info->card_table_shift_bits == card_table_shift_bits);
2280 g_assert (info->card_table_mask == GPOINTER_TO_UINT (card_table_mask));
2281
2282 amodule = g_new0 (MonoAotModule, 1);
2283 amodule->aot_name = found_aot_name;
2284 amodule->assembly = assembly;
2285
2286 memcpy (&amodule->info, info, sizeof (*info));
2287
2288 amodule->got = (void **)amodule->info.jit_got;
2289 amodule->llvm_got = (void **)amodule->info.llvm_got;
2290 amodule->globals = globals;
2291 amodule->sofile = sofile;
2292 amodule->method_to_code = g_hash_table_new (mono_aligned_addr_hash, NULL);
2293 amodule->extra_methods = g_hash_table_new (NULL, NULL);
2294 amodule->shared_got = g_new0 (gpointer, info->nshared_got_entries);
2295
2296 if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA) {
2297 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
2298 amodule->tables [i] = aot_data + info->table_offsets [i];
2299 }
2300
2301 mono_os_mutex_init_recursive (&amodule->mutex);
2302
2303 /* Read image table */
2304 {
2305 guint32 table_len, i;
2306 char *table = NULL;
2307
2308 if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA)
2309 table = (char *)amodule->tables [MONO_AOT_TABLE_IMAGE_TABLE];
2310 else
2311 table = (char *)info->image_table;
2312 g_assert (table);
2313
2314 table_len = *(guint32*)table;
2315 table += sizeof (guint32);
2316 amodule->image_table = g_new0 (MonoImage*, table_len);
2317 amodule->image_names = g_new0 (MonoAssemblyName, table_len);
2318 amodule->image_guids = g_new0 (char*, table_len);
2319 amodule->image_table_len = table_len;
2320 for (i = 0; i < table_len; ++i) {
2321 MonoAssemblyName *aname = &(amodule->image_names [i]);
2322
2323 aname->name = g_strdup (table);
2324 table += strlen (table) + 1;
2325 amodule->image_guids [i] = g_strdup (table);
2326 table += strlen (table) + 1;
2327 if (table [0] != 0)
2328 aname->culture = g_strdup (table);
2329 table += strlen (table) + 1;
2330 memcpy (aname->public_key_token, table, strlen (table) + 1);
2331 table += strlen (table) + 1;
2332
2333 table = (char *)ALIGN_PTR_TO (table, 8);
2334 aname->flags = *(guint32*)table;
2335 table += 4;
2336 aname->major = *(guint32*)table;
2337 table += 4;
2338 aname->minor = *(guint32*)table;
2339 table += 4;
2340 aname->build = *(guint32*)table;
2341 table += 4;
2342 aname->revision = *(guint32*)table;
2343 table += 4;
2344 }
2345 }
2346
2347 amodule->jit_code_start = (guint8 *)info->jit_code_start;
2348 amodule->jit_code_end = (guint8 *)info->jit_code_end;
2349 if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA) {
2350 amodule->blob = (guint8*)amodule->tables [MONO_AOT_TABLE_BLOB];
2351 amodule->method_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_METHOD_INFO_OFFSETS];
2352 amodule->ex_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_EX_INFO_OFFSETS];
2353 amodule->class_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_CLASS_INFO_OFFSETS];
2354 amodule->class_name_table = (guint16*)amodule->tables [MONO_AOT_TABLE_CLASS_NAME];
2355 amodule->extra_method_table = (guint32*)amodule->tables [MONO_AOT_TABLE_EXTRA_METHOD_TABLE];
2356 amodule->extra_method_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_EXTRA_METHOD_INFO_OFFSETS];
2357 amodule->got_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_GOT_INFO_OFFSETS];
2358 amodule->llvm_got_info_offsets = (guint32*)amodule->tables [MONO_AOT_TABLE_LLVM_GOT_INFO_OFFSETS];
2359 amodule->weak_field_indexes = (guint32*)amodule->tables [MONO_AOT_TABLE_WEAK_FIELD_INDEXES];
2360 } else {
2361 amodule->blob = (guint8*)info->blob;
2362 amodule->method_info_offsets = (guint32 *)info->method_info_offsets;
2363 amodule->ex_info_offsets = (guint32 *)info->ex_info_offsets;
2364 amodule->class_info_offsets = (guint32 *)info->class_info_offsets;
2365 amodule->class_name_table = (guint16 *)info->class_name_table;
2366 amodule->extra_method_table = (guint32 *)info->extra_method_table;
2367 amodule->extra_method_info_offsets = (guint32 *)info->extra_method_info_offsets;
2368 amodule->got_info_offsets = (guint32*)info->got_info_offsets;
2369 amodule->llvm_got_info_offsets = (guint32*)info->llvm_got_info_offsets;
2370 amodule->weak_field_indexes = (guint32*)info->weak_field_indexes;
2371 }
2372 amodule->unbox_trampolines = (guint32 *)info->unbox_trampolines;
2373 amodule->unbox_trampolines_end = (guint32 *)info->unbox_trampolines_end;
2374 amodule->unbox_trampoline_addresses = (guint32 *)info->unbox_trampoline_addresses;
2375 amodule->unwind_info = (guint8 *)info->unwind_info;
2376 amodule->mem_begin = (guint8*)amodule->jit_code_start;
2377 amodule->mem_end = (guint8 *)info->mem_end;
2378 amodule->plt = (guint8 *)info->plt;
2379 amodule->plt_end = (guint8 *)info->plt_end;
2380 amodule->mono_eh_frame = (guint8 *)info->mono_eh_frame;
2381 amodule->trampolines [MONO_AOT_TRAMP_SPECIFIC] = (guint8 *)info->specific_trampolines;
2382 amodule->trampolines [MONO_AOT_TRAMP_STATIC_RGCTX] = (guint8 *)info->static_rgctx_trampolines;
2383 amodule->trampolines [MONO_AOT_TRAMP_IMT] = (guint8 *)info->imt_trampolines;
2384 amodule->trampolines [MONO_AOT_TRAMP_GSHAREDVT_ARG] = (guint8 *)info->gsharedvt_arg_trampolines;
2385 amodule->trampolines [MONO_AOT_TRAMP_FTNPTR_ARG] = (guint8 *)info->ftnptr_arg_trampolines;
2386 amodule->trampolines [MONO_AOT_TRAMP_UNBOX_ARBITRARY] = (guint8 *)info->unbox_arbitrary_trampolines;
2387
2388 if (mono_is_corlib_image (assembly->image) || !strcmp (assembly->aname.name, "mscorlib") || !strcmp (assembly->aname.name, "System.Private.CoreLib"))
2389 mscorlib_aot_module = amodule;
2390
2391 /* Compute method addresses */
2392 amodule->methods = (void **)g_malloc0 (amodule->info.nmethods * sizeof (gpointer));
2393 for (i = 0; i < amodule->info.nmethods; ++i) {
2394 void *addr = NULL;
2395
2396 if (amodule->info.llvm_get_method) {
2397 gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
2398
2399 addr = get_method (i);
2400 }
2401
2402 /* method_addresses () contains a table of branches, since the ios linker can update those correctly */
2403 if (!addr && amodule->info.method_addresses) {
2404 addr = get_call_table_entry (amodule->info.method_addresses, i, amodule->info.call_table_entry_size);
2405 g_assert (addr);
2406 if (addr == amodule->info.method_addresses)
2407 addr = NULL;
2408 else
2409 addr = method_address_resolve ((guint8 *) addr);
2410 }
2411 if (addr == NULL)
2412 amodule->methods [i] = GINT_TO_POINTER (-1);
2413 else
2414 amodule->methods [i] = addr;
2415 }
2416
2417 if (make_unreadable) {
2418 #ifndef TARGET_WIN32
2419 guint8 *addr;
2420 guint8 *page_start, *page_end;
2421 int err, len;
2422
2423 addr = amodule->mem_begin;
2424 g_assert (addr);
2425 len = amodule->mem_end - amodule->mem_begin;
2426
2427 /* Round down in both directions to avoid modifying data which is not ours */
2428 page_start = (guint8 *) (((gssize) (addr)) & ~ (mono_pagesize () - 1)) + mono_pagesize ();
2429 page_end = (guint8 *) (((gssize) (addr + len)) & ~ (mono_pagesize () - 1));
2430 if (page_end > page_start) {
2431 err = mono_mprotect (page_start, (page_end - page_start), MONO_MMAP_NONE);
2432 g_assert (err == 0);
2433 }
2434 #endif
2435 }
2436
2437 /* Compute the boundaries of LLVM code */
2438 if (info->flags & MONO_AOT_FILE_FLAG_WITH_LLVM)
2439 compute_llvm_code_range (amodule, &amodule->llvm_code_start, &amodule->llvm_code_end);
2440
2441 mono_aot_lock ();
2442
2443 if (amodule->jit_code_start) {
2444 aot_code_low_addr = MIN (aot_code_low_addr, (gsize)amodule->jit_code_start);
2445 aot_code_high_addr = MAX (aot_code_high_addr, (gsize)amodule->jit_code_end);
2446 }
2447 if (amodule->llvm_code_start) {
2448 aot_code_low_addr = MIN (aot_code_low_addr, (gsize)amodule->llvm_code_start);
2449 aot_code_high_addr = MAX (aot_code_high_addr, (gsize)amodule->llvm_code_end);
2450 }
2451
2452 g_hash_table_insert (aot_modules, assembly, amodule);
2453 mono_aot_unlock ();
2454
2455 init_amodule_got (amodule, TRUE);
2456
2457 if (amodule->jit_code_start)
2458 mono_jit_info_add_aot_module (assembly->image, amodule->jit_code_start, amodule->jit_code_end);
2459 if (amodule->llvm_code_start)
2460 mono_jit_info_add_aot_module (assembly->image, amodule->llvm_code_start, amodule->llvm_code_end);
2461
2462 assembly->image->aot_module = amodule;
2463
2464 if (mono_aot_only && !mono_llvm_only) {
2465 char *code;
2466 find_amodule_symbol (amodule, "specific_trampolines_page", (gpointer *)&code);
2467 amodule->use_page_trampolines = code != NULL;
2468 /*g_warning ("using page trampolines: %d", amodule->use_page_trampolines);*/
2469 }
2470
2471 if (info->flags & MONO_AOT_FILE_FLAG_WITH_LLVM)
2472 /* Directly called methods might make calls through the PLT */
2473 init_plt (amodule);
2474
2475 /*
2476 * Register the plt region as a single trampoline so we can unwind from this code
2477 */
2478 mono_aot_tramp_info_register (
2479 mono_tramp_info_create (
2480 NULL,
2481 amodule->plt,
2482 amodule->plt_end - amodule->plt,
2483 NULL,
2484 mono_unwind_get_cie_program ()
2485 ),
2486 NULL
2487 );
2488
2489 /*
2490 * Since we store methoddef and classdef tokens when referring to methods/classes in
2491 * referenced assemblies, we depend on the exact versions of the referenced assemblies.
2492 * MS calls this 'hard binding'. This means we have to load all referenced assemblies
2493 * non-lazily, since we can't handle out-of-date errors later.
2494 * The cached class info also depends on the exact assemblies.
2495 */
2496 if (do_load_image) {
2497 for (i = 0; i < amodule->image_table_len; ++i) {
2498 ERROR_DECL (error);
2499 load_image (amodule, i, error);
2500 mono_error_cleanup (error); /* FIXME don't swallow the error */
2501 }
2502 }
2503
2504 if (amodule->out_of_date) {
2505 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: Module %s is unusable because a dependency is out-of-date.", assembly->image->name);
2506 if (mono_aot_only)
2507 g_error ("Failed to load AOT module '%s' while running in aot-only mode because a dependency cannot be found or it is out of date.\n", found_aot_name);
2508 } else {
2509 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_AOT, "AOT: image '%s' found.", found_aot_name);
2510 }
2511 }
2512
2513 /*
2514 * mono_aot_register_module:
2515 *
2516 * This should be called by embedding code to register normal AOT modules statically linked
2517 * into the executable.
2518 *
2519 * \param aot_info the value of the 'mono_aot_module_<ASSEMBLY_NAME>_info' global symbol from the AOT module.
2520 */
2521 void
2522 mono_aot_register_module (gpointer *aot_info)
2523 {
2524 gpointer *globals;
2525 char *aname;
2526 MonoAotFileInfo *info = (MonoAotFileInfo *)aot_info;
2527
2528 g_assert (info->version == MONO_AOT_FILE_VERSION);
2529
2530 if (!(info->flags & MONO_AOT_FILE_FLAG_LLVM_ONLY)) {
2531 globals = (void **)info->globals;
2532 g_assert (globals);
2533 }
2534
2535 aname = (char *)info->assembly_name;
2536
2537 /* This could be called before startup */
2538 if (aot_modules)
2539 mono_aot_lock ();
2540
2541 if (!static_aot_modules)
2542 static_aot_modules = g_hash_table_new (g_str_hash, g_str_equal);
2543
2544 g_hash_table_insert (static_aot_modules, aname, info);
2545
2546 if (info->flags & MONO_AOT_FILE_FLAG_EAGER_LOAD) {
2547 g_assert (!container_assm_name);
2548 container_assm_name = aname;
2549 }
2550
2551 if (aot_modules)
2552 mono_aot_unlock ();
2553 }
2554
2555 void
2556 mono_aot_init (void)
2557 {
2558 mono_os_mutex_init_recursive (&aot_mutex);
2559 mono_os_mutex_init_recursive (&aot_page_mutex);
2560 aot_modules = g_hash_table_new (NULL, NULL);
2561
2562 mono_install_assembly_load_hook_v2 (load_aot_module, NULL);
2563 mono_counters_register ("Async JIT info size", MONO_COUNTER_INT|MONO_COUNTER_JIT, &async_jit_info_size);
2564
2565 char *lastaot = g_getenv ("MONO_LASTAOT");
2566 if (lastaot) {
2567 mono_last_aot_method = atoi (lastaot);
2568 g_free (lastaot);
2569 }
2570 aot_cache_init ();
2571 }
2572
2573 void
2574 mono_aot_cleanup (void)
2575 {
2576 g_hash_table_destroy (aot_modules);
2577 }
2578
2579 static void
2580 load_container_amodule (MonoAssemblyLoadContext *alc)
2581 {
2582 ERROR_DECL (error);
2583
2584 if (!container_assm_name || container_amodule)
2585 return;
2586
2587 char *local_ref = container_assm_name;
2588 container_assm_name = NULL;
2589 MonoImageOpenStatus status = MONO_IMAGE_OK;
2590 MonoAssemblyOpenRequest req;
2591 gchar *dll = g_strdup_printf ( "%s.dll", local_ref);
2592 mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
2593 MonoAssembly *assm = mono_assembly_request_open (dll, &req, &status);
2594 if (!assm) {
2595 gchar *exe = g_strdup_printf ("%s.exe", local_ref);
2596 assm = mono_assembly_request_open (exe, &req, &status);
2597 }
2598 g_assert (assm);
2599 load_aot_module (alc, assm, NULL, error);
2600 container_amodule = assm->image->aot_module;
2601 }
2602
2603 static gboolean
2604 decode_cached_class_info (MonoAotModule *module, MonoCachedClassInfo *info, guint8 *buf, guint8 **endbuf)
2605 {
2606 ERROR_DECL (error);
2607 guint32 flags;
2608 MethodRef ref;
2609 gboolean res;
2610
2611 info->vtable_size = decode_value (buf, &buf);
2612 if (info->vtable_size == -1)
2613 /* Generic type */
2614 return FALSE;
2615 flags = decode_value (buf, &buf);
2616 info->ghcimpl = (flags >> 0) & 0x1;
2617 info->has_finalize = (flags >> 1) & 0x1;
2618 info->has_cctor = (flags >> 2) & 0x1;
2619 info->has_nested_classes = (flags >> 3) & 0x1;
2620 info->blittable = (flags >> 4) & 0x1;
2621 info->has_references = (flags >> 5) & 0x1;
2622 info->has_static_refs = (flags >> 6) & 0x1;
2623 info->no_special_static_fields = (flags >> 7) & 0x1;
2624 info->is_generic_container = (flags >> 8) & 0x1;
2625 info->has_weak_fields = (flags >> 9) & 0x1;
2626
2627 if (info->has_cctor) {
2628 res = decode_method_ref (module, &ref, buf, &buf, error);
2629 mono_error_assert_ok (error); /* FIXME don't swallow the error */
2630 if (!res)
2631 return FALSE;
2632 info->cctor_token = ref.token;
2633 }
2634 if (info->has_finalize) {
2635 res = decode_method_ref (module, &ref, buf, &buf, error);
2636 mono_error_assert_ok (error); /* FIXME don't swallow the error */
2637 if (!res)
2638 return FALSE;
2639 info->finalize_image = ref.image;
2640 info->finalize_token = ref.token;
2641 }
2642
2643 info->instance_size = decode_value (buf, &buf);
2644 info->class_size = decode_value (buf, &buf);
2645 info->packing_size = decode_value (buf, &buf);
2646 info->min_align = decode_value (buf, &buf);
2647
2648 *endbuf = buf;
2649
2650 return TRUE;
2651 }
2652
2653 gpointer
2654 mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot, MonoError *error)
2655 {
2656 int i;
2657 MonoClass *klass = vtable->klass;
2658 MonoAotModule *amodule = m_class_get_image (klass)->aot_module;
2659 guint8 *info, *p;
2660 MonoCachedClassInfo class_info;
2661 gboolean err;
2662 MethodRef ref;
2663 gboolean res;
2664 gpointer addr;
2665 ERROR_DECL (inner_error);
2666
2667 error_init (error);
2668
2669 if (MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || m_class_get_rank (klass) || !amodule)
2670 return NULL;
2671
2672 info = &amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (m_class_get_type_token (klass)) - 1)];
2673 p = info;
2674
2675 err = decode_cached_class_info (amodule, &class_info, p, &p);
2676 if (!err)
2677 return NULL;
2678
2679 for (i = 0; i < slot; ++i) {
2680 decode_method_ref (amodule, &ref, p, &p, inner_error);
2681 mono_error_cleanup (inner_error); /* FIXME don't swallow the error */
2682 }
2683
2684 res = decode_method_ref (amodule, &ref, p, &p, inner_error);
2685 mono_error_cleanup (inner_error); /* FIXME don't swallow the error */
2686 if (!res)
2687 return NULL;
2688 if (ref.no_aot_trampoline)
2689 return NULL;
2690
2691 if (mono_metadata_token_index (ref.token) == 0 || mono_metadata_token_table (ref.token) != MONO_TABLE_METHOD)
2692 return NULL;
2693
2694 addr = mono_aot_get_method_from_token (domain, ref.image, ref.token, error);
2695 return addr;
2696 }
2697
2698 gboolean
2699 mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res)
2700 {
2701 MonoAotModule *amodule = m_class_get_image (klass)->aot_module;
2702 guint8 *p;
2703 gboolean err;
2704
2705 if (m_class_get_rank (klass) || !m_class_get_type_token (klass) || !amodule)
2706 return FALSE;
2707
2708 p = (guint8*)&amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (m_class_get_type_token (klass)) - 1)];
2709
2710 err = decode_cached_class_info (amodule, res, p, &p);
2711 if (!err)
2712 return FALSE;
2713
2714 return TRUE;
2715 }
2716
2717 /**
2718 * mono_aot_get_class_from_name:
2719 *
2720 * Obtains a MonoClass with a given namespace and a given name which is located in IMAGE,
2721 * using a cache stored in the AOT file.
2722 * Stores the resulting class in *KLASS if found, stores NULL otherwise.
2723 *
2724 * Returns: TRUE if the klass was found/not found in the cache, FALSE if no aot file was
2725 * found.
2726 */
2727 gboolean
2728 mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass)
2729 {
2730 MonoAotModule *amodule = image->aot_module;
2731 guint16 *table, *entry;
2732 guint16 table_size;
2733 guint32 hash;
2734 char full_name_buf [1024];
2735 char *full_name;
2736 const char *name2, *name_space2;
2737 MonoTableInfo *t;
2738 guint32 cols [MONO_TYPEDEF_SIZE];
2739 GHashTable *nspace_table;
2740
2741 if (!amodule || !amodule->class_name_table)
2742 return FALSE;
2743
2744 amodule_lock (amodule);
2745
2746 *klass = NULL;
2747
2748 /* First look in the cache */
2749 if (!amodule->name_cache)
2750 amodule->name_cache = g_hash_table_new (g_str_hash, g_str_equal);
2751 nspace_table = (GHashTable *)g_hash_table_lookup (amodule->name_cache, name_space);
2752 if (nspace_table) {
2753 *klass = (MonoClass *)g_hash_table_lookup (nspace_table, name);
2754 if (*klass) {
2755 amodule_unlock (amodule);
2756 return TRUE;
2757 }
2758 }
2759
2760 table_size = amodule->class_name_table [0];
2761 table = amodule->class_name_table + 1;
2762
2763 if (name_space [0] == '\0')
2764 full_name = g_strdup_printf ("%s", name);
2765 else {
2766 if (strlen (name_space) + strlen (name) < 1000) {
2767 sprintf (full_name_buf, "%s.%s", name_space, name);
2768 full_name = full_name_buf;
2769 } else {
2770 full_name = g_strdup_printf ("%s.%s", name_space, name);
2771 }
2772 }
2773 hash = mono_metadata_str_hash (full_name) % table_size;
2774 if (full_name != full_name_buf)
2775 g_free (full_name);
2776
2777 entry = &table [hash * 2];
2778
2779 if (entry [0] != 0) {
2780 t = &image->tables [MONO_TABLE_TYPEDEF];
2781
2782 while (TRUE) {
2783 guint32 index = entry [0];
2784 guint32 next = entry [1];
2785 guint32 token = mono_metadata_make_token (MONO_TABLE_TYPEDEF, index);
2786
2787 name_table_accesses ++;
2788
2789 mono_metadata_decode_row (t, index - 1, cols, MONO_TYPEDEF_SIZE);
2790
2791 name2 = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
2792 name_space2 = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
2793
2794 if (!strcmp (name, name2) && !strcmp (name_space, name_space2)) {
2795 ERROR_DECL (error);
2796 amodule_unlock (amodule);
2797 *klass = mono_class_get_checked (image, token, error);
2798 if (!is_ok (error))
2799 mono_error_cleanup (error); /* FIXME don't swallow the error */
2800
2801 /* Add to cache */
2802 if (*klass) {
2803 amodule_lock (amodule);
2804 nspace_table = (GHashTable *)g_hash_table_lookup (amodule->name_cache, name_space);
2805 if (!nspace_table) {
2806 nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
2807 g_hash_table_insert (amodule->name_cache, (char*)name_space2, nspace_table);
2808 }
2809 g_hash_table_insert (nspace_table, (char*)name2, *klass);
2810 amodule_unlock (amodule);
2811 }
2812 return TRUE;
2813 }
2814
2815 if (next != 0) {
2816 entry = &table [next * 2];
2817 } else {
2818 break;
2819 }
2820 }
2821 }
2822
2823 amodule_unlock (amodule);
2824
2825 return TRUE;
2826 }
2827
2828 GHashTable *
2829 mono_aot_get_weak_field_indexes (MonoImage *image)
2830 {
2831 MonoAotModule *amodule = image->aot_module;
2832
2833 if (!amodule)
2834 return NULL;
2835
2836 /* Initialize weak field indexes from the cached copy */
2837 guint32 *indexes = (guint32*)amodule->weak_field_indexes;
2838 int len = indexes [0];
2839 GHashTable *indexes_hash = g_hash_table_new (NULL, NULL);
2840 for (int i = 0; i < len; ++i)
2841 g_hash_table_insert (indexes_hash, GUINT_TO_POINTER (indexes [i + 1]), GUINT_TO_POINTER (1));
2842 return indexes_hash;
2843 }
2844
2845 /* Compute the boundaries of the LLVM code for AMODULE. */
2846 static void
2847 compute_llvm_code_range (MonoAotModule *amodule, guint8 **code_start, guint8 **code_end)
2848 {
2849 guint8 *p;
2850 int version, fde_count;
2851 gint32 *table;
2852
2853 if (amodule->info.llvm_get_method) {
2854 gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
2855
2856 #ifdef HOST_WASM
2857 gsize min = 1 << 30, max = 0;
2858 gsize prev = 0;
2859
2860 // FIXME: This depends on emscripten allocating ftnptr ids sequentially
2861 for (int i = 0; i < amodule->info.nmethods; ++i) {
2862 void *addr = NULL;
2863
2864 addr = get_method (i);
2865 gsize val = (gsize)addr;
2866 if (val) {
2867 //g_assert (val > prev);
2868 if (val < min)
2869 min = val;
2870 else if (val > max)
2871 max = val;
2872 prev = val;
2873 }
2874 }
2875 if (max) {
2876 *code_start = (guint8*)min;
2877 *code_end = (guint8*)(max + 1);
2878 } else {
2879 *code_start = NULL;
2880 *code_end = NULL;
2881 }
2882 #else
2883 *code_start = (guint8 *)get_method (-1);
2884 *code_end = (guint8 *)get_method (-2);
2885
2886 g_assert (*code_end > *code_start);
2887 #endif
2888 return;
2889 }
2890
2891 g_assert (amodule->mono_eh_frame);
2892
2893 p = amodule->mono_eh_frame;
2894
2895 /* p points to data emitted by LLVM in DwarfException::EmitMonoEHFrame () */
2896
2897 /* Header */
2898 version = *p;
2899 g_assert (version == 3);
2900 p ++;
2901 p ++;
2902 p = (guint8 *)ALIGN_PTR_TO (p, 4);
2903
2904 fde_count = *(guint32*)p;
2905 p += 4;
2906 table = (gint32*)p;
2907
2908 if (fde_count > 0) {
2909 *code_start = (guint8 *)amodule->methods [table [0]];
2910 *code_end = (guint8*)amodule->methods [table [(fde_count - 1) * 2]] + table [fde_count * 2];
2911 } else {
2912 *code_start = NULL;
2913 *code_end = NULL;
2914 }
2915 }
2916
2917 static gboolean
2918 is_llvm_code (MonoAotModule *amodule, guint8 *code)
2919 {
2920 #if HOST_WASM
2921 return TRUE;
2922 #else
2923 if ((guint8*)code >= amodule->llvm_code_start && (guint8*)code < amodule->llvm_code_end)
2924 return TRUE;
2925 else
2926 return FALSE;
2927 #endif
2928 }
2929
2930 static gboolean
2931 is_thumb_code (MonoAotModule *amodule, guint8 *code)
2932 {
2933 if (is_llvm_code (amodule, code) && (amodule->info.flags & MONO_AOT_FILE_FLAG_LLVM_THUMB))
2934 return TRUE;
2935 else
2936 return FALSE;
2937 }
2938
2939 /*
2940 * decode_llvm_mono_eh_frame:
2941 *
2942 * Decode the EH information emitted by our modified LLVM compiler and construct a
2943 * MonoJitInfo structure from it.
2944 * If JINFO is NULL, set OUT_LLVM_CLAUSES to the number of llvm level clauses.
2945 * This function is async safe when called in async context.
2946 */
2947 static void
2948 decode_llvm_mono_eh_frame (MonoAotModule *amodule, MonoDomain *domain, MonoJitInfo *jinfo,
2949 guint8 *code, guint32 code_len,
2950 MonoJitExceptionInfo *clauses, int num_clauses,
2951 GSList **nesting,
2952 int *this_reg, int *this_offset, int *out_llvm_clauses)
2953 {
2954 guint8 *p, *code1, *code2;
2955 guint8 *fde, *cie, *code_start, *code_end;
2956 int version, fde_count;
2957 gint32 *table;
2958 int i, pos, left, right;
2959 MonoJitExceptionInfo *ei;
2960 guint32 fde_len, ei_len, nested_len, nindex;
2961 gpointer *type_info;
2962 MonoLLVMFDEInfo info;
2963 guint8 *unw_info;
2964 gboolean async;
2965
2966 async = mono_thread_info_is_async_context ();
2967
2968 if (!amodule->mono_eh_frame) {
2969 if (!jinfo) {
2970 *out_llvm_clauses = num_clauses;
2971 return;
2972 }
2973 memcpy (jinfo->clauses, clauses, num_clauses * sizeof (MonoJitExceptionInfo));
2974 return;
2975 }
2976
2977 g_assert (amodule->mono_eh_frame && code);
2978
2979 p = amodule->mono_eh_frame;
2980
2981 /* p points to data emitted by LLVM in DwarfMonoException::EmitMonoEHFrame () */
2982
2983 /* Header */
2984 version = *p;
2985 g_assert (version == 3);
2986 p ++;
2987 /* func_encoding = *p; */
2988 p ++;
2989 p = (guint8 *)ALIGN_PTR_TO (p, 4);
2990
2991 fde_count = *(guint32*)p;
2992 p += 4;
2993 table = (gint32*)p;
2994
2995 /* There is +1 entry in the table */
2996 cie = p + ((fde_count + 1) * 8);
2997
2998 /* Binary search in the table to find the entry for code */
2999 left = 0;
3000 right = fde_count;
3001 while (TRUE) {
3002 pos = (left + right) / 2;
3003
3004 /* The table contains method index/fde offset pairs */
3005 g_assert (table [(pos * 2)] != -1);
3006 code1 = (guint8 *)amodule->methods [table [(pos * 2)]];
3007 if (pos + 1 == fde_count) {
3008 code2 = amodule->llvm_code_end;
3009 } else {
3010 g_assert (table [(pos + 1) * 2] != -1);
3011 code2 = (guint8 *)amodule->methods [table [(pos + 1) * 2]];
3012 }
3013
3014 if (code < code1)
3015 right = pos;
3016 else if (code >= code2)
3017 left = pos + 1;
3018 else
3019 break;
3020 }
3021
3022 code_start = (guint8 *)amodule->methods [table [(pos * 2)]];
3023 if (pos + 1 == fde_count) {
3024 /* The +1 entry in the table contains the length of the last method */
3025 int len = table [(pos + 1) * 2];
3026 code_end = code_start + len;
3027 } else {
3028 code_end = (guint8 *)amodule->methods [table [(pos + 1) * 2]];
3029 }
3030 if (!code_len)
3031 code_len = code_end - code_start;
3032
3033 g_assert (code >= code_start && code < code_end);
3034
3035 if (is_thumb_code (amodule, code_start))
3036 /* Clear thumb flag */
3037 code_start = (guint8*)(((gsize)code_start) & ~1);
3038
3039 fde = amodule->mono_eh_frame + table [(pos * 2) + 1];
3040 /* This won't overflow because there is +1 entry in the table */
3041 fde_len = table [(pos * 2) + 2 + 1] - table [(pos * 2) + 1];
3042
3043 /* Compute lengths */
3044 mono_unwind_decode_llvm_mono_fde (fde, fde_len, cie, code_start, &info, NULL, NULL, NULL);
3045
3046 if (async) {
3047 /* These are leaked, but the leak is bounded */
3048 ei = mono_domain_alloc0_lock_free (domain, info.ex_info_len * sizeof (MonoJitExceptionInfo));
3049 type_info = mono_domain_alloc0_lock_free (domain, info.ex_info_len * sizeof (gpointer));
3050 unw_info = mono_domain_alloc0_lock_free (domain, info.unw_info_len);
3051 } else {
3052 ei = (MonoJitExceptionInfo *)g_malloc0 (info.ex_info_len * sizeof (MonoJitExceptionInfo));
3053 type_info = (gpointer *)g_malloc0 (info.ex_info_len * sizeof (gpointer));
3054 unw_info = (guint8*)g_malloc0 (info.unw_info_len);
3055 }
3056 mono_unwind_decode_llvm_mono_fde (fde, fde_len, cie, code_start, &info, ei, type_info, unw_info);
3057
3058 ei_len = info.ex_info_len;
3059 *this_reg = info.this_reg;
3060 *this_offset = info.this_offset;
3061
3062 /*
3063 * LLVM might represent one IL region with multiple regions.
3064 */
3065
3066 /* Count number of nested clauses */
3067 nested_len = 0;
3068 for (i = 0; i < ei_len; ++i) {
3069 /* This might be unaligned */
3070 gint32 cindex1 = read32 (type_info [i]);
3071 GSList *l;
3072
3073 for (l = nesting [cindex1]; l; l = l->next)
3074 nested_len ++;
3075 }
3076
3077 if (!jinfo) {
3078 *out_llvm_clauses = ei_len + nested_len;
3079 return;
3080 }
3081
3082 /* Store the unwind info addr/length in the MonoJitInfo structure itself so its async safe */
3083 MonoUnwindJitInfo *jinfo_unwind = mono_jit_info_get_unwind_info (jinfo);
3084 g_assert (jinfo_unwind);
3085 jinfo_unwind->unw_info = unw_info;
3086 jinfo_unwind->unw_info_len = info.unw_info_len;
3087
3088 for (i = 0; i < ei_len; ++i) {
3089 /*
3090 * clauses contains the original IL exception info saved by the AOT
3091 * compiler, we have to combine that with the information produced by LLVM
3092 */
3093 /* The type_info entries contain IL clause indexes */
3094 int clause_index = read32 (type_info [i]);
3095 MonoJitExceptionInfo *jei = &jinfo->clauses [i];
3096 MonoJitExceptionInfo *orig_jei = &clauses [clause_index];
3097
3098 g_assert (clause_index < num_clauses);
3099 jei->flags = orig_jei->flags;
3100 jei->data.catch_class = orig_jei->data.catch_class;
3101
3102 jei->try_start = ei [i].try_start;
3103 jei->try_end = ei [i].try_end;
3104 jei->handler_start = ei [i].handler_start;
3105 jei->clause_index = clause_index;
3106
3107 if (is_thumb_code (amodule, (guint8 *)jei->try_start)) {
3108 jei->try_start = (void*)((gsize)jei->try_start & ~1);
3109 jei->try_end = (void*)((gsize)jei->try_end & ~1);
3110 /* Make sure we transition to thumb when a handler starts */
3111 jei->handler_start = (void*)((gsize)jei->handler_start + 1);
3112 }
3113 }
3114
3115 /* See exception_cb () in mini-llvm.c as to why this is needed */
3116 nindex = ei_len;
3117 for (i = 0; i < ei_len; ++i) {
3118 gint32 cindex1 = read32 (type_info [i]);
3119 GSList *l;
3120
3121 for (l = nesting [cindex1]; l; l = l->next) {
3122 gint32 nesting_cindex = GPOINTER_TO_INT (l->data);
3123 MonoJitExceptionInfo *nesting_ei;
3124 MonoJitExceptionInfo *nesting_clause = &clauses [nesting_cindex];
3125
3126 nesting_ei = &jinfo->clauses [nindex];
3127 nindex ++;
3128
3129 memcpy (nesting_ei, &jinfo->clauses [i], sizeof (MonoJitExceptionInfo));
3130 nesting_ei->flags = nesting_clause->flags;
3131 nesting_ei->data.catch_class = nesting_clause->data.catch_class;
3132 nesting_ei->clause_index = nesting_cindex;
3133 }
3134 }
3135 g_assert (nindex == ei_len + nested_len);
3136 }
3137
3138 static gpointer
3139 alloc0_jit_info_data (MonoDomain *domain, int size, gboolean async_context)
3140
3141 #define alloc0_jit_info_data(domain, size, async_context) (g_cast (alloc0_jit_info_data ((domain), (size), (async_context))))
3142
3143 {
3144 gpointer res;
3145
3146 if (async_context) {
3147 res = mono_domain_alloc0_lock_free (domain, size);
3148 mono_atomic_fetch_add_i32 (&async_jit_info_size, size);
3149 } else {
3150 res = mono_domain_alloc0 (domain, size);
3151 }
3152 return res;
3153 }
3154
3155 /*
3156 * LOCKING: Acquires the domain lock.
3157 * In async context, this is async safe.
3158 */
3159 static MonoJitInfo*
3160 decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain,
3161 MonoMethod *method, guint8* ex_info,
3162 guint8 *code, guint32 code_len)
3163 {
3164 ERROR_DECL (error);
3165 int i, buf_len, num_clauses, len;
3166 MonoJitInfo *jinfo;
3167 MonoJitInfoFlags flags = JIT_INFO_NONE;
3168 guint unwind_info, eflags;
3169 gboolean has_generic_jit_info, has_dwarf_unwind_info, has_clauses, has_seq_points, has_try_block_holes, has_arch_eh_jit_info;
3170 gboolean from_llvm, has_gc_map;
3171 guint8 *p;
3172 int try_holes_info_size, num_holes;
3173 int this_reg = 0, this_offset = 0;
3174 gboolean async;
3175
3176 /* Load the method info from the AOT file */
3177 async = mono_thread_info_is_async_context ();
3178
3179 p = ex_info;
3180 eflags = decode_value (p, &p);
3181 has_generic_jit_info = (eflags & 1) != 0;
3182 has_dwarf_unwind_info = (eflags & 2) != 0;
3183 has_clauses = (eflags & 4) != 0;
3184 has_seq_points = (eflags & 8) != 0;
3185 from_llvm = (eflags & 16) != 0;
3186 has_try_block_holes = (eflags & 32) != 0;
3187 has_gc_map = (eflags & 64) != 0;
3188 has_arch_eh_jit_info = (eflags & 128) != 0;
3189
3190 if (has_dwarf_unwind_info) {
3191 unwind_info = decode_value (p, &p);
3192 g_assert (unwind_info < (1 << 30));
3193 } else {
3194 unwind_info = decode_value (p, &p);
3195 }
3196 if (has_generic_jit_info)
3197 flags |= JIT_INFO_HAS_GENERIC_JIT_INFO;
3198
3199 if (has_try_block_holes) {
3200 num_holes = decode_value (p, &p);
3201 flags |= JIT_INFO_HAS_TRY_BLOCK_HOLES;
3202 try_holes_info_size = sizeof (MonoTryBlockHoleTableJitInfo) + num_holes * sizeof (MonoTryBlockHoleJitInfo);
3203 } else {
3204 num_holes = try_holes_info_size = 0;
3205 }
3206
3207 if (has_arch_eh_jit_info) {
3208 flags |= JIT_INFO_HAS_ARCH_EH_INFO;
3209 /* Overwrite the original code_len which includes alignment padding */
3210 code_len = decode_value (p, &p);
3211 }
3212
3213 /* Exception table */
3214 if (has_clauses)
3215 num_clauses = decode_value (p, &p);
3216 else
3217 num_clauses = 0;
3218
3219 if (from_llvm) {
3220 MonoJitExceptionInfo *clauses;
3221 GSList **nesting;
3222
3223 /*
3224 * Part of the info is encoded by the AOT compiler, the rest is in the .eh_frame
3225 * section.
3226 */
3227 if (async) {
3228 if (num_clauses < 16) {
3229 clauses = g_newa (MonoJitExceptionInfo, num_clauses);
3230 nesting = g_newa (GSList*, num_clauses);
3231 } else {
3232 clauses = alloc0_jit_info_data (domain, sizeof (MonoJitExceptionInfo) * num_clauses, TRUE);
3233 nesting = alloc0_jit_info_data (domain, sizeof (GSList*) * num_clauses, TRUE);
3234 }
3235 memset (clauses, 0, sizeof (MonoJitExceptionInfo) * num_clauses);
3236 memset (nesting, 0, sizeof (GSList*) * num_clauses);
3237 } else {
3238 clauses = g_new0 (MonoJitExceptionInfo, num_clauses);
3239 nesting = g_new0 (GSList*, num_clauses);
3240 }
3241
3242 for (i = 0; i < num_clauses; ++i) {
3243 MonoJitExceptionInfo *ei = &clauses [i];
3244
3245 ei->flags = decode_value (p, &p);
3246
3247 if (!(ei->flags == MONO_EXCEPTION_CLAUSE_FILTER || ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
3248 int len = decode_value (p, &p);
3249
3250 if (len > 0) {
3251 if (async) {
3252 p += len;
3253 } else {
3254 ei->data.catch_class = decode_klass_ref (amodule, p, &p, error);
3255 mono_error_cleanup (error); /* FIXME don't swallow the error */
3256 }
3257 }
3258 }
3259
3260 ei->clause_index = i;
3261
3262 ei->try_offset = decode_value (p, &p);
3263 ei->try_len = decode_value (p, &p);
3264 ei->handler_offset = decode_value (p, &p);
3265 ei->handler_len = decode_value (p, &p);
3266
3267 /* Read the list of nesting clauses */
3268 while (TRUE) {
3269 int nesting_index = decode_value (p, &p);
3270 if (nesting_index == -1)
3271 break;
3272 // FIXME: async
3273 g_assert (!async);
3274 nesting [i] = g_slist_prepend (nesting [i], GINT_TO_POINTER (nesting_index));
3275 }
3276 }
3277
3278 flags |= JIT_INFO_HAS_UNWIND_INFO;
3279
3280 int num_llvm_clauses;
3281 /* Get the length first */
3282 decode_llvm_mono_eh_frame (amodule, domain, NULL, code, code_len, clauses, num_clauses, nesting, &this_reg, &this_offset, &num_llvm_clauses);
3283 len = mono_jit_info_size (flags, num_llvm_clauses, num_holes);
3284 jinfo = (MonoJitInfo *)alloc0_jit_info_data (domain, len, async);
3285 mono_jit_info_init (jinfo, method, code, code_len, flags, num_llvm_clauses, num_holes);
3286
3287 decode_llvm_mono_eh_frame (amodule, domain, jinfo, code, code_len, clauses, num_clauses, nesting, &this_reg, &this_offset, NULL);
3288
3289 if (!async) {
3290 g_free (clauses);
3291 for (i = 0; i < num_clauses; ++i)
3292 g_slist_free (nesting [i]);
3293 g_free (nesting);
3294 }
3295 jinfo->from_llvm = 1;
3296 } else {
3297 len = mono_jit_info_size (flags, num_clauses, num_holes);
3298 jinfo = (MonoJitInfo *)alloc0_jit_info_data (domain, len, async);
3299 mono_jit_info_init (jinfo, method, code, code_len, flags, num_clauses, num_holes);
3300
3301 for (i = 0; i < jinfo->num_clauses; ++i) {
3302 MonoJitExceptionInfo *ei = &jinfo->clauses [i];
3303
3304 ei->flags = decode_value (p, &p);
3305
3306 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
3307 /* Not used for catch clauses */
3308 if (ei->flags != MONO_EXCEPTION_CLAUSE_NONE)
3309 ei->exvar_offset = decode_value (p, &p);
3310 #else
3311 ei->exvar_offset = decode_value (p, &p);
3312 #endif
3313
3314 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER || ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)
3315 ei->data.filter = code + decode_value (p, &p);
3316 else {
3317 int len = decode_value (p, &p);
3318
3319 if (len > 0) {
3320 if (async) {
3321 p += len;
3322 } else {
3323 ei->data.catch_class = decode_klass_ref (amodule, p, &p, error);
3324 mono_error_cleanup (error); /* FIXME don't swallow the error */
3325 }
3326 }
3327 }
3328
3329 ei->try_start = code + decode_value (p, &p);
3330 ei->try_end = code + decode_value (p, &p);
3331 ei->handler_start = code + decode_value (p, &p);
3332 }
3333
3334 jinfo->unwind_info = unwind_info;
3335 jinfo->domain_neutral = 0;
3336 jinfo->from_aot = 1;
3337 }
3338
3339 if (has_try_block_holes) {
3340 MonoTryBlockHoleTableJitInfo *table;
3341
3342 g_assert (jinfo->has_try_block_holes);
3343
3344 table = mono_jit_info_get_try_block_hole_table_info (jinfo);
3345 g_assert (table);
3346
3347 table->num_holes = (guint16)num_holes;
3348 for (i = 0; i < num_holes; ++i) {
3349 MonoTryBlockHoleJitInfo *hole = &table->holes [i];
3350 hole->clause = decode_value (p, &p);
3351 hole->length = decode_value (p, &p);
3352 hole->offset = decode_value (p, &p);
3353 }
3354 }
3355
3356 if (has_arch_eh_jit_info) {
3357 MonoArchEHJitInfo *eh_info;
3358
3359 g_assert (jinfo->has_arch_eh_info);
3360
3361 eh_info = mono_jit_info_get_arch_eh_info (jinfo);
3362 eh_info->stack_size = decode_value (p, &p);
3363 eh_info->epilog_size = decode_value (p, &p);
3364 }
3365
3366 if (async) {
3367 /* The rest is not needed in async mode */
3368 jinfo->async = TRUE;
3369 jinfo->d.aot_info = amodule;
3370 // FIXME: Cache
3371 return jinfo;
3372 }
3373
3374 if (has_generic_jit_info) {
3375 MonoGenericJitInfo *gi;
3376 int len;
3377
3378 g_assert (jinfo->has_generic_jit_info);
3379
3380 gi = mono_jit_info_get_generic_jit_info (jinfo);
3381 g_assert (gi);
3382
3383 gi->nlocs = decode_value (p, &p);
3384 if (gi->nlocs) {
3385 gi->locations = (MonoDwarfLocListEntry *)alloc0_jit_info_data (domain, gi->nlocs * sizeof (MonoDwarfLocListEntry), async);
3386 for (i = 0; i < gi->nlocs; ++i) {
3387 MonoDwarfLocListEntry *entry = &gi->locations [i];
3388
3389 entry->is_reg = decode_value (p, &p);
3390 entry->reg = decode_value (p, &p);
3391 if (!entry->is_reg)
3392 entry->offset = decode_value (p, &p);
3393 if (i > 0)
3394 entry->from = decode_value (p, &p);
3395 entry->to = decode_value (p, &p);
3396 }
3397 gi->has_this = 1;
3398 } else {
3399 if (from_llvm) {
3400 gi->has_this = this_reg != -1;
3401 gi->this_reg = this_reg;
3402 gi->this_offset = this_offset;
3403 } else {
3404 gi->has_this = decode_value (p, &p);
3405 gi->this_reg = decode_value (p, &p);
3406 gi->this_offset = decode_value (p, &p);
3407 }
3408 }
3409
3410 len = decode_value (p, &p);
3411 if (async) {
3412 p += len;
3413 } else {
3414 jinfo->d.method = decode_resolve_method_ref (amodule, p, &p, error);
3415 mono_error_cleanup (error); /* FIXME don't swallow the error */
3416 }
3417
3418 gi->generic_sharing_context = alloc0_jit_info_data (domain, sizeof (MonoGenericSharingContext), async);
3419 if (decode_value (p, &p)) {
3420 /* gsharedvt */
3421 MonoGenericSharingContext *gsctx = gi->generic_sharing_context;
3422
3423 gsctx->is_gsharedvt = TRUE;
3424 }
3425 }
3426
3427 if (method && has_seq_points) {
3428 MonoSeqPointInfo *seq_points;
3429
3430 p += mono_seq_point_info_read (&seq_points, p, FALSE);
3431
3432 mono_domain_lock (domain);
3433 /* This could be set already since this function can be called more than once for the same method */
3434 if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, method))
3435 g_hash_table_insert (domain_jit_info (domain)->seq_points, method, seq_points);
3436 else
3437 mono_seq_point_info_free (seq_points);
3438 mono_domain_unlock (domain);
3439
3440 jinfo->seq_points = seq_points;
3441 }
3442
3443 /* Load debug info */
3444 buf_len = decode_value (p, &p);
3445 if (!async)
3446 mono_debug_add_aot_method (domain, method, code, p, buf_len);
3447 p += buf_len;
3448
3449 if (has_gc_map) {
3450 int map_size = decode_value (p, &p);
3451 /* The GC map requires 4 bytes of alignment */
3452 while ((guint64)(gsize)p % 4)
3453 p ++;
3454 jinfo->gc_info = p;
3455 p += map_size;
3456 }
3457
3458 if (amodule != m_class_get_image (jinfo->d.method->klass)->aot_module) {
3459 mono_aot_lock ();
3460 if (!ji_to_amodule)
3461 ji_to_amodule = g_hash_table_new (NULL, NULL);
3462 g_hash_table_insert (ji_to_amodule, jinfo, amodule);
3463 mono_aot_unlock ();
3464 }
3465
3466 return jinfo;
3467 }
3468
3469 static gboolean
3470 amodule_contains_code_addr (MonoAotModule *amodule, guint8 *code)
3471 {
3472 return (code >= amodule->jit_code_start && code <= amodule->jit_code_end) ||
3473 (code >= amodule->llvm_code_start && code <= amodule->llvm_code_end);
3474 }
3475
3476 /*
3477 * mono_aot_get_unwind_info:
3478 *
3479 * Return a pointer to the DWARF unwind info belonging to JI.
3480 */
3481 guint8*
3482 mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len)
3483 {
3484 MonoAotModule *amodule;
3485 guint8 *p;
3486 guint8 *code = (guint8 *)ji->code_start;
3487
3488 if (ji->async)
3489 amodule = ji->d.aot_info;
3490 else
3491 amodule = m_class_get_image (jinfo_get_method (ji)->klass)->aot_module;
3492 g_assert (amodule);
3493 g_assert (ji->from_aot);
3494
3495 if (!amodule_contains_code_addr (amodule, code)) {
3496 /* ji belongs to a different aot module than amodule */
3497 mono_aot_lock ();
3498 g_assert (ji_to_amodule);
3499 amodule = (MonoAotModule *)g_hash_table_lookup (ji_to_amodule, ji);
3500 g_assert (amodule);
3501 g_assert (amodule_contains_code_addr (amodule, code));
3502 mono_aot_unlock ();
3503 }
3504
3505 p = amodule->unwind_info + ji->unwind_info;
3506 *unwind_info_len = decode_value (p, &p);
3507 return p;
3508 }
3509
3510 static void
3511 msort_method_addresses_internal (gpointer *array, int *indexes, int lo, int hi, gpointer *scratch, int *scratch_indexes)
3512 {
3513 int mid = (lo + hi) / 2;
3514 int i, t_lo, t_hi;
3515
3516 if (lo >= hi)
3517 return;
3518
3519 if (hi - lo < 32) {
3520 for (i = lo; i < hi; ++i)
3521 if (array [i] > array [i + 1])
3522 break;
3523 if (i == hi)
3524 /* Already sorted */
3525 return;
3526 }
3527
3528 msort_method_addresses_internal (array, indexes, lo, mid, scratch, scratch_indexes);
3529 msort_method_addresses_internal (array, indexes, mid + 1, hi, scratch, scratch_indexes);
3530
3531 if (array [mid] < array [mid + 1])
3532 return;
3533
3534 /* Merge */
3535 t_lo = lo;
3536 t_hi = mid + 1;
3537 for (i = lo; i <= hi; i ++) {
3538 if (t_lo <= mid && ((t_hi > hi) || array [t_lo] < array [t_hi])) {
3539 scratch [i] = array [t_lo];
3540 scratch_indexes [i] = indexes [t_lo];
3541 t_lo ++;
3542 } else {
3543 scratch [i] = array [t_hi];
3544 scratch_indexes [i] = indexes [t_hi];
3545 t_hi ++;
3546 }
3547 }
3548 for (i = lo; i <= hi; ++i) {
3549 array [i] = scratch [i];
3550 indexes [i] = scratch_indexes [i];
3551 }
3552 }
3553
3554 static void
3555 msort_method_addresses (gpointer *array, int *indexes, int len)
3556 {
3557 gpointer *scratch;
3558 int *scratch_indexes;
3559
3560 scratch = g_new (gpointer, len);
3561 scratch_indexes = g_new (int, len);
3562 msort_method_addresses_internal (array, indexes, 0, len - 1, scratch, scratch_indexes);
3563 g_free (scratch);
3564 g_free (scratch_indexes);
3565 }
3566
3567 /*
3568 * mono_aot_find_jit_info:
3569 *
3570 * In async context, the resulting MonoJitInfo will not have its method field set, and it will not be added
3571 * to the jit info tables.
3572 * FIXME: Large sizes in the lock free allocator
3573 */
3574 MonoJitInfo *
3575 mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr)
3576 {
3577 ERROR_DECL (error);
3578 int pos, left, right, code_len;
3579 int method_index, table_len;
3580 guint32 token;
3581 MonoAotModule *amodule = image->aot_module;
3582 MonoMethod *method = NULL;
3583 MonoJitInfo *jinfo;
3584 guint8 *code, *ex_info, *p;
3585 guint32 *table;
3586 int nmethods;
3587 gpointer *methods;
3588 guint8 *code1, *code2;
3589 int methods_len, i;
3590 gboolean async;
3591
3592 if (!amodule)
3593 return NULL;
3594
3595 nmethods = amodule->info.nmethods;
3596
3597 if (domain != mono_get_root_domain ())
3598 /* FIXME: */
3599 return NULL;
3600
3601 if (!amodule_contains_code_addr (amodule, (guint8 *)addr))
3602 return NULL;
3603
3604 async = mono_thread_info_is_async_context ();
3605
3606 /* Compute a sorted table mapping code to method indexes. */
3607 if (!amodule->sorted_methods) {
3608 // FIXME: async
3609 gpointer *methods = g_new0 (gpointer, nmethods);
3610 int *method_indexes = g_new0 (int, nmethods);
3611 int methods_len = 0;
3612
3613 for (i = 0; i < nmethods; ++i) {
3614 /* Skip the -1 entries to speed up sorting */
3615 if (amodule->methods [i] == GINT_TO_POINTER (-1))
3616 continue;
3617 methods [methods_len] = amodule->methods [i];
3618 method_indexes [methods_len] = i;
3619 methods_len ++;
3620 }
3621 /* Use a merge sort as this is mostly sorted */
3622 msort_method_addresses (methods, method_indexes, methods_len);
3623 for (i = 0; i < methods_len -1; ++i)
3624 g_assert (methods [i] <= methods [i + 1]);
3625 amodule->sorted_methods_len = methods_len;
3626 if (mono_atomic_cas_ptr ((gpointer*)&amodule->sorted_methods, methods, NULL) != NULL)
3627 /* Somebody got in before us */
3628 g_free (methods);
3629 if (mono_atomic_cas_ptr ((gpointer*)&amodule->sorted_method_indexes, method_indexes, NULL) != NULL)
3630 /* Somebody got in before us */
3631 g_free (method_indexes);
3632 }
3633
3634 /* Binary search in the sorted_methods table */
3635 methods = amodule->sorted_methods;
3636 methods_len = amodule->sorted_methods_len;
3637 code = (guint8 *)addr;
3638 left = 0;
3639 right = methods_len;
3640 while (TRUE) {
3641 pos = (left + right) / 2;
3642
3643 code1 = (guint8 *)methods [pos];
3644 if (pos + 1 == methods_len) {
3645 if (code1 >= amodule->jit_code_start && code1 < amodule->jit_code_end)
3646 code2 = amodule->jit_code_end;
3647 else
3648 code2 = amodule->llvm_code_end;
3649 } else {
3650 code2 = (guint8 *)methods [pos + 1];
3651 }
3652
3653 if (code < code1)
3654 right = pos;
3655 else if (code >= code2)
3656 left = pos + 1;
3657 else
3658 break;
3659 }
3660
3661 g_assert (addr >= methods [pos]);
3662 if (pos + 1 < methods_len)
3663 g_assert (addr < methods [pos + 1]);
3664 method_index = amodule->sorted_method_indexes [pos];
3665
3666 /* In async mode, jinfo is not added to the normal jit info table, so have to cache it ourselves */
3667 if (async) {
3668 JitInfoMap *table = amodule->async_jit_info_table;
3669 int len;
3670
3671 if (table) {
3672 len = table [0].method_index;
3673 for (i = 1; i < len; ++i) {
3674 if (table [i].method_index == method_index)
3675 return table [i].jinfo;
3676 }
3677 }
3678 }
3679
3680 code = (guint8 *)amodule->methods [method_index];
3681 ex_info = &amodule->blob [mono_aot_get_offset (amodule->ex_info_offsets, method_index)];
3682
3683 if (pos == methods_len - 1) {
3684 if (code >= amodule->jit_code_start && code < amodule->jit_code_end)
3685 code_len = amodule->jit_code_end - code;
3686 else
3687 code_len = amodule->llvm_code_end - code;
3688 } else {
3689 code_len = (guint8*)methods [pos + 1] - (guint8*)methods [pos];
3690 }
3691
3692 g_assert ((guint8*)code <= (guint8*)addr && (guint8*)addr < (guint8*)code + code_len);
3693
3694 /* Might be a wrapper/extra method */
3695 if (!async) {
3696 if (amodule->extra_methods) {
3697 amodule_lock (amodule);
3698 method = (MonoMethod *)g_hash_table_lookup (amodule->extra_methods, GUINT_TO_POINTER (method_index));
3699 amodule_unlock (amodule);
3700 } else {
3701 method = NULL;
3702 }
3703
3704 if (!method) {
3705 if (method_index >= image->tables [MONO_TABLE_METHOD].rows) {
3706 /*
3707 * This is hit for extra methods which are called directly, so they are
3708 * not in amodule->extra_methods.
3709 */
3710 table_len = amodule->extra_method_info_offsets [0];
3711 table = amodule->extra_method_info_offsets + 1;
3712 left = 0;
3713 right = table_len;
3714 pos = 0;
3715
3716 /* Binary search */
3717 while (TRUE) {
3718 pos = ((left + right) / 2);
3719
3720 g_assert (pos < table_len);
3721
3722 if (table [pos * 2] < method_index)
3723 left = pos + 1;
3724 else if (table [pos * 2] > method_index)
3725 right = pos;
3726 else
3727 break;
3728 }
3729
3730 p = amodule->blob + table [(pos * 2) + 1];
3731 method = decode_resolve_method_ref (amodule, p, &p, error);
3732 mono_error_cleanup (error); /* FIXME don't swallow the error */
3733 if (!method)
3734 /* Happens when a random address is passed in which matches a not-yey called wrapper encoded using its name */
3735 return NULL;
3736 } else {
3737 ERROR_DECL (error);
3738 token = mono_metadata_make_token (MONO_TABLE_METHOD, method_index + 1);
3739 method = mono_get_method_checked (image, token, NULL, NULL, error);
3740 if (!method)
3741 g_error ("AOT runtime could not load method due to %s", mono_error_get_message (error)); /* FIXME don't swallow the error */
3742 }
3743 }
3744 /* FIXME: */
3745 g_assert (method);
3746 }
3747
3748 //printf ("F: %s\n", mono_method_full_name (method, TRUE));
3749
3750 jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, code, code_len);
3751
3752 g_assert ((guint8*)addr >= (guint8*)jinfo->code_start);
3753
3754 /* Add it to the normal JitInfo tables */
3755 if (async) {
3756 JitInfoMap *old_table, *new_table;
3757 int len;
3758
3759 /*
3760 * Use a simple inmutable table with linear search to cache async jit info entries.
3761 * This assumes that the number of entries is small.
3762 */
3763 while (TRUE) {
3764 /* Copy the table, adding a new entry at the end */
3765 old_table = amodule->async_jit_info_table;
3766 if (old_table)
3767 len = old_table[0].method_index;
3768 else
3769 len = 1;
3770 new_table = (JitInfoMap *)alloc0_jit_info_data (domain, (len + 1) * sizeof (JitInfoMap), async);
3771 if (old_table)
3772 memcpy (new_table, old_table, len * sizeof (JitInfoMap));
3773 new_table [0].method_index = len + 1;
3774 new_table [len].method_index = method_index;
3775 new_table [len].jinfo = jinfo;
3776 /* Publish it */
3777 mono_memory_barrier ();
3778 if (mono_atomic_cas_ptr ((volatile gpointer *)&amodule->async_jit_info_table, new_table, old_table) == old_table)
3779 break;
3780 }
3781 } else {
3782 mono_jit_info_table_add (domain, jinfo);
3783 }
3784
3785 if ((guint8*)addr >= (guint8*)jinfo->code_start + jinfo->code_size)
3786 /* addr is in the padding between methods, see the adjustment of code_size in decode_exception_debug_info () */
3787 return NULL;
3788
3789 return jinfo;
3790 }
3791
3792 static gboolean
3793 decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guint8 *buf, guint8 **endbuf)
3794 {
3795 ERROR_DECL (error);
3796 guint8 *p = buf;
3797 gpointer *table;
3798 MonoImage *image;
3799 int i;
3800
3801 switch (ji->type) {
3802 case MONO_PATCH_INFO_METHOD:
3803 case MONO_PATCH_INFO_METHOD_JUMP:
3804 case MONO_PATCH_INFO_METHOD_FTNDESC:
3805 case MONO_PATCH_INFO_ICALL_ADDR:
3806 case MONO_PATCH_INFO_ICALL_ADDR_CALL:
3807 case MONO_PATCH_INFO_METHOD_RGCTX:
3808 case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
3809 MethodRef ref;
3810 gboolean res;
3811
3812 res = decode_method_ref (aot_module, &ref, p, &p, error);
3813 mono_error_assert_ok (error); /* FIXME don't swallow the error */
3814 if (!res)
3815 goto cleanup;
3816
3817 if (!ref.method && !mono_aot_only && !ref.no_aot_trampoline && (ji->type == MONO_PATCH_INFO_METHOD) && (mono_metadata_token_table (ref.token) == MONO_TABLE_METHOD)) {
3818 ji->data.target = mono_create_ftnptr (mono_domain_get (), mono_create_jit_trampoline_from_token (ref.image, ref.token));
3819 ji->type = MONO_PATCH_INFO_ABS;
3820 }
3821 else {
3822 if (ref.method) {
3823 ji->data.method = ref.method;
3824 }else {
3825 ERROR_DECL (error);
3826 ji->data.method = mono_get_method_checked (ref.image, ref.token, NULL, NULL, error);
3827 if (!ji->data.method)
3828 g_error ("AOT Runtime could not load method due to %s", mono_error_get_message (error)); /* FIXME don't swallow the error */
3829 }
3830 g_assert (ji->data.method);
3831 mono_class_init_internal (ji->data.method->klass);
3832 }
3833 break;
3834 }
3835 case MONO_PATCH_INFO_LDSTR_LIT:
3836 {
3837 guint32 len = decode_value (p, &p);
3838
3839 ji->data.name = (char*)p;
3840 p += len + 1;
3841 break;
3842 }
3843 case MONO_PATCH_INFO_METHODCONST:
3844 /* Shared */
3845 ji->data.method = decode_resolve_method_ref (aot_module, p, &p, error);
3846 mono_error_cleanup (error); /* FIXME don't swallow the error */
3847 if (!ji->data.method)
3848 goto cleanup;
3849 break;
3850 case MONO_PATCH_INFO_VTABLE:
3851 case MONO_PATCH_INFO_CLASS:
3852 case MONO_PATCH_INFO_IID:
3853 case MONO_PATCH_INFO_ADJUSTED_IID:
3854 /* Shared */
3855 ji->data.klass = decode_klass_ref (aot_module, p, &p, error);
3856 mono_error_cleanup (error); /* FIXME don't swallow the error */
3857 if (!ji->data.klass)
3858 goto cleanup;
3859 break;
3860 case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
3861 ji->data.del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (mp, sizeof (MonoDelegateClassMethodPair));
3862 ji->data.del_tramp->klass = decode_klass_ref (aot_module, p, &p, error);
3863 mono_error_cleanup (error); /* FIXME don't swallow the error */
3864 if (!ji->data.del_tramp->klass)
3865 goto cleanup;
3866 if (decode_value (p, &p)) {
3867 ji->data.del_tramp->method = decode_resolve_method_ref (aot_module, p, &p, error);
3868 mono_error_cleanup (error); /* FIXME don't swallow the error */
3869 if (!ji->data.del_tramp->method)
3870 goto cleanup;
3871 }
3872 ji->data.del_tramp->is_virtual = decode_value (p, &p) ? TRUE : FALSE;
3873 break;
3874 case MONO_PATCH_INFO_IMAGE:
3875 ji->data.image = load_image (aot_module, decode_value (p, &p), error);
3876 mono_error_cleanup (error); /* FIXME don't swallow the error */
3877 if (!ji->data.image)
3878 goto cleanup;
3879 break;
3880 case MONO_PATCH_INFO_FIELD:
3881 case MONO_PATCH_INFO_SFLDA:
3882 /* Shared */
3883 ji->data.field = decode_field_info (aot_module, p, &p);
3884 if (!ji->data.field)
3885 goto cleanup;
3886 break;
3887 case MONO_PATCH_INFO_SWITCH:
3888 ji->data.table = (MonoJumpInfoBBTable *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoBBTable));
3889 ji->data.table->table_size = decode_value (p, &p);
3890 table = (void **)mono_domain_alloc (mono_domain_get (), sizeof (gpointer) * ji->data.table->table_size);
3891 ji->data.table->table = (MonoBasicBlock**)table;
3892 for (i = 0; i < ji->data.table->table_size; i++)
3893 table [i] = (gpointer)(gssize)decode_value (p, &p);
3894 break;
3895 case MONO_PATCH_INFO_R4: {
3896 guint32 val;
3897
3898 ji->data.target = mono_domain_alloc0 (mono_domain_get (), sizeof (float));
3899 val = decode_value (p, &p);
3900 *(float*)ji->data.target = *(float*)&val;
3901 break;
3902 }
3903 case MONO_PATCH_INFO_R8: {
3904 guint32 val [2];
3905 guint64 v;
3906
3907 ji->data.target = mono_domain_alloc0 (mono_domain_get (), sizeof (double));
3908
3909 val [0] = decode_value (p, &p);
3910 val [1] = decode_value (p, &p);
3911 v = ((guint64)val [1] << 32) | ((guint64)val [0]);
3912 *(double*)ji->data.target = *(double*)&v;
3913 break;
3914 }
3915 case MONO_PATCH_INFO_LDSTR:
3916 image = load_image (aot_module, decode_value (p, &p), error);
3917 mono_error_cleanup (error); /* FIXME don't swallow the error */
3918 if (!image)
3919 goto cleanup;
3920 ji->data.token = mono_jump_info_token_new (mp, image, MONO_TOKEN_STRING + decode_value (p, &p));
3921 break;
3922 case MONO_PATCH_INFO_RVA:
3923 case MONO_PATCH_INFO_DECLSEC:
3924 case MONO_PATCH_INFO_LDTOKEN:
3925 case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
3926 /* Shared */
3927 image = load_image (aot_module, decode_value (p, &p), error);
3928 mono_error_cleanup (error); /* FIXME don't swallow the error */
3929 if (!image)
3930 goto cleanup;
3931 ji->data.token = mono_jump_info_token_new (mp, image, decode_value (p, &p));
3932
3933 ji->data.token->has_context = decode_value (p, &p);
3934 if (ji->data.token->has_context) {
3935 gboolean res = decode_generic_context (aot_module, &ji->data.token->context, p, &p, error);
3936 mono_error_cleanup (error); /* FIXME don't swallow the error */
3937 if (!res)
3938 goto cleanup;
3939 }
3940 break;
3941 case MONO_PATCH_INFO_EXC_NAME:
3942 ji->data.klass = decode_klass_ref (aot_module, p, &p, error);
3943 mono_error_cleanup (error); /* FIXME don't swallow the error */
3944 if (!ji->data.klass)
3945 goto cleanup;
3946 ji->data.name = m_class_get_name (ji->data.klass);
3947 break;
3948 case MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG:
3949 case MONO_PATCH_INFO_GC_CARD_TABLE_ADDR:
3950 case MONO_PATCH_INFO_GC_NURSERY_START:
3951 case MONO_PATCH_INFO_GC_NURSERY_BITS:
3952 case MONO_PATCH_INFO_PROFILER_ALLOCATION_COUNT:
3953 case MONO_PATCH_INFO_PROFILER_CLAUSE_COUNT:
3954 break;
3955 case MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR:
3956 ji->data.uindex = decode_value (p, &p);
3957 break;
3958 case MONO_PATCH_INFO_CASTCLASS_CACHE:
3959 ji->data.index = decode_value (p, &p);
3960 break;
3961 case MONO_PATCH_INFO_JIT_ICALL_ID:
3962 case MONO_PATCH_INFO_JIT_ICALL_ADDR:
3963 case MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL:
3964 ji->data.jit_icall_id = (MonoJitICallId)decode_value (p, &p);
3965 break;
3966 case MONO_PATCH_INFO_RGCTX_FETCH:
3967 case MONO_PATCH_INFO_RGCTX_SLOT_INDEX: {
3968 gboolean res;
3969 MonoJumpInfoRgctxEntry *entry;
3970 guint32 offset, val;
3971 guint8 *p2;
3972
3973 offset = decode_value (p, &p);
3974 val = decode_value (p, &p);
3975
3976 entry = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
3977 p2 = aot_module->blob + offset;
3978 entry->in_mrgctx = ((val & 1) > 0) ? TRUE : FALSE;
3979 if (entry->in_mrgctx)
3980 entry->d.method = decode_resolve_method_ref (aot_module, p2, &p2, error);
3981 else
3982 entry->d.klass = decode_klass_ref (aot_module, p2, &p2, error);
3983 entry->info_type = (MonoRgctxInfoType)((val >> 1) & 0xff);
3984 entry->data = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
3985 entry->data->type = (MonoJumpInfoType)((val >> 9) & 0xff);
3986 mono_error_cleanup (error); /* FIXME don't swallow the error */
3987
3988 res = decode_patch (aot_module, mp, entry->data, p, &p);
3989 if (!res)
3990 goto cleanup;
3991 ji->data.rgctx_entry = entry;
3992 break;
3993 }
3994 case MONO_PATCH_INFO_SEQ_POINT_INFO:
3995 case MONO_PATCH_INFO_AOT_MODULE:
3996 case MONO_PATCH_INFO_MSCORLIB_GOT_ADDR:
3997 break;
3998 case MONO_PATCH_INFO_SIGNATURE:
3999 case MONO_PATCH_INFO_GSHAREDVT_IN_WRAPPER:
4000 ji->data.target = decode_signature (aot_module, p, &p);
4001 break;
4002 case MONO_PATCH_INFO_GSHAREDVT_CALL: {
4003 MonoJumpInfoGSharedVtCall *info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoGSharedVtCall));
4004 info->sig = decode_signature (aot_module, p, &p);
4005 g_assert (info->sig);
4006 info->method = decode_resolve_method_ref (aot_module, p, &p, error);
4007 mono_error_assert_ok (error); /* FIXME don't swallow the error */
4008
4009 ji->data.target = info;
4010 break;
4011 }
4012 case MONO_PATCH_INFO_GSHAREDVT_METHOD: {
4013 MonoGSharedVtMethodInfo *info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (mp, sizeof (MonoGSharedVtMethodInfo));
4014 int i;
4015
4016 info->method = decode_resolve_method_ref (aot_module, p, &p, error);
4017 mono_error_assert_ok (error); /* FIXME don't swallow the error */
4018
4019 info->num_entries = decode_value (p, &p);
4020 info->count_entries = info->num_entries;
4021 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (mp, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->num_entries);
4022 for (i = 0; i < info->num_entries; ++i) {
4023 MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
4024
4025 template_->info_type = (MonoRgctxInfoType)decode_value (p, &p);
4026 switch (mini_rgctx_info_type_to_patch_info_type (template_->info_type)) {
4027 case MONO_PATCH_INFO_CLASS: {
4028 MonoClass *klass = decode_klass_ref (aot_module, p, &p, error);
4029 mono_error_cleanup (error); /* FIXME don't swallow the error */
4030 if (!klass)
4031 goto cleanup;
4032 template_->data = m_class_get_byval_arg (klass);
4033 break;
4034 }
4035 case MONO_PATCH_INFO_FIELD:
4036 template_->data = decode_field_info (aot_module, p, &p);
4037 if (!template_->data)
4038 goto cleanup;
4039 break;
4040 default:
4041 g_assert_not_reached ();
4042 break;
4043 }
4044 }
4045 ji->data.target = info;
4046 break;
4047 }
4048 case MONO_PATCH_INFO_VIRT_METHOD: {
4049 MonoJumpInfoVirtMethod *info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoVirtMethod));
4050
4051 info->klass = decode_klass_ref (aot_module, p, &p, error);
4052 mono_error_assert_ok (error); /* FIXME don't swallow the error */
4053
4054 info->method = decode_resolve_method_ref (aot_module, p, &p, error);
4055 mono_error_assert_ok (error); /* FIXME don't swallow the error */
4056
4057 ji->data.target = info;
4058 break;
4059 }
4060 case MONO_PATCH_INFO_GC_SAFE_POINT_FLAG:
4061 break;
4062 case MONO_PATCH_INFO_AOT_JIT_INFO:
4063 ji->data.index = decode_value (p, &p);
4064 break;
4065 default:
4066 g_error ("unhandled type %d", ji->type);
4067 break;
4068 }
4069
4070 *endbuf = p;
4071
4072 return TRUE;
4073
4074 cleanup:
4075 return FALSE;
4076 }
4077
4078 /*
4079 * decode_patches:
4080 *
4081 * Decode a list of patches identified by the got offsets in GOT_OFFSETS. Return an array of
4082 * MonoJumpInfo structures allocated from MP. GOT entries already loaded have their
4083 * ji->type set to MONO_PATCH_INFO_NONE.
4084 */
4085 static MonoJumpInfo*
4086 decode_patches (MonoAotModule *amodule, MonoMemPool *mp, int n_patches, gboolean llvm, guint32 *got_offsets)
4087 {
4088 MonoJumpInfo *patches;
4089 MonoJumpInfo *ji;
4090 gpointer *got;
4091 guint32 *got_info_offsets;
4092 int i;
4093 gboolean res;
4094
4095 if (llvm) {
4096 got = amodule->llvm_got;
4097 got_info_offsets = (guint32 *)amodule->llvm_got_info_offsets;
4098 } else {
4099 got = amodule->got;
4100 got_info_offsets = (guint32 *)amodule->got_info_offsets;
4101 }
4102
4103 patches = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo) * n_patches);
4104 for (i = 0; i < n_patches; ++i) {
4105 guint8 *p = amodule->blob + mono_aot_get_offset (got_info_offsets, got_offsets [i]);
4106
4107 ji = &patches [i];
4108 ji->type = (MonoJumpInfoType)decode_value (p, &p);
4109
4110 /* See load_method () for SFLDA */
4111 if (got && got [got_offsets [i]] && ji->type != MONO_PATCH_INFO_SFLDA) {
4112 /* Already loaded */
4113 ji->type = MONO_PATCH_INFO_NONE;
4114 } else {
4115 res = decode_patch (amodule, mp, ji, p, &p);
4116 if (!res)
4117 return NULL;
4118 }
4119 }
4120
4121 return patches;
4122 }
4123
4124 static MonoJumpInfo*
4125 load_patch_info (MonoAotModule *amodule, MonoMemPool *mp, int n_patches,
4126 gboolean llvm, guint32 **got_slots,
4127 guint8 *buf, guint8 **endbuf)
4128 {
4129 MonoJumpInfo *patches;
4130 int pindex;
4131 guint8 *p;
4132
4133 p = buf;
4134
4135 *got_slots = (guint32 *)g_malloc (sizeof (guint32) * n_patches);
4136 for (pindex = 0; pindex < n_patches; ++pindex) {
4137 (*got_slots)[pindex] = decode_value (p, &p);
4138 }
4139
4140 patches = decode_patches (amodule, mp, n_patches, llvm, *got_slots);
4141 if (!patches) {
4142 g_free (*got_slots);
4143 *got_slots = NULL;
4144 return NULL;
4145 }
4146
4147 *endbuf = p;
4148 return patches;
4149 }
4150
4151 static void
4152 register_jump_target_got_slot (MonoDomain *domain, MonoMethod *method, gpointer *got_slot)
4153 {
4154 /*
4155 * Jump addresses cannot be patched by the trampoline code since it
4156 * does not have access to the caller's address. Instead, we collect
4157 * the addresses of the GOT slots pointing to a method, and patch
4158 * them after the method has been compiled.
4159 */
4160 MonoJitDomainInfo *info = domain_jit_info (domain);
4161 GSList *list;
4162 MonoMethod *shared_method = mini_method_to_shared (method);
4163 method = shared_method ? shared_method : method;
4164
4165 mono_domain_lock (domain);
4166 if (!info->jump_target_got_slot_hash)
4167 info->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL);
4168 list = (GSList *)g_hash_table_lookup (info->jump_target_got_slot_hash, method);
4169 list = g_slist_prepend (list, got_slot);
4170 g_hash_table_insert (info->jump_target_got_slot_hash, method, list);
4171 mono_domain_unlock (domain);
4172 }
4173
4174 /*
4175 * load_method:
4176 *
4177 * Load the method identified by METHOD_INDEX from the AOT image. Return a
4178 * pointer to the native code of the method, or NULL if not found.
4179 * METHOD might not be set if the caller only has the image/token info.
4180 */
4181 static gpointer
4182 load_method (MonoDomain *domain, MonoAotModule *amodule, MonoImage *image, MonoMethod *method, guint32 token, int method_index,
4183 MonoError *error)
4184 {
4185 MonoJitInfo *jinfo = NULL;
4186 guint8 *code = NULL, *info;
4187 gboolean res;
4188
4189 error_init (error);
4190
4191 init_amodule_got (amodule, FALSE);
4192
4193 if (domain != mono_get_root_domain ())
4194 /* Non shared AOT code can't be used in other appdomains */
4195 return NULL;
4196
4197 if (amodule->out_of_date)
4198 return NULL;
4199
4200 if (amodule->info.llvm_get_method) {
4201 /*
4202 * Obtain the method address by calling a generated function in the LLVM module.
4203 */
4204 gpointer (*get_method) (int) = (gpointer (*)(int))amodule->info.llvm_get_method;
4205 code = (guint8 *)get_method (method_index);
4206 }
4207
4208 if (!code) {
4209 if (method_index < amodule->info.nmethods)
4210 code = (guint8 *)amodule->methods [method_index];
4211 else
4212 return NULL;
4213
4214 /* JITted method */
4215 if (amodule->methods [method_index] == GINT_TO_POINTER (-1)) {
4216 if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) {
4217 char *full_name;
4218
4219 if (!method) {
4220 method = mono_get_method_checked (image, token, NULL, NULL, error);
4221 if (!method)
4222 return NULL;
4223 }
4224 if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) {
4225 full_name = mono_method_full_name (method, TRUE);
4226 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: NOT FOUND: %s.", full_name);
4227 g_free (full_name);
4228 }
4229 }
4230 return NULL;
4231 }
4232 }
4233
4234 info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
4235
4236 if (!amodule->methods_loaded) {
4237 amodule_lock (amodule);
4238 if (!amodule->methods_loaded) {
4239 guint32 *loaded;
4240
4241 loaded = g_new0 (guint32, amodule->info.nmethods / 32 + 1);
4242 mono_memory_barrier ();
4243 amodule->methods_loaded = loaded;
4244 }
4245 amodule_unlock (amodule);
4246 }
4247
4248 if ((amodule->methods_loaded [method_index / 32] >> (method_index % 32)) & 0x1)
4249 return code;
4250
4251 if (mini_debug_options.aot_skip_set && !(method && method->wrapper_type)) {
4252 gint32 methods_aot = mono_atomic_load_i32 (&mono_jit_stats.methods_aot);
4253 methods_aot += mono_atomic_load_i32 (&mono_jit_stats.methods_aot_llvm);
4254 if (methods_aot == mini_debug_options.aot_skip) {
4255 if (!method) {
4256 method = mono_get_method_checked (image, token, NULL, NULL, error);
4257 if (!method)
4258 return NULL;
4259 }
4260 if (method) {
4261 char *name = mono_method_full_name (method, TRUE);
4262 g_print ("NON AOT METHOD: %s.\n", name);
4263 g_free (name);
4264 } else {
4265 g_print ("NON AOT METHOD: %p %d\n", code, method_index);
4266 }
4267 mini_debug_options.aot_skip_set = FALSE;
4268 return NULL;
4269 }
4270 }
4271
4272 if (mono_last_aot_method != -1) {
4273 gint32 methods_aot = mono_atomic_load_i32 (&mono_jit_stats.methods_aot);
4274 methods_aot += mono_atomic_load_i32 (&mono_jit_stats.methods_aot_llvm);
4275 if (methods_aot >= mono_last_aot_method)
4276 return NULL;
4277 else if (methods_aot == mono_last_aot_method - 1) {
4278 if (!method) {
4279 method = mono_get_method_checked (image, token, NULL, NULL, error);
4280 if (!method)
4281 return NULL;
4282 }
4283 if (method) {
4284 char *name = mono_method_full_name (method, TRUE);
4285 g_print ("LAST AOT METHOD: %s.\n", name);
4286 g_free (name);
4287 } else {
4288 g_print ("LAST AOT METHOD: %p %d\n", code, method_index);
4289 }
4290 }
4291 }
4292
4293 if (!(is_llvm_code (amodule, code) && (amodule->info.flags & MONO_AOT_FILE_FLAG_LLVM_ONLY)) ||
4294 (mono_llvm_only && method && method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)) {
4295 res = init_method (amodule, method_index, method, NULL, error);
4296 if (!res)
4297 goto cleanup;
4298 }
4299
4300 if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) {
4301 char *full_name;
4302
4303 if (!method) {
4304 method = mono_get_method_checked (image, token, NULL, NULL, error);
4305 if (!method)
4306 return NULL;
4307 }
4308
4309 full_name = mono_method_full_name (method, TRUE);
4310
4311 if (!jinfo)
4312 jinfo = mono_aot_find_jit_info (domain, amodule->assembly->image, code);
4313
4314 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: FOUND method %s [%p - %p %p]", full_name, code, code + jinfo->code_size, info);
4315 g_free (full_name);
4316 }
4317
4318 if (mono_llvm_only) {
4319 guint8 *info, *p;
4320
4321 info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
4322 p = info;
4323 guint8 flags = decode_value (p, &p);
4324 /* The caller needs to looks this up, but its hard to do without constructing the full MonoJitInfo, so save it here */
4325 if (flags & MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE) {
4326 mono_aot_lock ();
4327 if (!code_to_method_flags)
4328 code_to_method_flags = g_hash_table_new (NULL, NULL);
4329 g_hash_table_insert (code_to_method_flags, code, GUINT_TO_POINTER (flags));
4330 mono_aot_unlock ();
4331 }
4332 }
4333
4334 init_plt (amodule);
4335
4336 amodule_lock (amodule);
4337
4338 if (is_llvm_code (amodule, code))
4339 mono_atomic_inc_i32 (&mono_jit_stats.methods_aot_llvm);
4340 else
4341 mono_atomic_inc_i32 (&mono_jit_stats.methods_aot);
4342
4343 if (method && method->wrapper_type)
4344 g_hash_table_insert (amodule->method_to_code, method, code);
4345
4346 /* Commit changes since methods_loaded is accessed outside the lock */
4347 mono_memory_barrier ();
4348
4349 amodule->methods_loaded [method_index / 32] |= 1 << (method_index % 32);
4350
4351 amodule_unlock (amodule);
4352
4353 if (MONO_PROFILER_ENABLED (jit_begin) || MONO_PROFILER_ENABLED (jit_done)) {
4354 MonoJitInfo *jinfo;
4355
4356 if (!method) {
4357 method = mono_get_method_checked (amodule->assembly->image, token, NULL, NULL, error);
4358 if (!method)
4359 return NULL;
4360 }
4361 MONO_PROFILER_RAISE (jit_begin, (method));
4362 jinfo = mono_jit_info_table_find (domain, code);
4363 g_assert (jinfo);
4364 MONO_PROFILER_RAISE (jit_done, (method, jinfo));
4365 }
4366
4367 return code;
4368
4369 cleanup:
4370 if (jinfo)
4371 g_free (jinfo);
4372
4373 return NULL;
4374 }
4375
4376 /** find_aot_method_in_amodule
4377 *
4378 * \param code_amodule The AOT module containing the code pointer
4379 * \param method The method to find the code index for
4380 * \param hash_full The hash for the method
4381 */
4382 static guint32
4383 find_aot_method_in_amodule (MonoAotModule *code_amodule, MonoMethod *method, guint32 hash_full)
4384 {
4385 ERROR_DECL (error);
4386 guint32 table_size, entry_size, hash;
4387 guint32 *table, *entry;
4388 guint32 index;
4389 static guint32 n_extra_decodes;
4390
4391 // The AOT module containing the MonoMethod
4392 // The reference to the metadata amodule will differ among multiple dedup methods
4393 // which mangle to the same name but live in different assemblies. This leads to
4394 // the caching breaking. The solution seems to be to cache using the "metadata" amodule.
4395 MonoAotModule *metadata_amodule = m_class_get_image (method->klass)->aot_module;
4396
4397 if (!metadata_amodule || metadata_amodule->out_of_date || !code_amodule || code_amodule->out_of_date)
4398 return 0xffffff;
4399
4400 table_size = code_amodule->extra_method_table [0];
4401 hash = hash_full % table_size;
4402 table = code_amodule->extra_method_table + 1;
4403 entry_size = 3;
4404
4405 entry = &table [hash * entry_size];
4406
4407 if (entry [0] == 0)
4408 return 0xffffff;
4409
4410 index = 0xffffff;
4411 while (TRUE) {
4412 guint32 key = entry [0];
4413 guint32 value = entry [1];
4414 guint32 next = entry [entry_size - 1];
4415 MonoMethod *m;
4416 guint8 *p, *orig_p;
4417
4418 p = code_amodule->blob + key;
4419 orig_p = p;
4420
4421 amodule_lock (metadata_amodule);
4422 if (!metadata_amodule->method_ref_to_method)
4423 metadata_amodule->method_ref_to_method = g_hash_table_new (NULL, NULL);
4424 m = (MonoMethod *)g_hash_table_lookup (metadata_amodule->method_ref_to_method, p);
4425 amodule_unlock (metadata_amodule);
4426 if (!m) {
4427 m = decode_resolve_method_ref_with_target (code_amodule, method, p, &p, error);
4428 mono_error_cleanup (error); /* FIXME don't swallow the error */
4429 /*
4430 * Can't catche runtime invoke wrappers since it would break
4431 * the check in decode_method_ref_with_target ().
4432 */
4433 if (m && m->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
4434 amodule_lock (metadata_amodule);
4435 g_hash_table_insert (metadata_amodule->method_ref_to_method, orig_p, m);
4436 amodule_unlock (metadata_amodule);
4437 }
4438 }
4439 if (m == method) {
4440 index = value;
4441 break;
4442 }
4443
4444 /* Methods decoded needlessly */
4445 if (m) {
4446 //printf ("%d %s %s %p\n", n_extra_decodes, mono_method_full_name (method, TRUE), mono_method_full_name (m, TRUE), orig_p);
4447 n_extra_decodes ++;
4448 }
4449
4450 if (next != 0)
4451 entry = &table [next * entry_size];
4452 else
4453 break;
4454 }
4455
4456 if (index != 0xffffff)
4457 g_assert (index < code_amodule->info.nmethods);
4458
4459 return index;
4460 }
4461
4462 static void
4463 add_module_cb (gpointer key, gpointer value, gpointer user_data)
4464 {
4465 g_ptr_array_add ((GPtrArray*)user_data, value);
4466 }
4467
4468 gboolean
4469 mono_aot_can_dedup (MonoMethod *method)
4470 {
4471 #ifdef TARGET_WASM
4472 /* Use a set of wrappers/instances which work and useful */
4473 switch (method->wrapper_type) {
4474 case MONO_WRAPPER_RUNTIME_INVOKE:
4475 return TRUE;
4476 break;
4477 case MONO_WRAPPER_OTHER: {
4478 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
4479
4480 if (info->subtype == WRAPPER_SUBTYPE_PTR_TO_STRUCTURE ||
4481 info->subtype == WRAPPER_SUBTYPE_STRUCTURE_TO_PTR ||
4482 info->subtype == WRAPPER_SUBTYPE_INTERP_LMF ||
4483 info->subtype == WRAPPER_SUBTYPE_AOT_INIT)
4484 return FALSE;
4485 return TRUE;
4486 }
4487 default:
4488 break;
4489 }
4490
4491 if (method->is_inflated && !mono_method_is_generic_sharable_full (method, TRUE, FALSE, FALSE) &&
4492 !mini_is_gsharedvt_signature (mono_method_signature_internal (method)) &&
4493 !mini_is_gsharedvt_klass (method->klass))
4494 return TRUE;
4495
4496 return FALSE;
4497 #else
4498 gboolean not_normal_gshared = method->is_inflated && !mono_method_is_generic_sharable_full (method, TRUE, FALSE, FALSE);
4499 gboolean extra_method = (method->wrapper_type != MONO_WRAPPER_NONE) || not_normal_gshared;
4500
4501 return extra_method;
4502 #endif
4503 }
4504
4505
4506 /*
4507 * find_aot_method:
4508 *
4509 * Try finding METHOD in the extra_method table in all AOT images.
4510 * Return its method index, or 0xffffff if not found. Set OUT_AMODULE to the AOT
4511 * module where the method was found.
4512 */
4513 static guint32
4514 find_aot_method (MonoMethod *method, MonoAotModule **out_amodule)
4515 {
4516 guint32 index;
4517 GPtrArray *modules;
4518 int i;
4519 guint32 hash = mono_aot_method_hash (method);
4520
4521 /* Try the place we expect to have moved the method only
4522 * We don't probe, as that causes hard-to-debug issues when we fail
4523 * to find the method */
4524 if (container_amodule && mono_aot_can_dedup (method)) {
4525 *out_amodule = container_amodule;
4526 index = find_aot_method_in_amodule (container_amodule, method, hash);
4527 return index;
4528 }
4529
4530 /* Try the method's module first */
4531 *out_amodule = m_class_get_image (method->klass)->aot_module;
4532 index = find_aot_method_in_amodule (m_class_get_image (method->klass)->aot_module, method, hash);
4533 if (index != 0xffffff)
4534 return index;
4535
4536 /*
4537 * Try all other modules.
4538 * This is needed because generic instances klass->image points to the image
4539 * containing the generic definition, but the native code is generated to the
4540 * AOT image which contains the reference.
4541 */
4542
4543 /* Make a copy to avoid doing the search inside the aot lock */
4544 modules = g_ptr_array_new ();
4545 mono_aot_lock ();
4546 g_hash_table_foreach (aot_modules, add_module_cb, modules);
4547 mono_aot_unlock ();
4548
4549 index = 0xffffff;
4550 for (i = 0; i < modules->len; ++i) {
4551 MonoAotModule *amodule = (MonoAotModule *)g_ptr_array_index (modules, i);
4552
4553 if (amodule != m_class_get_image (method->klass)->aot_module)
4554 index = find_aot_method_in_amodule (amodule, method, hash);
4555 if (index != 0xffffff) {
4556 *out_amodule = amodule;
4557 break;
4558 }
4559 }
4560
4561 g_ptr_array_free (modules, TRUE);
4562
4563 return index;
4564 }
4565
4566 guint32
4567 mono_aot_find_method_index (MonoMethod *method)
4568 {
4569 MonoAotModule *out_amodule;
4570 return find_aot_method (method, &out_amodule);
4571 }
4572
4573 static gboolean
4574 init_method (MonoAotModule *amodule, guint32 method_index, MonoMethod *method, MonoClass *init_class, MonoError *error)
4575 {
4576 MonoDomain *domain = mono_domain_get ();
4577 MonoMemPool *mp;
4578 MonoClass *klass_to_run_ctor = NULL;
4579 gboolean from_plt = method == NULL;
4580 int pindex, n_patches;
4581 guint8 *p;
4582 MonoJitInfo *jinfo = NULL;
4583 guint8 *code, *info;
4584 MonoGenericContext *context;
4585 MonoGenericContext ctx;
4586
4587 /* Might be needed if the method is externally called */
4588 init_plt (amodule);
4589 init_amodule_got (amodule, FALSE);
4590
4591 memset (&ctx, 0, sizeof (ctx));
4592
4593 error_init (error);
4594
4595 code = (guint8 *)amodule->methods [method_index];
4596 info = &amodule->blob [mono_aot_get_offset (amodule->method_info_offsets, method_index)];
4597
4598 p = info;
4599
4600 guint8 flags = decode_value (p, &p);
4601 if (flags & MONO_AOT_METHOD_FLAG_HAS_CCTOR)
4602 klass_to_run_ctor = decode_klass_ref (amodule, p, &p, error);
4603 if (!is_ok (error))
4604 return FALSE;
4605
4606 //FIXME old code would use the class from @method if not null and ignore the one encoded. I don't know if we need to honor that -- @kumpera
4607 if (method)
4608 klass_to_run_ctor = method->klass;
4609
4610 context = NULL;
4611 if (flags & MONO_AOT_METHOD_FLAG_HAS_CTX) {
4612 decode_generic_context (amodule, &ctx, p, &p, error);
4613 mono_error_assert_ok (error);
4614 context = &ctx;
4615 }
4616
4617 if (flags & MONO_AOT_METHOD_FLAG_HAS_PATCHES)
4618 n_patches = decode_value (p, &p);
4619 else
4620 n_patches = 0;
4621
4622 if (n_patches) {
4623 MonoJumpInfo *patches;
4624 guint32 *got_slots;
4625 gboolean llvm;
4626 gpointer *got;
4627
4628 mp = mono_mempool_new ();
4629
4630 if ((gpointer)code >= amodule->info.jit_code_start && (gpointer)code <= amodule->info.jit_code_end) {
4631 llvm = FALSE;
4632 got = amodule->got;
4633 } else {
4634 llvm = TRUE;
4635 got = amodule->llvm_got;
4636 g_assert (got);
4637 }
4638
4639 patches = load_patch_info (amodule, mp, n_patches, llvm, &got_slots, p, &p);
4640 if (patches == NULL) {
4641 mono_mempool_destroy (mp);
4642 goto cleanup;
4643 }
4644
4645 for (pindex = 0; pindex < n_patches; ++pindex) {
4646 MonoJumpInfo *ji = &patches [pindex];
4647 gpointer addr;
4648
4649 /*
4650 * For SFLDA, we need to call resolve_patch_target () since the GOT slot could have
4651 * been initialized by load_method () for a static cctor before the cctor has
4652 * finished executing (#23242).
4653 */
4654 if (ji->type == MONO_PATCH_INFO_NONE) {
4655 } else if (!got [got_slots [pindex]] || ji->type == MONO_PATCH_INFO_SFLDA) {
4656 /* In llvm-only made, we might encounter shared methods */
4657 if (mono_llvm_only && ji->type == MONO_PATCH_INFO_METHOD && mono_method_check_context_used (ji->data.method)) {
4658 g_assert (context);
4659 ji->data.method = mono_class_inflate_generic_method_checked (ji->data.method, context, error);
4660 if (!is_ok (error)) {
4661 g_free (got_slots);
4662 mono_mempool_destroy (mp);
4663 return FALSE;
4664 }
4665 }
4666 /* This cannot be resolved in mono_resolve_patch_target () */
4667 if (ji->type == MONO_PATCH_INFO_AOT_JIT_INFO) {
4668 // FIXME: Lookup using the index
4669 jinfo = mono_aot_find_jit_info (domain, amodule->assembly->image, code);
4670 ji->type = MONO_PATCH_INFO_ABS;
4671 ji->data.target = jinfo;
4672 }
4673 addr = mono_resolve_patch_target (method, domain, code, ji, TRUE, error);
4674 if (!is_ok (error)) {
4675 g_free (got_slots);
4676 mono_mempool_destroy (mp);
4677 return FALSE;
4678 }
4679 if (ji->type == MONO_PATCH_INFO_METHOD_JUMP)
4680 addr = mono_create_ftnptr (domain, addr);
4681 mono_memory_barrier ();
4682 got [got_slots [pindex]] = addr;
4683 if (ji->type == MONO_PATCH_INFO_METHOD_JUMP)
4684 register_jump_target_got_slot (domain, ji->data.method, &(got [got_slots [pindex]]));
4685 }
4686 ji->type = MONO_PATCH_INFO_NONE;
4687 }
4688
4689 g_free (got_slots);
4690
4691 mono_mempool_destroy (mp);
4692 }
4693
4694 if (mini_debug_options.load_aot_jit_info_eagerly)
4695 jinfo = mono_aot_find_jit_info (domain, amodule->assembly->image, code);
4696
4697 gboolean inited_ok;
4698 inited_ok = TRUE;
4699 if (init_class) {
4700 MonoVTable *vt = mono_class_vtable_checked (domain, init_class, error);
4701 if (!is_ok (error))
4702 inited_ok = FALSE;
4703 else
4704 inited_ok = mono_runtime_class_init_full (vt, error);
4705 } else if (from_plt && klass_to_run_ctor && !mono_class_is_gtd (klass_to_run_ctor)) {
4706 MonoVTable *vt = mono_class_vtable_checked (domain, klass_to_run_ctor, error);
4707 if (!is_ok (error))
4708 inited_ok = FALSE;
4709 else
4710 inited_ok = mono_runtime_class_init_full (vt, error);
4711 }
4712 if (!inited_ok)
4713 return FALSE;
4714
4715 return TRUE;
4716
4717 cleanup:
4718 if (jinfo)
4719 g_free (jinfo);
4720
4721 return FALSE;
4722 }
4723
4724 /*
4725 * mono_aot_init_llvmonly_method:
4726 *
4727 * Initialize the method identified by METHOD_INDEX in llvmonly mode.
4728 */
4729 gboolean
4730 mono_aot_init_llvmonly_method (gpointer aot_module, guint32 method_index, MonoClass *init_class, MonoError *error)
4731 {
4732 MonoAotModule *amodule = (MonoAotModule*)aot_module;
4733 MonoMethod *method = NULL;
4734
4735 return init_method (amodule, method_index, method, init_class, error);
4736 }
4737
4738 /*
4739 * mono_aot_get_method:
4740 *
4741 * Return a pointer to the AOTed native code for METHOD if it can be found,
4742 * NULL otherwise.
4743 * On platforms with function pointers, this doesn't return a function pointer.
4744 */
4745 gpointer
4746 mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error)
4747 {
4748 MonoClass *klass = method->klass;
4749 MonoMethod *orig_method = method;
4750 guint32 method_index;
4751 MonoAotModule *amodule = m_class_get_image (klass)->aot_module;
4752 guint8 *code;
4753 gboolean cache_result = FALSE;
4754 ERROR_DECL (inner_error);
4755
4756 error_init (error);
4757
4758 if (domain != mono_get_root_domain ())
4759 /* Non shared AOT code can't be used in other appdomains */
4760 return NULL;
4761
4762 if (enable_aot_cache && !amodule && domain->entry_assembly && mono_is_corlib_image (m_class_get_image (klass))) {
4763 /* This cannot be AOTed during startup, so do it now */
4764 if (!mscorlib_aot_loaded) {
4765 mscorlib_aot_loaded = TRUE;
4766 load_aot_module (mono_domain_default_alc (domain), m_class_get_image (klass)->assembly, NULL, error);
4767 amodule = m_class_get_image (klass)->aot_module;
4768 }
4769 }
4770
4771 if (!amodule)
4772 return NULL;
4773
4774 if (amodule->out_of_date)
4775 return NULL;
4776
4777 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
4778 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
4779 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
4780 (method->flags & METHOD_ATTRIBUTE_ABSTRACT))
4781 return NULL;
4782
4783 /* Load the dedup module lazily */
4784 load_container_amodule (mono_assembly_get_alc (amodule->assembly));
4785
4786 /*
4787 * Use the original method instead of its invoke-with-check wrapper.
4788 * This is not a problem when using full-aot, since it doesn't support
4789 * remoting.
4790 */
4791 if (mono_aot_only && method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
4792 return mono_aot_get_method (domain, mono_marshal_method_from_wrapper (method), error);
4793
4794 g_assert (m_class_is_inited (klass));
4795
4796 /* Find method index */
4797 method_index = 0xffffff;
4798
4799 gboolean dedupable = mono_aot_can_dedup (method);
4800
4801 if (method->is_inflated && !method->wrapper_type && mono_method_is_generic_sharable_full (method, TRUE, FALSE, FALSE) && !dedupable) {
4802 MonoMethod *orig_method = method;
4803 /*
4804 * For generic methods, we store the fully shared instance in place of the
4805 * original method.
4806 */
4807 method = mono_method_get_declaring_generic_method (method);
4808 method_index = mono_metadata_token_index (method->token) - 1;
4809
4810 if (amodule->llvm_code_start) {
4811 /* Needed by mini_llvm_init_gshared_method_this () */
4812 /* orig_method is a random instance but it is enough to make init_method () work */
4813 amodule_lock (amodule);
4814 g_hash_table_insert (amodule->extra_methods, GUINT_TO_POINTER (method_index), orig_method);
4815 amodule_unlock (amodule);
4816 }
4817 }
4818
4819 if (method_index == 0xffffff && (method->is_inflated || !method->token)) {
4820 /* This hash table is used to avoid the slower search in the extra_method_table in the AOT image */
4821 amodule_lock (amodule);
4822 code = (guint8 *)g_hash_table_lookup (amodule->method_to_code, method);
4823 amodule_unlock (amodule);
4824 if (code)
4825 return code;
4826
4827 cache_result = TRUE;
4828 if (method_index == 0xffffff)
4829 method_index = find_aot_method (method, &amodule);
4830
4831 /*
4832 * Special case the ICollection<T> wrappers for arrays, as they cannot
4833 * be statically enumerated, and each wrapper ends up calling the same
4834 * method in Array.
4835 */
4836 if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && m_class_get_rank (method->klass) && strstr (method->name, "System.Collections.Generic")) {
4837 MonoMethod *m = mono_aot_get_array_helper_from_wrapper (method);
4838
4839 code = (guint8 *)mono_aot_get_method (domain, m, inner_error);
4840 mono_error_cleanup (inner_error);
4841 if (code)
4842 return code;
4843 }
4844
4845 /*
4846 * Special case Array.GetGenericValue_icall which is a generic icall.
4847 * Generic sharing currently can't handle it, but the icall returns data using
4848 * an out parameter, so the managed-to-native wrappers can share the same code.
4849 */
4850 if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && method->klass == mono_defaults.array_class && !strcmp (method->name, "GetGenericValue_icall")) {
4851 MonoMethod *m;
4852 MonoGenericContext ctx;
4853
4854 if (mono_method_signature_internal (method)->params [1]->type == MONO_TYPE_OBJECT)
4855 /* Avoid recursion */
4856 return NULL;
4857
4858 m = mono_class_get_method_from_name_checked (mono_defaults.array_class, "GetGenericValue_icall", 3, 0, error);
4859 mono_error_assert_ok (error);
4860 g_assert (m);
4861
4862 memset (&ctx, 0, sizeof (ctx));
4863 MonoType *args [ ] = { m_class_get_byval_arg (mono_defaults.object_class) };
4864 ctx.method_inst = mono_metadata_get_generic_inst (1, args);
4865
4866 m = mono_marshal_get_native_wrapper (mono_class_inflate_generic_method_checked (m, &ctx, error), TRUE, TRUE);
4867 if (!m)
4868 g_error ("AOT runtime could not load method due to %s", mono_error_get_message (error)); /* FIXME don't swallow the error */
4869
4870 /*
4871 * Get the code for the <object> instantiation which should be emitted into
4872 * the mscorlib aot image by the AOT compiler.
4873 */
4874 code = (guint8 *)mono_aot_get_method (domain, m, inner_error);
4875 mono_error_cleanup (inner_error);
4876 if (code)
4877 return code;
4878 }
4879
4880 /* For ARRAY_ACCESSOR wrappers with reference types, use the <object> instantiation saved in corlib */
4881 if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_OTHER) {
4882 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
4883
4884 if (info->subtype == WRAPPER_SUBTYPE_ARRAY_ACCESSOR) {
4885 MonoMethod *array_method = info->d.array_accessor.method;
4886 if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (m_class_get_element_class (array_method->klass)))) {
4887 int rank;
4888
4889 if (!strcmp (array_method->name, "Set"))
4890 rank = mono_method_signature_internal (array_method)->param_count - 1;
4891 else if (!strcmp (array_method->name, "Get") || !strcmp (array_method->name, "Address"))
4892 rank = mono_method_signature_internal (array_method)->param_count;
4893 else
4894 g_assert_not_reached ();
4895 MonoClass *obj_array_class = mono_class_create_array (mono_defaults.object_class, rank);
4896 MonoMethod *m = mono_class_get_method_from_name_checked (obj_array_class, array_method->name, mono_method_signature_internal (array_method)->param_count, 0, error);
4897 mono_error_assert_ok (error);
4898 g_assert (m);
4899
4900 m = mono_marshal_get_array_accessor_wrapper (m);
4901 if (m != method) {
4902 code = (guint8 *)mono_aot_get_method (domain, m, inner_error);
4903 mono_error_cleanup (inner_error);
4904 if (code)
4905 return code;
4906 }
4907 }
4908 }
4909 }
4910
4911 if (method_index == 0xffffff && method->is_inflated && mono_method_is_generic_sharable_full (method, FALSE, TRUE, FALSE)) {
4912 /* Partial sharing */
4913 MonoMethod *shared;
4914
4915 shared = mini_get_shared_method_full (method, SHARE_MODE_NONE, error);
4916 return_val_if_nok (error, NULL);
4917
4918 method_index = find_aot_method (shared, &amodule);
4919 if (method_index != 0xffffff)
4920 method = shared;
4921 }
4922
4923 if (method_index == 0xffffff && method->is_inflated && mono_method_is_generic_sharable_full (method, FALSE, FALSE, TRUE)) {
4924 MonoMethod *shared;
4925 /* gsharedvt */
4926 /* Use the all-vt shared method since this is what was AOTed */
4927 shared = mini_get_shared_method_full (method, SHARE_MODE_GSHAREDVT, error);
4928 if (!shared)
4929 return NULL;
4930
4931 method_index = find_aot_method (shared, &amodule);
4932 if (method_index != 0xffffff) {
4933 method = mini_get_shared_method_full (method, SHARE_MODE_GSHAREDVT, error);
4934 if (!method)
4935 return NULL;
4936 }
4937 }
4938
4939 if (method_index == 0xffffff) {
4940 if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT)) {
4941 char *full_name;
4942
4943 full_name = mono_method_full_name (method, TRUE);
4944 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT NOT FOUND: %s.", full_name);
4945 g_free (full_name);
4946 }
4947 return NULL;
4948 }
4949
4950 if (method_index == 0xffffff)
4951 return NULL;
4952
4953 /* Needed by find_jit_info */
4954 amodule_lock (amodule);
4955 g_hash_table_insert (amodule->extra_methods, GUINT_TO_POINTER (method_index), method);
4956 amodule_unlock (amodule);
4957 } else {
4958 /* Common case */
4959 method_index = mono_metadata_token_index (method->token) - 1;
4960
4961 guint32 num_methods = amodule->info.nmethods - amodule->info.nextra_methods;
4962 if (method_index >= num_methods)
4963 /* method not available in AOT image */
4964 return NULL;
4965 }
4966
4967 code = (guint8 *)load_method (domain, amodule, m_class_get_image (klass), method, method->token, method_index, error);
4968 if (!is_ok (error))
4969 return NULL;
4970 if (code && cache_result) {
4971 amodule_lock (amodule);
4972 g_hash_table_insert (amodule->method_to_code, orig_method, code);
4973 amodule_unlock (amodule);
4974 }
4975 return code;
4976 }
4977
4978 /**
4979 * Same as mono_aot_get_method, but we try to avoid loading any metadata from the
4980 * method.
4981 */
4982 gpointer
4983 mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token, MonoError *error)
4984 {
4985 MonoAotModule *aot_module = image->aot_module;
4986 int method_index;
4987 gpointer res;
4988
4989 error_init (error);
4990
4991 if (!aot_module)
4992 return NULL;
4993
4994 method_index = mono_metadata_token_index (token) - 1;
4995
4996 res = load_method (domain, aot_module, image, NULL, token, method_index, error);
4997 return res;
4998 }
4999
5000 typedef struct {
5001 guint8 *addr;
5002 gboolean res;
5003 } IsGotEntryUserData;
5004
5005 static void
5006 check_is_got_entry (gpointer key, gpointer value, gpointer user_data)
5007 {
5008 IsGotEntryUserData *data = (IsGotEntryUserData*)user_data;
5009 MonoAotModule *aot_module = (MonoAotModule*)value;
5010
5011 if (aot_module->got && (data->addr >= (guint8*)(aot_module->got)) && (data->addr < (guint8*)(aot_module->got + aot_module->info.got_size)))
5012 data->res = TRUE;
5013 }
5014
5015 gboolean
5016 mono_aot_is_got_entry (guint8 *code, guint8 *addr)
5017 {
5018 IsGotEntryUserData user_data;
5019
5020 if (!aot_modules)
5021 return FALSE;
5022
5023 user_data.addr = addr;
5024 user_data.res = FALSE;
5025 mono_aot_lock ();
5026 g_hash_table_foreach (aot_modules, check_is_got_entry, &user_data);
5027 mono_aot_unlock ();
5028
5029 return user_data.res;
5030 }
5031
5032 typedef struct {
5033 guint8 *addr;
5034 MonoAotModule *module;
5035 } FindAotModuleUserData;
5036
5037 static void
5038 find_aot_module_cb (gpointer key, gpointer value, gpointer user_data)
5039 {
5040 FindAotModuleUserData *data = (FindAotModuleUserData*)user_data;
5041 MonoAotModule *aot_module = (MonoAotModule*)value;
5042
5043 if (amodule_contains_code_addr (aot_module, data->addr))
5044 data->module = aot_module;
5045 }
5046
5047 static MonoAotModule*
5048 find_aot_module (guint8 *code)
5049 {
5050 FindAotModuleUserData user_data;
5051
5052 if (!aot_modules)
5053 return NULL;
5054
5055 /* Reading these need no locking */
5056 if (((gsize)code < aot_code_low_addr) || ((gsize)code > aot_code_high_addr))
5057 return NULL;
5058
5059 user_data.addr = code;
5060 user_data.module = NULL;
5061
5062 mono_aot_lock ();
5063 g_hash_table_foreach (aot_modules, find_aot_module_cb, &user_data);
5064 mono_aot_unlock ();
5065
5066 return user_data.module;
5067 }
5068
5069 void
5070 mono_aot_patch_plt_entry (guint8 *code, guint8 *plt_entry, gpointer *got, host_mgreg_t *regs, guint8 *addr)
5071 {
5072 MonoAotModule *amodule;
5073
5074 /*
5075 * Since AOT code is only used in the root domain,
5076 * mono_domain_get () != mono_get_root_domain () means the calling method
5077 * is AppDomain:InvokeInDomain, so this is the same check as in
5078 * mono_method_same_domain () but without loading the metadata for the method.
5079 */
5080 if (mono_domain_get () == mono_get_root_domain ()) {
5081 if (!got) {
5082 amodule = find_aot_module (code);
5083 if (amodule)
5084 got = amodule->got;
5085 }
5086 mono_arch_patch_plt_entry (plt_entry, got, regs, addr);
5087 }
5088 }
5089
5090 /*
5091 * mono_aot_plt_resolve:
5092 *
5093 * This function is called by the entries in the PLT to resolve the actual method that
5094 * needs to be called. It returns a trampoline to the method and patches the PLT entry.
5095 * Returns NULL if the something cannot be loaded.
5096 */
5097 gpointer
5098 mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code, MonoError *error)
5099 {
5100 #ifdef MONO_ARCH_AOT_SUPPORTED
5101 guint8 *p, *target, *plt_entry;
5102 MonoJumpInfo ji;
5103 MonoAotModule *module = (MonoAotModule*)aot_module;
5104 gboolean res, no_ftnptr = FALSE;
5105 MonoMemPool *mp;
5106 gboolean using_gsharedvt = FALSE;
5107
5108 error_init (error);
5109
5110 //printf ("DYN: %p %d\n", aot_module, plt_info_offset);
5111
5112 p = &module->blob [plt_info_offset];
5113
5114 ji.type = (MonoJumpInfoType)decode_value (p, &p);
5115
5116 mp = mono_mempool_new ();
5117 res = decode_patch (module, mp, &ji, p, &p);
5118
5119 if (!res) {
5120 mono_mempool_destroy (mp);
5121 return NULL;
5122 }
5123
5124 #ifdef MONO_ARCH_GSHAREDVT_SUPPORTED
5125 using_gsharedvt = TRUE;
5126 #endif
5127
5128 /*
5129 * Avoid calling resolve_patch_target in the full-aot case if possible, since
5130 * it would create a trampoline, and we don't need that.
5131 * We could do this only if the method does not need the special handling
5132 * in mono_magic_trampoline ().
5133 */
5134 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) &&
5135 !mono_method_needs_static_rgctx_invoke (ji.data.method, FALSE) && !using_gsharedvt) {
5136 target = (guint8 *)mono_jit_compile_method (ji.data.method, error);
5137 if (!is_ok (error)) {
5138 mono_mempool_destroy (mp);
5139 return NULL;
5140 }
5141 no_ftnptr = TRUE;
5142 } else {
5143 target = (guint8 *)mono_resolve_patch_target (NULL, mono_domain_get (), NULL, &ji, TRUE, error);
5144 if (!is_ok (error)) {
5145 mono_mempool_destroy (mp);
5146 return NULL;
5147 }
5148 }
5149
5150 /*
5151 * The trampoline expects us to return a function descriptor on platforms which use
5152 * it, but resolve_patch_target returns a direct function pointer for some type of
5153 * patches, so have to translate between the two.
5154 * FIXME: Clean this up, but how ?
5155 */
5156 if (ji.type == MONO_PATCH_INFO_ABS
5157 || ji.type == MONO_PATCH_INFO_JIT_ICALL_ID
5158 || ji.type == MONO_PATCH_INFO_ICALL_ADDR
5159 || ji.type == MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR
5160 || ji.type == MONO_PATCH_INFO_JIT_ICALL_ADDR
5161 || ji.type == MONO_PATCH_INFO_RGCTX_FETCH) {
5162 /* These should already have a function descriptor */
5163 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
5164 /* Our function descriptors have a 0 environment, gcc created ones don't */
5165 if (ji.type != MONO_PATCH_INFO_JIT_ICALL_ID
5166 && ji.type != MONO_PATCH_INFO_JIT_ICALL_ADDR
5167 && ji.type != MONO_PATCH_INFO_ICALL_ADDR
5168 && ji.type != MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR)
5169 g_assert (((gpointer*)target) [2] == 0);
5170 #endif
5171 /* Empty */
5172 } else if (!no_ftnptr) {
5173 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
5174 g_assert (((gpointer*)target) [2] != 0);
5175 #endif
5176 target = (guint8 *)mono_create_ftnptr (mono_domain_get (), target);
5177 }
5178
5179 mono_mempool_destroy (mp);
5180
5181 /* Patch the PLT entry with target which might be the actual method not a trampoline */
5182 plt_entry = mono_aot_get_plt_entry (code);
5183 g_assert (plt_entry);
5184 mono_aot_patch_plt_entry (code, plt_entry, module->got, NULL, target);
5185
5186 return target;
5187 #else
5188 g_assert_not_reached ();
5189 return NULL;
5190 #endif
5191 }
5192
5193 /**
5194 * init_plt:
5195 *
5196 * Initialize the PLT table of the AOT module. Called lazily when the first AOT
5197 * method in the module is loaded to avoid committing memory by writing to it.
5198 */
5199 static void
5200 init_plt (MonoAotModule *amodule)
5201 {
5202 int i;
5203 gpointer tramp;
5204
5205 if (amodule->plt_inited)
5206 return;
5207
5208 tramp = mono_create_specific_trampoline (amodule, MONO_TRAMPOLINE_AOT_PLT, mono_get_root_domain (), NULL);
5209 tramp = mono_create_ftnptr (mono_domain_get (), tramp);
5210
5211 amodule_lock (amodule);
5212
5213 if (amodule->plt_inited) {
5214 amodule_unlock (amodule);
5215 return;
5216 }
5217
5218 if (amodule->info.plt_size <= 1) {
5219 amodule->plt_inited = TRUE;
5220 amodule_unlock (amodule);
5221 return;
5222 }
5223
5224 /*
5225 * Initialize the PLT entries in the GOT to point to the default targets.
5226 */
5227 for (i = 1; i < amodule->info.plt_size; ++i)
5228 /* All the default entries point to the AOT trampoline */
5229 ((gpointer*)amodule->got)[amodule->info.plt_got_offset_base + i] = tramp;
5230
5231 mono_memory_barrier ();
5232
5233 amodule->plt_inited = TRUE;
5234
5235 amodule_unlock (amodule);
5236 }
5237
5238 /*
5239 * mono_aot_get_plt_entry:
5240 *
5241 * Return the address of the PLT entry called by the code at CODE if exists.
5242 */
5243 guint8*
5244 mono_aot_get_plt_entry (guint8 *code)
5245 {
5246 MonoAotModule *amodule = find_aot_module (code);
5247 guint8 *target = NULL;
5248
5249 if (!amodule)
5250 return NULL;
5251
5252 #ifdef TARGET_ARM
5253 if (is_thumb_code (amodule, code - 4))
5254 return mono_arm_get_thumb_plt_entry (code);
5255 #endif
5256
5257 #ifdef MONO_ARCH_AOT_SUPPORTED
5258 target = mono_arch_get_call_target (code);
5259 #else
5260 g_assert_not_reached ();
5261 #endif
5262
5263 #ifdef MONOTOUCH
5264 while (target != NULL) {
5265 if ((target >= (guint8*)(amodule->plt)) && (target < (guint8*)(amodule->plt_end)))
5266 return target;
5267
5268 // Add 4 since mono_arch_get_call_target assumes we're passing
5269 // the instruction after the actual branch instruction.
5270 target = mono_arch_get_call_target (target + 4);
5271 }
5272
5273 return NULL;
5274 #else
5275 if ((target >= (guint8*)(amodule->plt)) && (target < (guint8*)(amodule->plt_end)))
5276 return target;
5277 else
5278 return NULL;
5279 #endif
5280 }
5281
5282 /*
5283 * mono_aot_get_plt_info_offset:
5284 *
5285 * Return the PLT info offset belonging to the plt entry called by CODE.
5286 */
5287 guint32
5288 mono_aot_get_plt_info_offset (host_mgreg_t *regs, guint8 *code)
5289 {
5290 guint8 *plt_entry = mono_aot_get_plt_entry (code);
5291
5292 g_assert (plt_entry);
5293
5294 /* The offset is embedded inside the code after the plt entry */
5295 #ifdef MONO_ARCH_AOT_SUPPORTED
5296 return mono_arch_get_plt_info_offset (plt_entry, regs, code);
5297 #else
5298 g_assert_not_reached ();
5299 return 0;
5300 #endif
5301 }
5302
5303 static gpointer
5304 mono_create_ftnptr_malloc (guint8 *code)
5305 {
5306 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
5307 MonoPPCFunctionDescriptor *ftnptr = g_malloc0 (sizeof (MonoPPCFunctionDescriptor));
5308
5309 ftnptr->code = code;
5310 ftnptr->toc = NULL;
5311 ftnptr->env = NULL;
5312
5313 return ftnptr;
5314 #else
5315 return code;
5316 #endif
5317 }
5318
5319 /*
5320 * load_function_full:
5321 *
5322 * Load the function named NAME from the aot image.
5323 */
5324 static gpointer
5325 load_function_full (MonoAotModule *amodule, const char *name, MonoTrampInfo **out_tinfo)
5326 {
5327 char *symbol;
5328 guint8 *p;
5329 int n_patches, pindex;
5330 MonoMemPool *mp;
5331 gpointer code;
5332 guint32 info_offset;
5333
5334 /* Load the code */
5335
5336 find_amodule_symbol (amodule, name, &code);
5337 g_assertf (code, "Symbol '%s' not found in AOT file '%s'.\n", name, amodule->aot_name);
5338
5339 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "AOT: FOUND function '%s' in AOT file '%s'.", name, amodule->aot_name);
5340
5341 /* Load info */
5342
5343 symbol = g_strdup_printf ("%s_p", name);
5344 find_amodule_symbol (amodule, symbol, (gpointer *)&p);
5345 g_free (symbol);
5346 if (!p)
5347 /* Nothing to patch */
5348 return code;
5349
5350 info_offset = *(guint32*)p;
5351 if (out_tinfo) {
5352 MonoTrampInfo *tinfo;
5353 guint32 code_size, uw_info_len, uw_offset;
5354 guint8 *uw_info;
5355 /* Construct a MonoTrampInfo from the data in the AOT image */
5356
5357 p += sizeof (guint32);
5358 code_size = *(guint32*)p;
5359 p += sizeof (guint32);
5360 uw_offset = *(guint32*)p;
5361 uw_info = amodule->unwind_info + uw_offset;
5362 uw_info_len = decode_value (uw_info, &uw_info);
5363
5364 tinfo = g_new0 (MonoTrampInfo, 1);
5365 tinfo->code = (guint8 *)code;
5366 tinfo->code_size = code_size;
5367 tinfo->uw_info_len = uw_info_len;
5368 if (uw_info_len)
5369 tinfo->uw_info = uw_info;
5370
5371 *out_tinfo = tinfo;
5372 }
5373
5374 p = amodule->blob + info_offset;
5375
5376 /* Similar to mono_aot_load_method () */
5377
5378 n_patches = decode_value (p, &p);
5379
5380 if (n_patches) {
5381 MonoJumpInfo *patches;
5382 guint32 *got_slots;
5383
5384 mp = mono_mempool_new ();
5385
5386 patches = load_patch_info (amodule, mp, n_patches, FALSE, &got_slots, p, &p);
5387 g_assert (patches);
5388
5389 for (pindex = 0; pindex < n_patches; ++pindex) {
5390 MonoJumpInfo *ji = &patches [pindex];
5391 ERROR_DECL (error);
5392 gpointer target;
5393
5394 if (amodule->got [got_slots [pindex]])
5395 continue;
5396
5397 /*
5398 * When this code is executed, the runtime may not be initalized yet, so
5399 * resolve the patch info by hand.
5400 */
5401 if (ji->type == MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR) {
5402 target = mono_create_specific_trampoline (GUINT_TO_POINTER (ji->data.uindex), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
5403 target = mono_create_ftnptr_malloc ((guint8 *)target);
5404 } else if (ji->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
5405 const MonoJitICallId jit_icall_id = (MonoJitICallId)ji->data.jit_icall_id;
5406 switch (jit_icall_id) {
5407
5408 #undef MONO_AOT_ICALL
5409 #define MONO_AOT_ICALL(x) case MONO_JIT_ICALL_ ## x: target = (gpointer)x; break;
5410
5411 MONO_AOT_ICALL (mono_get_lmf_addr)
5412 MONO_AOT_ICALL (mono_thread_force_interruption_checkpoint_noraise)
5413 MONO_AOT_ICALL (mono_exception_from_token)
5414
5415 case MONO_JIT_ICALL_mono_debugger_agent_single_step_from_context:
5416 target = (gpointer)mini_get_dbg_callbacks ()->single_step_from_context;
5417 break;
5418 case MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context:
5419 target = (gpointer)mini_get_dbg_callbacks ()->breakpoint_from_context;
5420 break;
5421 case MONO_JIT_ICALL_mono_throw_exception:
5422 target = mono_get_throw_exception_addr ();
5423 break;
5424 case MONO_JIT_ICALL_mono_rethrow_preserve_exception:
5425 target = mono_get_rethrow_preserve_exception_addr ();
5426 break;
5427
5428 case MONO_JIT_ICALL_generic_trampoline_jit:
5429 case MONO_JIT_ICALL_generic_trampoline_jump:
5430 case MONO_JIT_ICALL_generic_trampoline_rgctx_lazy_fetch:
5431 case MONO_JIT_ICALL_generic_trampoline_aot:
5432 case MONO_JIT_ICALL_generic_trampoline_aot_plt:
5433 case MONO_JIT_ICALL_generic_trampoline_delegate:
5434 case MONO_JIT_ICALL_generic_trampoline_generic_virtual_remoting:
5435 case MONO_JIT_ICALL_generic_trampoline_vcall:
5436 target = (gpointer)mono_get_trampoline_func (mono_jit_icall_id_to_trampoline_type (jit_icall_id));
5437 break;
5438 default:
5439 target = mono_arch_load_function (jit_icall_id);
5440 g_assertf (target, "Unknown relocation '%p'\n", ji->data.target);
5441 }
5442 } else {
5443 /* Hopefully the code doesn't have patches which need method or
5444 * domain to be set.
5445 */
5446 target = mono_resolve_patch_target (NULL, NULL, (guint8 *)code, ji, FALSE, error);
5447 mono_error_assert_ok (error);
5448 g_assert (target);
5449 }
5450
5451 if (ji->type != MONO_PATCH_INFO_NONE)
5452 amodule->got [got_slots [pindex]] = target;
5453 }
5454
5455 g_free (got_slots);
5456
5457 mono_mempool_destroy (mp);
5458 }
5459
5460 return code;
5461 }
5462
5463 static gpointer
5464 load_function (MonoAotModule *amodule, const char *name)
5465 {
5466 return load_function_full (amodule, name, NULL);
5467 }
5468
5469 static MonoAotModule*
5470 get_mscorlib_aot_module (void)
5471 {
5472 MonoImage *image;
5473 MonoAotModule *amodule;
5474
5475 image = mono_defaults.corlib;
5476 if (image && image->aot_module)
5477 amodule = image->aot_module;
5478 else
5479 amodule = mscorlib_aot_module;
5480 g_assert (amodule);
5481 return amodule;
5482 }
5483
5484 static void
5485 mono_no_trampolines (void)
5486 {
5487 g_assert_not_reached ();
5488 }
5489
5490 /*
5491 * Return the trampoline identified by NAME from the mscorlib AOT file.
5492 * On ppc64, this returns a function descriptor.
5493 */
5494 gpointer
5495 mono_aot_get_trampoline_full (const char *name, MonoTrampInfo **out_tinfo)
5496 {
5497 MonoAotModule *amodule = get_mscorlib_aot_module ();
5498
5499 if (mono_llvm_only) {
5500 *out_tinfo = NULL;
5501 return (gpointer)mono_no_trampolines;
5502 }
5503
5504 return mono_create_ftnptr_malloc ((guint8 *)load_function_full (amodule, name, out_tinfo));
5505 }
5506
5507 gpointer
5508 mono_aot_get_trampoline (const char *name)
5509 {
5510 MonoTrampInfo *out_tinfo;
5511 gpointer code;
5512
5513 code = mono_aot_get_trampoline_full (name, &out_tinfo);
5514 mono_aot_tramp_info_register (out_tinfo, NULL);
5515
5516 return code;
5517 }
5518
5519 static gpointer
5520 read_unwind_info (MonoAotModule *amodule, MonoTrampInfo *info, const char *symbol_name)
5521 {
5522 gpointer symbol_addr;
5523 guint32 uw_offset, uw_info_len;
5524 guint8 *uw_info;
5525
5526 find_amodule_symbol (amodule, symbol_name, &symbol_addr);
5527
5528 if (!symbol_addr)
5529 return NULL;
5530
5531 uw_offset = *(guint32*)symbol_addr;
5532 uw_info = amodule->unwind_info + uw_offset;
5533 uw_info_len = decode_value (uw_info, &uw_info);
5534
5535 info->uw_info_len = uw_info_len;
5536 if (uw_info_len)
5537 info->uw_info = uw_info;
5538 else
5539 info->uw_info = NULL;
5540
5541 /* If successful return the address of the following data */
5542 return (guint32*)symbol_addr + 1;
5543 }
5544
5545 #ifdef MONOTOUCH
5546 #include <mach/mach.h>
5547
5548 static TrampolinePage* trampoline_pages [MONO_AOT_TRAMP_NUM];
5549
5550 static void
5551 read_page_trampoline_uwinfo (MonoTrampInfo *info, int tramp_type, gboolean is_generic)
5552 {
5553 char symbol_name [128];
5554
5555 if (tramp_type == MONO_AOT_TRAMP_SPECIFIC)
5556 sprintf (symbol_name, "specific_trampolines_page_%s_p", is_generic ? "gen" : "sp");
5557 else if (tramp_type == MONO_AOT_TRAMP_STATIC_RGCTX)
5558 sprintf (symbol_name, "rgctx_trampolines_page_%s_p", is_generic ? "gen" : "sp");
5559 else if (tramp_type == MONO_AOT_TRAMP_IMT)
5560 sprintf (symbol_name, "imt_trampolines_page_%s_p", is_generic ? "gen" : "sp");
5561 else if (tramp_type == MONO_AOT_TRAMP_GSHAREDVT_ARG)
5562 sprintf (symbol_name, "gsharedvt_trampolines_page_%s_p", is_generic ? "gen" : "sp");
5563 else if (tramp_type == MONO_AOT_TRAMP_UNBOX_ARBITRARY)
5564 sprintf (symbol_name, "unbox_arbitrary_trampolines_page_%s_p", is_generic ? "gen" : "sp");
5565 else
5566 g_assert_not_reached ();
5567
5568 read_unwind_info (mscorlib_aot_module, info, symbol_name);
5569 }
5570
5571 static unsigned char*
5572 get_new_trampoline_from_page (int tramp_type)
5573 {
5574 MonoImage *image;
5575 TrampolinePage *page;
5576 int count;
5577 void *tpage;
5578 vm_address_t addr, taddr;
5579 kern_return_t ret;
5580 vm_prot_t prot, max_prot;
5581 int psize, specific_trampoline_size;
5582 unsigned char *code;
5583
5584 specific_trampoline_size = 2 * sizeof (gpointer);
5585
5586 mono_aot_page_lock ();
5587 page = trampoline_pages [tramp_type];
5588 if (page && page->trampolines < page->trampolines_end) {
5589 code = page->trampolines;
5590 page->trampolines += specific_trampoline_size;
5591 mono_aot_page_unlock ();
5592 return code;
5593 }
5594 mono_aot_page_unlock ();
5595
5596 psize = MONO_AOT_TRAMP_PAGE_SIZE;
5597
5598 /* the trampoline template page is in the mscorlib module */
5599 MonoAotModule *amodule = mscorlib_aot_module;
5600 g_assert (amodule);
5601
5602 if (tramp_type == MONO_AOT_TRAMP_SPECIFIC)
5603 tpage = load_function (amodule, "specific_trampolines_page");
5604 else if (tramp_type == MONO_AOT_TRAMP_STATIC_RGCTX)
5605 tpage = load_function (amodule, "rgctx_trampolines_page");
5606 else if (tramp_type == MONO_AOT_TRAMP_IMT)
5607 tpage = load_function (amodule, "imt_trampolines_page");
5608 else if (tramp_type == MONO_AOT_TRAMP_GSHAREDVT_ARG)
5609 tpage = load_function (amodule, "gsharedvt_arg_trampolines_page");
5610 else if (tramp_type == MONO_AOT_TRAMP_UNBOX_ARBITRARY)
5611 tpage = load_function (amodule, "unbox_arbitrary_trampolines_page");
5612 else
5613 g_error ("Incorrect tramp type for trampolines page");
5614 g_assert (tpage);
5615 /*g_warning ("loaded trampolines page at %x", tpage);*/
5616
5617 /* avoid the unlikely case of looping forever */
5618 count = 40;
5619 page = NULL;
5620 while (page == NULL && count-- > 0) {
5621 MonoTrampInfo *gen_info, *sp_info;
5622
5623 addr = 0;
5624 /* allocate two contiguous pages of memory: the first page will contain the data (like a local constant pool)
5625 * while the second will contain the trampolines.
5626 */
5627 do {
5628 ret = vm_allocate (mach_task_self (), &addr, psize * 2, VM_FLAGS_ANYWHERE);
5629 } while (ret == KERN_ABORTED);
5630 if (ret != KERN_SUCCESS) {
5631 g_error ("Cannot allocate memory for trampolines: %d", ret);
5632 break;
5633 }
5634 /*g_warning ("allocated trampoline double page at %x", addr);*/
5635 /* replace the second page with a remapped trampoline page */
5636 taddr = addr + psize;
5637 vm_deallocate (mach_task_self (), taddr, psize);
5638 ret = vm_remap (mach_task_self (), &taddr, psize, 0, FALSE, mach_task_self(), (vm_address_t)tpage, FALSE, &prot, &max_prot, VM_INHERIT_SHARE);
5639 if (ret != KERN_SUCCESS) {
5640 /* someone else got the page, try again */
5641 vm_deallocate (mach_task_self (), addr, psize);
5642 continue;
5643 }
5644 /*g_warning ("remapped trampoline page at %x", taddr);*/
5645
5646 mono_aot_page_lock ();
5647 page = trampoline_pages [tramp_type];
5648 /* some other thread already allocated, so use that to avoid wasting memory */
5649 if (page && page->trampolines < page->trampolines_end) {
5650 code = page->trampolines;
5651 page->trampolines += specific_trampoline_size;
5652 mono_aot_page_unlock ();
5653 vm_deallocate (mach_task_self (), addr, psize);
5654 vm_deallocate (mach_task_self (), taddr, psize);
5655 return code;
5656 }
5657 page = (TrampolinePage*)addr;
5658 page->next = trampoline_pages [tramp_type];
5659 trampoline_pages [tramp_type] = page;
5660 page->trampolines = (guint8*)(taddr + amodule->info.tramp_page_code_offsets [tramp_type]);
5661 page->trampolines_end = (guint8*)(taddr + psize - 64);
5662 code = page->trampolines;
5663 page->trampolines += specific_trampoline_size;
5664 mono_aot_page_unlock ();
5665
5666 /* Register the generic part at the beggining of the trampoline page */
5667 gen_info = mono_tramp_info_create (NULL, (guint8*)taddr, amodule->info.tramp_page_code_offsets [tramp_type], NULL, NULL);
5668 read_page_trampoline_uwinfo (gen_info, tramp_type, TRUE);
5669 mono_aot_tramp_info_register (gen_info, NULL);
5670 /*
5671 * FIXME
5672 * Registering each specific trampoline produces a lot of
5673 * MonoJitInfo structures. Jump trampolines are also registered
5674 * separately.
5675 */
5676 if (tramp_type != MONO_AOT_TRAMP_SPECIFIC) {
5677 /* Register the rest of the page as a single trampoline */
5678 sp_info = mono_tramp_info_create (NULL, code, page->trampolines_end - code, NULL, NULL);
5679 read_page_trampoline_uwinfo (sp_info, tramp_type, FALSE);
5680 mono_aot_tramp_info_register (sp_info, NULL);
5681 }
5682 return code;
5683 }
5684 g_error ("Cannot allocate more trampoline pages: %d", ret);
5685 return NULL;
5686 }
5687
5688 #else
5689 static unsigned char*
5690 get_new_trampoline_from_page (int tramp_type)
5691 {
5692 g_error ("Page trampolines not supported.");
5693 return NULL;
5694 }
5695 #endif
5696
5697
5698 static gpointer
5699 get_new_specific_trampoline_from_page (gpointer tramp, gpointer arg)
5700 {
5701 void *code;
5702 gpointer *data;
5703
5704 code = get_new_trampoline_from_page (MONO_AOT_TRAMP_SPECIFIC);
5705
5706 data = (gpointer*)((char*)code - MONO_AOT_TRAMP_PAGE_SIZE);
5707 data [0] = arg;
5708 data [1] = tramp;
5709 /*g_warning ("new trampoline at %p for data %p, tramp %p (stored at %p)", code, arg, tramp, data);*/
5710 return code;
5711
5712 }
5713
5714 static gpointer
5715 get_new_rgctx_trampoline_from_page (gpointer tramp, gpointer arg)
5716 {
5717 void *code;
5718 gpointer *data;
5719
5720 code = get_new_trampoline_from_page (MONO_AOT_TRAMP_STATIC_RGCTX);
5721
5722 data = (gpointer*)((char*)code - MONO_AOT_TRAMP_PAGE_SIZE);
5723 data [0] = arg;
5724 data [1] = tramp;
5725 /*g_warning ("new rgctx trampoline at %p for data %p, tramp %p (stored at %p)", code, arg, tramp, data);*/
5726 return code;
5727
5728 }
5729
5730 static gpointer
5731 get_new_imt_trampoline_from_page (gpointer arg)
5732 {
5733 void *code;
5734 gpointer *data;
5735
5736 code = get_new_trampoline_from_page (MONO_AOT_TRAMP_IMT);
5737
5738 data = (gpointer*)((char*)code - MONO_AOT_TRAMP_PAGE_SIZE);
5739 data [0] = arg;
5740 /*g_warning ("new imt trampoline at %p for data %p, (stored at %p)", code, arg, data);*/
5741 return code;
5742
5743 }
5744
5745 static gpointer
5746 get_new_gsharedvt_arg_trampoline_from_page (gpointer tramp, gpointer arg)
5747 {
5748 void *code;
5749 gpointer *data;
5750
5751 code = get_new_trampoline_from_page (MONO_AOT_TRAMP_GSHAREDVT_ARG);
5752
5753 data = (gpointer*)((char*)code - MONO_AOT_TRAMP_PAGE_SIZE);
5754 data [0] = arg;
5755 data [1] = tramp;
5756 /*g_warning ("new rgctx trampoline at %p for data %p, tramp %p (stored at %p)", code, arg, tramp, data);*/
5757 return code;
5758 }
5759
5760 static gpointer
5761 get_new_unbox_arbitrary_trampoline_frome_page (gpointer addr)
5762 {
5763 void *code;
5764 gpointer *data;
5765
5766 code = get_new_trampoline_from_page (MONO_AOT_TRAMP_UNBOX_ARBITRARY);
5767
5768 data = (gpointer*)((char*)code - MONO_AOT_TRAMP_PAGE_SIZE);
5769 data [0] = addr;
5770
5771 return code;
5772 }
5773
5774 /* Return a given kind of trampoline */
5775 /* FIXME set unwind info for these trampolines */
5776 static gpointer
5777 get_numerous_trampoline (MonoAotTrampoline tramp_type, int n_got_slots, MonoAotModule **out_amodule, guint32 *got_offset, guint32 *out_tramp_size)
5778 {
5779 MonoImage *image;
5780 MonoAotModule *amodule = get_mscorlib_aot_module ();
5781 int index, tramp_size;
5782
5783 /* Currently, we keep all trampolines in the mscorlib AOT image */
5784 image = mono_defaults.corlib;
5785
5786 *out_amodule = amodule;
5787
5788 mono_aot_lock ();
5789
5790 #ifdef MONOTOUCH
5791 #define MONOTOUCH_TRAMPOLINES_ERROR ". See http://docs.xamarin.com/ios/troubleshooting for instructions on how to fix this condition."
5792 #else
5793 #define MONOTOUCH_TRAMPOLINES_ERROR ""
5794 #endif
5795 if (amodule->trampoline_index [tramp_type] == amodule->info.num_trampolines [tramp_type]) {
5796 g_error ("Ran out of trampolines of type %d in '%s' (limit %d)%s\n",
5797 tramp_type, image ? image->name : MONO_ASSEMBLY_CORLIB_NAME, amodule->info.num_trampolines [tramp_type], MONOTOUCH_TRAMPOLINES_ERROR);
5798 }
5799 index = amodule->trampoline_index [tramp_type] ++;
5800
5801 mono_aot_unlock ();
5802
5803 *got_offset = amodule->info.trampoline_got_offset_base [tramp_type] + (index * n_got_slots);
5804
5805 tramp_size = amodule->info.trampoline_size [tramp_type];
5806
5807 if (out_tramp_size)
5808 *out_tramp_size = tramp_size;
5809
5810 return amodule->trampolines [tramp_type] + (index * tramp_size);
5811 }
5812
5813 static void
5814 no_specific_trampoline (void)
5815 {
5816 g_assert_not_reached ();
5817 }
5818
5819 /*
5820 * Return a specific trampoline from the AOT file.
5821 */
5822 gpointer
5823 mono_aot_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
5824 {
5825 MonoAotModule *amodule;
5826 guint32 got_offset, tramp_size;
5827 guint8 *code, *tramp;
5828 static gpointer generic_trampolines [MONO_TRAMPOLINE_NUM];
5829 static gboolean inited;
5830 static guint32 num_trampolines;
5831
5832 if (mono_llvm_only) {
5833 *code_len = 1;
5834 return (gpointer)no_specific_trampoline;
5835 }
5836
5837 if (!inited) {
5838 mono_aot_lock ();
5839
5840 if (!inited) {
5841 mono_counters_register ("Specific trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &num_trampolines);
5842 inited = TRUE;
5843 }
5844
5845 mono_aot_unlock ();
5846 }
5847
5848 num_trampolines ++;
5849
5850 if (!generic_trampolines [tramp_type]) {
5851 const char *symbol;
5852
5853 symbol = mono_get_generic_trampoline_name (tramp_type);
5854 generic_trampolines [tramp_type] = mono_aot_get_trampoline (symbol);
5855 }
5856
5857 tramp = (guint8 *)generic_trampolines [tramp_type];
5858 g_assert (tramp);
5859
5860 if (USE_PAGE_TRAMPOLINES) {
5861 code = (guint8 *)get_new_specific_trampoline_from_page (tramp, arg1);
5862 tramp_size = 8;
5863 } else {
5864 code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_SPECIFIC, 2, &amodule, &got_offset, &tramp_size);
5865
5866 amodule->got [got_offset] = tramp;
5867 amodule->got [got_offset + 1] = arg1;
5868 }
5869
5870 if (code_len)
5871 *code_len = tramp_size;
5872
5873 return code;
5874 }
5875
5876 gpointer
5877 mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr)
5878 {
5879 MonoAotModule *amodule;
5880 guint8 *code;
5881 guint32 got_offset;
5882
5883 if (USE_PAGE_TRAMPOLINES) {
5884 code = (guint8 *)get_new_rgctx_trampoline_from_page (addr, ctx);
5885 } else {
5886 code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_STATIC_RGCTX, 2, &amodule, &got_offset, NULL);
5887
5888 amodule->got [got_offset] = ctx;
5889 amodule->got [got_offset + 1] = addr;
5890 }
5891
5892 /* The caller expects an ftnptr */
5893 return mono_create_ftnptr (mono_domain_get (), code);
5894 }
5895
5896 gpointer
5897 mono_aot_get_unbox_arbitrary_trampoline (gpointer addr)
5898 {
5899 MonoAotModule *amodule;
5900 guint8 *code;
5901 guint32 got_offset;
5902
5903 if (USE_PAGE_TRAMPOLINES) {
5904 code = (guint8 *)get_new_unbox_arbitrary_trampoline_frome_page (addr);
5905 } else {
5906 code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_UNBOX_ARBITRARY, 1, &amodule, &got_offset, NULL);
5907 amodule->got [got_offset] = addr;
5908 }
5909
5910 /* The caller expects an ftnptr */
5911 return mono_create_ftnptr (mono_domain_get (), code);
5912 }
5913
5914 static int
5915 i32_idx_comparer (const void *key, const void *member)
5916 {
5917 gint32 idx1 = GPOINTER_TO_INT (key);
5918 gint32 idx2 = *(gint32*)member;
5919 return idx1 - idx2;
5920 }
5921
5922 static int
5923 i16_idx_comparer (const void *key, const void *member)
5924 {
5925 int idx1 = GPOINTER_TO_INT (key);
5926 int idx2 = *(gint16*)member;
5927 return idx1 - idx2;
5928 }
5929
5930 static gboolean
5931 aot_is_slim_amodule (MonoAotModule *amodule)
5932 {
5933 if (!amodule)
5934 return FALSE;
5935
5936 /* "slim" only applies to mscorlib.dll */
5937 if (strcmp (amodule->aot_name, "mscorlib"))
5938 return FALSE;
5939
5940 guint32 f = amodule->info.flags;
5941 return (f & MONO_AOT_FILE_FLAG_INTERP) && !(f & MONO_AOT_FILE_FLAG_FULL_AOT);
5942 }
5943
5944 gpointer
5945 mono_aot_get_unbox_trampoline (MonoMethod *method, gpointer addr)
5946 {
5947 ERROR_DECL (error);
5948 guint32 method_index = mono_metadata_token_index (method->token) - 1;
5949 MonoAotModule *amodule;
5950 gpointer code;
5951 guint32 *ut, *ut_end, *entry;
5952 int low, high, entry_index = 0;
5953 MonoTrampInfo *tinfo;
5954
5955 if (method->is_inflated && !mono_method_is_generic_sharable_full (method, FALSE, FALSE, FALSE)) {
5956 method_index = find_aot_method (method, &amodule);
5957 if (method_index == 0xffffff && mono_method_is_generic_sharable_full (method, FALSE, TRUE, FALSE)) {
5958 MonoMethod *shared = mini_get_shared_method_full (method, SHARE_MODE_NONE, error);
5959 mono_error_assert_ok (error);
5960 method_index = find_aot_method (shared, &amodule);
5961 }
5962 if (method_index == 0xffffff && mono_method_is_generic_sharable_full (method, FALSE, TRUE, TRUE)) {
5963 MonoMethod *shared = mini_get_shared_method_full (method, SHARE_MODE_GSHAREDVT, error);
5964 mono_error_assert_ok (error);
5965
5966 method_index = find_aot_method (shared, &amodule);
5967 }
5968 } else
5969 amodule = m_class_get_image (method->klass)->aot_module;
5970
5971 if (amodule == NULL || method_index == 0xffffff || aot_is_slim_amodule (amodule)) {
5972 /* couldn't find unbox trampoline specifically generated for that
5973 * method. this should only happen when an unbox trampoline is needed
5974 * for `fullAOT code -> native-to-interp -> interp` transition if
5975 * (1) it's a virtual call
5976 * (2) the receiver is a value type, thus needs unboxing */
5977 g_assert (mono_use_interpreter);
5978 return mono_aot_get_unbox_arbitrary_trampoline (addr);
5979 }
5980
5981 if (amodule->info.llvm_unbox_tramp_indexes) {
5982 int unbox_tramp_idx;
5983
5984 /* Search the llvm_unbox_tramp_indexes table using a binary search */
5985 if (amodule->info.llvm_unbox_tramp_elemsize == sizeof (guint32)) {
5986 void *ptr = mono_binary_search (GINT_TO_POINTER (method_index), amodule->info.llvm_unbox_tramp_indexes, amodule->info.llvm_unbox_tramp_num, amodule->info.llvm_unbox_tramp_elemsize, i32_idx_comparer);
5987 g_assert (ptr);
5988 g_assert (*(int*)ptr == method_index);
5989 unbox_tramp_idx = (guint32*)ptr - (guint32*)amodule->info.llvm_unbox_tramp_indexes;
5990 } else {
5991 void *ptr = mono_binary_search (GINT_TO_POINTER (method_index), amodule->info.llvm_unbox_tramp_indexes, amodule->info.llvm_unbox_tramp_num, amodule->info.llvm_unbox_tramp_elemsize, i16_idx_comparer);
5992 g_assert (ptr);
5993 g_assert (*(gint16*)ptr == method_index);
5994 unbox_tramp_idx = (guint16*)ptr - (guint16*)amodule->info.llvm_unbox_tramp_indexes;
5995 }
5996 g_assert (unbox_tramp_idx < amodule->info.llvm_unbox_tramp_num);
5997 code = ((gpointer*)(amodule->info.llvm_unbox_trampolines))[unbox_tramp_idx];
5998 g_assert (code);
5999 return code;
6000 }
6001
6002 if (amodule->info.llvm_get_unbox_tramp) {
6003 gpointer (*get_tramp) (int) = (gpointer (*)(int))amodule->info.llvm_get_unbox_tramp;
6004 code = get_tramp (method_index);
6005
6006 if (code)
6007 return code;
6008 }
6009
6010 ut = amodule->unbox_trampolines;
6011 ut_end = amodule->unbox_trampolines_end;
6012
6013 /* Do a binary search in the sorted table */
6014 code = NULL;
6015 low = 0;
6016 high = (ut_end - ut);
6017 while (low < high) {
6018 entry_index = (low + high) / 2;
6019 entry = &ut [entry_index];
6020 if (entry [0] < method_index) {
6021 low = entry_index + 1;
6022 } else if (entry [0] > method_index) {
6023 high = entry_index;
6024 } else {
6025 break;
6026 }
6027 }
6028
6029 code = get_call_table_entry (amodule->unbox_trampoline_addresses, entry_index, amodule->info.call_table_entry_size);
6030 g_assert (code);
6031
6032 tinfo = mono_tramp_info_create (NULL, (guint8 *)code, 0, NULL, NULL);
6033
6034 gpointer const symbol_addr = read_unwind_info (amodule, tinfo, "unbox_trampoline_p");
6035 if (!symbol_addr) {
6036 mono_tramp_info_free (tinfo);
6037 return FALSE;
6038 }
6039
6040 tinfo->code_size = *(guint32*)symbol_addr;
6041 mono_aot_tramp_info_register (tinfo, NULL);
6042
6043 /* The caller expects an ftnptr */
6044 return mono_create_ftnptr (mono_domain_get (), code);
6045 }
6046
6047 gpointer
6048 mono_aot_get_lazy_fetch_trampoline (guint32 slot)
6049 {
6050 char *symbol;
6051 gpointer code;
6052 MonoAotModule *amodule = mscorlib_aot_module;
6053 guint32 index = MONO_RGCTX_SLOT_INDEX (slot);
6054 static int count = 0;
6055
6056 count ++;
6057 if (index >= amodule->info.num_rgctx_fetch_trampolines) {
6058 static gpointer addr;
6059 gpointer *info;
6060
6061 /*
6062 * Use the general version of the rgctx fetch trampoline. It receives a pair of <slot, trampoline> in the rgctx arg reg.
6063 */
6064 if (!addr)
6065 addr = load_function (amodule, "rgctx_fetch_trampoline_general");
6066 info = (void **)mono_domain_alloc0 (mono_get_root_domain (), sizeof (gpointer) * 2);
6067 info [0] = GUINT_TO_POINTER (slot);
6068 info [1] = mono_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
6069 code = mono_aot_get_static_rgctx_trampoline (info, addr);
6070 return mono_create_ftnptr (mono_domain_get (), code);
6071 }
6072
6073 symbol = mono_get_rgctx_fetch_trampoline_name (slot);
6074 code = load_function (amodule, symbol);
6075 g_free (symbol);
6076 /* The caller expects an ftnptr */
6077 return mono_create_ftnptr (mono_domain_get (), code);
6078 }
6079
6080 static void
6081 no_imt_trampoline (void)
6082 {
6083 g_assert_not_reached ();
6084 }
6085
6086 gpointer
6087 mono_aot_get_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp)
6088 {
6089 guint32 got_offset;
6090 gpointer code;
6091 gpointer *buf;
6092 int i, index, real_count;
6093 MonoAotModule *amodule;
6094
6095 if (mono_llvm_only)
6096 return (gpointer)no_imt_trampoline;
6097
6098 real_count = 0;
6099 for (i = 0; i < count; ++i) {
6100 MonoIMTCheckItem *item = imt_entries [i];
6101
6102 if (item->is_equals)
6103 real_count ++;
6104 }
6105
6106 /* Save the entries into an array */
6107 buf = (void **)mono_domain_alloc (domain, (real_count + 1) * 2 * sizeof (gpointer));
6108 index = 0;
6109 for (i = 0; i < count; ++i) {
6110 MonoIMTCheckItem *item = imt_entries [i];
6111
6112 if (!item->is_equals)
6113 continue;
6114
6115 g_assert (item->key);
6116
6117 buf [(index * 2)] = item->key;
6118 if (item->has_target_code) {
6119 gpointer *p = (gpointer *)mono_domain_alloc (domain, sizeof (gpointer));
6120 *p = item->value.target_code;
6121 buf [(index * 2) + 1] = p;
6122 } else {
6123 buf [(index * 2) + 1] = &(vtable->vtable [item->value.vtable_slot]);
6124 }
6125 index ++;
6126 }
6127 buf [(index * 2)] = NULL;
6128 buf [(index * 2) + 1] = fail_tramp;
6129
6130 if (USE_PAGE_TRAMPOLINES) {
6131 code = get_new_imt_trampoline_from_page (buf);
6132 } else {
6133 code = get_numerous_trampoline (MONO_AOT_TRAMP_IMT, 1, &amodule, &got_offset, NULL);
6134
6135 amodule->got [got_offset] = buf;
6136 }
6137
6138 return code;
6139 }
6140
6141 gpointer
6142 mono_aot_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr)
6143 {
6144 MonoAotModule *amodule;
6145 guint8 *code;
6146 guint32 got_offset;
6147
6148 if (USE_PAGE_TRAMPOLINES) {
6149 code = (guint8 *)get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
6150 } else {
6151 code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_GSHAREDVT_ARG, 2, &amodule, &got_offset, NULL);
6152
6153 amodule->got [got_offset] = arg;
6154 amodule->got [got_offset + 1] = addr;
6155 }
6156
6157 /* The caller expects an ftnptr */
6158 return mono_create_ftnptr (mono_domain_get (), code);
6159 }
6160
6161 #ifdef MONO_ARCH_HAVE_FTNPTR_ARG_TRAMPOLINE
6162 gpointer
6163 mono_aot_get_ftnptr_arg_trampoline (gpointer arg, gpointer addr)
6164 {
6165 MonoAotModule *amodule;
6166 guint8 *code;
6167 guint32 got_offset;
6168
6169 if (USE_PAGE_TRAMPOLINES) {
6170 g_error ("FIXME: ftnptr_arg page trampolines");
6171 } else {
6172 code = (guint8 *)get_numerous_trampoline (MONO_AOT_TRAMP_FTNPTR_ARG, 2, &amodule, &got_offset, NULL);
6173
6174 amodule->got [got_offset] = arg;
6175 amodule->got [got_offset + 1] = addr;
6176 }
6177
6178 /* The caller expects an ftnptr */
6179 return mono_create_ftnptr (mono_domain_get (), code);
6180 }
6181 #endif
6182
6183
6184 /*
6185 * mono_aot_set_make_unreadable:
6186 *
6187 * Set whenever to make all mmaped memory unreadable. In conjuction with a
6188 * SIGSEGV handler, this is useful to find out which pages the runtime tries to read.
6189 */
6190 void
6191 mono_aot_set_make_unreadable (gboolean unreadable)
6192 {
6193 static int inited;
6194
6195 make_unreadable = unreadable;
6196
6197 if (make_unreadable && !inited) {
6198 mono_counters_register ("AOT: pagefaults", MONO_COUNTER_JIT | MONO_COUNTER_INT, &n_pagefaults);
6199 }
6200 }
6201
6202 typedef struct {
6203 MonoAotModule *module;
6204 guint8 *ptr;
6205 } FindMapUserData;
6206
6207 static void
6208 find_map (gpointer key, gpointer value, gpointer user_data)
6209 {
6210 MonoAotModule *module = (MonoAotModule*)value;
6211 FindMapUserData *data = (FindMapUserData*)user_data;
6212
6213 if (!data->module)
6214 if ((data->ptr >= module->mem_begin) && (data->ptr < module->mem_end))
6215 data->module = module;
6216 }
6217
6218 static MonoAotModule*
6219 find_module_for_addr (void *ptr)
6220 {
6221 FindMapUserData data;
6222
6223 if (!make_unreadable)
6224 return NULL;
6225
6226 data.module = NULL;
6227 data.ptr = (guint8*)ptr;
6228
6229 mono_aot_lock ();
6230 g_hash_table_foreach (aot_modules, (GHFunc)find_map, &data);
6231 mono_aot_unlock ();
6232
6233 return data.module;
6234 }
6235
6236 /*
6237 * mono_aot_is_pagefault:
6238 *
6239 * Should be called from a SIGSEGV signal handler to find out whenever @ptr is
6240 * within memory allocated by this module.
6241 */
6242 gboolean
6243 mono_aot_is_pagefault (void *ptr)
6244 {
6245 if (!make_unreadable)
6246 return FALSE;
6247
6248 /*
6249 * Not signal safe, but SIGSEGV's are synchronous, and
6250 * this is only turned on by a MONO_DEBUG option.
6251 */
6252 return find_module_for_addr (ptr) != NULL;
6253 }
6254
6255 /*
6256 * mono_aot_handle_pagefault:
6257 *
6258 * Handle a pagefault caused by an unreadable page by making it readable again.
6259 */
6260 void
6261 mono_aot_handle_pagefault (void *ptr)
6262 {
6263 #ifndef HOST_WIN32
6264 guint8* start = (guint8*)ROUND_DOWN (((gssize)ptr), mono_pagesize ());
6265 int res;
6266
6267 mono_aot_lock ();
6268 res = mono_mprotect (start, mono_pagesize (), MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_EXEC);
6269 g_assert (res == 0);
6270
6271 n_pagefaults ++;
6272 mono_aot_unlock ();
6273 #endif
6274 }
6275
6276 MonoAotMethodFlags
6277 mono_aot_get_method_flags (guint8 *code)
6278 {
6279 guint32 flags;
6280
6281 if (!code_to_method_flags)
6282 return MONO_AOT_METHOD_FLAG_NONE;
6283 mono_aot_lock ();
6284 /* Not found and no FLAG_NONE are the same, but its not a problem */
6285 flags = GPOINTER_TO_UINT (g_hash_table_lookup (code_to_method_flags, code));
6286 mono_aot_unlock ();
6287 return (MonoAotMethodFlags)flags;
6288 }
6289
6290 #else
6291 /* AOT disabled */
6292
6293 void
6294 mono_aot_init (void)
6295 {
6296 }
6297
6298 void
6299 mono_aot_cleanup (void)
6300 {
6301 }
6302
6303 guint32
6304 mono_aot_find_method_index (MonoMethod *method)
6305 {
6306 g_assert_not_reached ();
6307 return 0;
6308 }
6309
6310 void
6311 mono_aot_init_llvm_method (gpointer aot_module, guint32 method_index)
6312 {
6313 }
6314
6315 gpointer
6316 mono_aot_get_method (MonoDomain *domain,
6317 MonoMethod *method, MonoError *error)
6318 {
6319 error_init (error);
6320 return NULL;
6321 }
6322
6323 gboolean
6324 mono_aot_is_got_entry (guint8 *code, guint8 *addr)
6325 {
6326 return FALSE;
6327 }
6328
6329 gboolean
6330 mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res)
6331 {
6332 return FALSE;
6333 }
6334
6335 gboolean
6336 mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass)
6337 {
6338 return FALSE;
6339 }
6340
6341 MonoJitInfo *
6342 mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr)
6343 {
6344 return NULL;
6345 }
6346
6347 gpointer
6348 mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token, MonoError *error)
6349 {
6350 error_init (error);
6351 return NULL;
6352 }
6353
6354 guint8*
6355 mono_aot_get_plt_entry (guint8 *code)
6356 {
6357 return NULL;
6358 }
6359
6360 gpointer
6361 mono_aot_plt_resolve (gpointer aot_module, guint32 plt_info_offset, guint8 *code, MonoError *error)
6362 {
6363 return NULL;
6364 }
6365
6366 void
6367 mono_aot_patch_plt_entry (guint8 *code, guint8 *plt_entry, gpointer *got, host_mgreg_t *regs, guint8 *addr)
6368 {
6369 }
6370
6371 gpointer
6372 mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int slot, MonoError *error)
6373 {
6374 error_init (error);
6375
6376 return NULL;
6377 }
6378
6379 guint32
6380 mono_aot_get_plt_info_offset (host_mgreg_t *regs, guint8 *code)
6381 {
6382 g_assert_not_reached ();
6383
6384 return 0;
6385 }
6386
6387 gpointer
6388 mono_aot_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
6389 {
6390 g_assert_not_reached ();
6391 return NULL;
6392 }
6393
6394 gpointer
6395 mono_aot_get_static_rgctx_trampoline (gpointer ctx, gpointer addr)
6396 {
6397 g_assert_not_reached ();
6398 return NULL;
6399 }
6400
6401 gpointer
6402 mono_aot_get_trampoline_full (const char *name, MonoTrampInfo **out_tinfo)
6403 {
6404 g_assert_not_reached ();
6405 return NULL;
6406 }
6407
6408 gpointer
6409 mono_aot_get_trampoline (const char *name)
6410 {
6411 g_assert_not_reached ();
6412 return NULL;
6413 }
6414
6415 gpointer
6416 mono_aot_get_unbox_arbitrary_trampoline (gpointer addr)
6417 {
6418 g_assert_not_reached ();
6419 return NULL;
6420 }
6421
6422 gpointer
6423 mono_aot_get_unbox_trampoline (MonoMethod *method, gpointer addr)
6424 {
6425 g_assert_not_reached ();
6426 return NULL;
6427 }
6428
6429 gpointer
6430 mono_aot_get_lazy_fetch_trampoline (guint32 slot)
6431 {
6432 g_assert_not_reached ();
6433 return NULL;
6434 }
6435
6436 gpointer
6437 mono_aot_get_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp)
6438 {
6439 g_assert_not_reached ();
6440 return NULL;
6441 }
6442
6443 gpointer
6444 mono_aot_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr)
6445 {
6446 g_assert_not_reached ();
6447 return NULL;
6448 }
6449
6450 #ifdef MONO_ARCH_HAVE_FTNPTR_ARG_TRAMPOLINE
6451 gpointer
6452 mono_aot_get_ftnptr_arg_trampoline (gpointer arg, gpointer addr)
6453 {
6454 g_assert_not_reached ();
6455 return NULL;
6456 }
6457 #endif
6458
6459 void
6460 mono_aot_set_make_unreadable (gboolean unreadable)
6461 {
6462 }
6463
6464 gboolean
6465 mono_aot_is_pagefault (void *ptr)
6466 {
6467 return FALSE;
6468 }
6469
6470 void
6471 mono_aot_handle_pagefault (void *ptr)
6472 {
6473 }
6474
6475 guint8*
6476 mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len)
6477 {
6478 g_assert_not_reached ();
6479 return NULL;
6480 }
6481
6482 GHashTable *
6483 mono_aot_get_weak_field_indexes (MonoImage *image)
6484 {
6485 return NULL;
6486 }
6487
6488 MonoAotMethodFlags
6489 mono_aot_get_method_flags (guint8 *code)
6490 {
6491 return MONO_AOT_METHOD_FLAG_NONE;
6492 }
6493
6494 gboolean
6495 mono_aot_init_llvmonly_method (gpointer aot_module, guint32 method_index, MonoClass *init_class, MonoError *error)
6496 {
6497 g_assert_not_reached ();
6498 return FALSE;
6499 }
6500
6501 #endif
Mirror of the official Mono project git repository