mono/mini/aot-runtime.c

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