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