mono/mini/mini-trampolines.c

   1 /*
   2  * (C) 2003 Ximian, Inc.
   3  * (C) 2003-2011 Novell, Inc.
   4  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   5  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   6  */
   7 #include <config.h>
   8 #include <glib.h>
   9
  10 #include <mono/metadata/appdomain.h>
  11 #include <mono/metadata/metadata-internals.h>
  12 #include <mono/metadata/marshal.h>
  13 #include <mono/metadata/tabledefs.h>
  14 #include <mono/utils/mono-counters.h>
  15 #include <mono/utils/mono-error-internals.h>
  16 #include <mono/utils/mono-membar.h>
  17 #include <mono/utils/mono-compiler.h>
  18 #include <mono/utils/mono-threads-coop.h>
  19
  20 #include "mini.h"
  21 #include "lldb.h"
  22
  23 #ifdef ENABLE_INTERPRETER
  24 #include "interp/interp.h"
  25 #endif
  26
  27 /*
  28  * Address of the trampoline code.  This is used by the debugger to check
  29  * whether a method is a trampoline.
  30  */
  31 guint8* mono_trampoline_code [MONO_TRAMPOLINE_NUM];
  32
  33 static GHashTable *rgctx_lazy_fetch_trampoline_hash;
  34 static GHashTable *rgctx_lazy_fetch_trampoline_hash_addr;
  35 static guint32 trampoline_calls, jit_trampolines, unbox_trampolines, static_rgctx_trampolines;
  36
  37 #define mono_trampolines_lock() mono_os_mutex_lock (&trampolines_mutex)
  38 #define mono_trampolines_unlock() mono_os_mutex_unlock (&trampolines_mutex)
  39 static mono_mutex_t trampolines_mutex;
  40
  41 #ifdef MONO_ARCH_GSHARED_SUPPORTED
  42
  43 typedef struct {
  44         MonoMethod *m;
  45         gpointer addr;
  46 } RgctxTrampInfo;
  47
  48 static gint
  49 rgctx_tramp_info_equal (gconstpointer ka, gconstpointer kb)
  50 {
  51         const RgctxTrampInfo *i1 = (const RgctxTrampInfo *)ka;
  52         const RgctxTrampInfo *i2 = (const RgctxTrampInfo *)kb;
  53
  54         if (i1->m == i2->m && i1->addr == i2->addr)
  55                 return 1;
  56         else
  57                 return 0;
  58 }
  59
  60 static guint
  61 rgctx_tramp_info_hash (gconstpointer data)
  62 {
  63         const RgctxTrampInfo *info = (const RgctxTrampInfo *)data;
  64
  65         return GPOINTER_TO_UINT (info->m) ^ GPOINTER_TO_UINT (info->addr);
  66 }
  67
  68 /**
  69  * mono_create_static_rgctx_trampoline:
  70  * @m: the mono method to create a trampoline for
  71  * @addr: the address to jump to (where the compiled code for M lives)
  72  *
  73  * Creates a static rgctx trampoline for M which branches to ADDR which should
  74  * point to the compiled code of M.
  75  *
  76  * Static rgctx trampolines are used when a shared generic method which doesn't
  77  * have a this argument is called indirectly, ie. from code which can't pass in
  78  * the rgctx argument. The trampoline sets the rgctx argument and jumps to the
  79  * methods code. These trampolines are similar to the unbox trampolines, they
  80  * perform the same task as the static rgctx wrappers, but they are smaller/faster,
  81  * and can be made to work with full AOT.
  82  *
  83  * On PPC addr should be an ftnptr and the return value is an ftnptr too.
  84  *
  85  * Returns the generated static rgctx trampoline.
  86  */
  87 gpointer
  88 mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr)
  89 {
  90         gpointer ctx;
  91         gpointer res;
  92         MonoDomain *domain;
  93         RgctxTrampInfo tmp_info;
  94         RgctxTrampInfo *info;
  95
  96 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
  97         g_assert (((gpointer*)addr) [2] == 0);
  98 #endif
  99
 100         ctx = mini_method_get_rgctx (m);
 101
 102         domain = mono_domain_get ();
 103
 104         /*
 105          * In the AOT case, addr might point to either the method, or to an unbox trampoline,
 106          * so make the hash keyed on the m+addr pair.
 107          */
 108         mono_domain_lock (domain);
 109         if (!domain_jit_info (domain)->static_rgctx_trampoline_hash)
 110                 domain_jit_info (domain)->static_rgctx_trampoline_hash = g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
 111         tmp_info.m = m;
 112         tmp_info.addr = addr;
 113         res = g_hash_table_lookup (domain_jit_info (domain)->static_rgctx_trampoline_hash,
 114                                                            &tmp_info);
 115         mono_domain_unlock (domain);
 116         if (res)
 117                 return res;
 118
 119         if (mono_aot_only)
 120                 res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
 121         else
 122                 res = mono_arch_get_static_rgctx_trampoline (m, (MonoMethodRuntimeGenericContext *)ctx, addr);
 123
 124         mono_domain_lock (domain);
 125         /* Duplicates inserted while we didn't hold the lock are OK */
 126         info = (RgctxTrampInfo *)mono_domain_alloc (domain, sizeof (RgctxTrampInfo));
 127         info->m = m;
 128         info->addr = addr;
 129         g_hash_table_insert (domain_jit_info (domain)->static_rgctx_trampoline_hash, info, res);
 130         mono_domain_unlock (domain);
 131
 132         static_rgctx_trampolines ++;
 133
 134         return res;
 135 }
 136 #else
 137 gpointer
 138 mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr)
 139 {
 140        /*
 141         * This shouldn't happen as all arches which support generic sharing support
 142         * static rgctx trampolines as well.
 143         */
 144        g_assert_not_reached ();
 145 }
 146 #endif
 147
 148 #if 0
 149 #define DEBUG_IMT(stmt) do { stmt; } while (0)
 150 #else
 151 #define DEBUG_IMT(stmt) do { } while (0)
 152 #endif
 153
 154 /*
 155  * mini_resolve_imt_method:
 156  *
 157  *   Resolve the actual method called when making an IMT call through VTABLE_SLOT with IMT_METHOD as the interface method.
 158  *
 159  * Either IMPL_METHOD or OUT_AOT_ADDR will be set on return.
 160  */
 161 gpointer*
 162 mini_resolve_imt_method (MonoVTable *vt, gpointer *vtable_slot, MonoMethod *imt_method, MonoMethod **impl_method, gpointer *out_aot_addr, gboolean *out_need_rgctx_tramp, MonoMethod **variant_iface, MonoError *error)
 163 {
 164         MonoMethod *impl = NULL, *generic_virtual = NULL;
 165         gboolean lookup_aot, variance_used = FALSE, need_rgctx_tramp = FALSE;
 166         gpointer addr;
 167         guint8 *aot_addr = NULL;
 168         int displacement = vtable_slot - ((gpointer*)vt);
 169         int interface_offset;
 170         int imt_slot = MONO_IMT_SIZE + displacement;
 171
 172         g_assert (imt_slot < MONO_IMT_SIZE);
 173
 174         error_init (error);
 175         /* This has to be variance aware since imt_method can be from an interface that vt->klass doesn't directly implement */
 176         interface_offset = mono_class_interface_offset_with_variance (vt->klass, imt_method->klass, &variance_used);
 177         if (interface_offset < 0)
 178                 g_error ("%s doesn't implement interface %s\n", mono_type_get_name_full (&vt->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL), mono_type_get_name_full (&imt_method->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL));
 179
 180         *variant_iface = NULL;
 181         if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst) {
 182                 /* Generic virtual method */
 183                 generic_virtual = imt_method;
 184                 need_rgctx_tramp = TRUE;
 185         } else if (variance_used && mono_class_has_variant_generic_params (imt_method->klass)) {
 186                 *variant_iface = imt_method;
 187         }
 188
 189         addr = NULL;
 190         /* We can only use the AOT compiled code if we don't require further processing */
 191         lookup_aot = !generic_virtual & !variant_iface;
 192
 193         if (!mono_llvm_only)
 194                 mono_vtable_build_imt_slot (vt, mono_method_get_imt_slot (imt_method));
 195
 196         if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst) {
 197                 MonoGenericContext context = { NULL, NULL };
 198
 199                 /*
 200                  * Generic virtual method, imt_method contains the inflated interface
 201                  * method, need to get the inflated impl method.
 202                  */
 203                 /* imt_method->slot might not be set */
 204                 impl = mono_class_get_vtable_entry (vt->klass, interface_offset + mono_method_get_declaring_generic_method (imt_method)->slot);
 205
 206                 if (mono_class_is_ginst (impl->klass))
 207                         context.class_inst = mono_class_get_generic_class (impl->klass)->context.class_inst;
 208                 context.method_inst = ((MonoMethodInflated*)imt_method)->context.method_inst;
 209                 impl = mono_class_inflate_generic_method_checked (impl, &context, error);
 210                 mono_error_assert_ok (error);
 211         } else {
 212
 213                 /* Avoid loading metadata or creating a generic vtable if possible */
 214                 if (lookup_aot && !vt->klass->valuetype) {
 215                         aot_addr = (guint8 *)mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, interface_offset + mono_method_get_vtable_slot (imt_method), error);
 216                         return_val_if_nok (error, NULL);
 217                 } else {
 218                         aot_addr = NULL;
 219                 }
 220                 if (aot_addr)
 221                         impl = NULL;
 222                 else
 223                         impl = mono_class_get_vtable_entry (vt->klass, interface_offset + mono_method_get_vtable_slot (imt_method));
 224         }
 225
 226         if (impl && mono_method_needs_static_rgctx_invoke (impl, FALSE))
 227                 need_rgctx_tramp = TRUE;
 228         if (impl && impl->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
 229                 WrapperInfo *info = mono_marshal_get_wrapper_info (impl);
 230
 231                 if (info && info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER)
 232                         need_rgctx_tramp = TRUE;
 233         }
 234         *impl_method = impl;
 235         *out_need_rgctx_tramp = need_rgctx_tramp;
 236         *out_aot_addr = aot_addr;
 237
 238         DEBUG_IMT (printf ("mono_convert_imt_slot_to_vtable_slot: method = %s.%s.%s, imt_method = %s.%s.%s\n",
 239                                            method->klass->name_space, method->klass->name, method->name,
 240                                            imt_method->klass->name_space, imt_method->klass->name, imt_method->name));
 241
 242         if (vt->imt_collisions_bitmap & (1 << imt_slot)) {
 243                 int slot = mono_method_get_vtable_index (imt_method);
 244                 int vtable_offset;
 245
 246                 g_assert (slot != -1);
 247                 vtable_offset = interface_offset + slot;
 248                 vtable_slot = & (vt->vtable [vtable_offset]);
 249                 DEBUG_IMT (printf ("mono_convert_imt_slot_to_vtable_slot: slot %p[%d] is in the IMT, and colliding becomes %p[%d] (interface_offset = %d, method->slot = %d)\n", slot, imt_slot, vtable_slot, vtable_offset, interface_offset, imt_method->slot));
 250                 return vtable_slot;
 251         } else {
 252                 DEBUG_IMT (printf ("mono_convert_imt_slot_to_vtable_slot: slot %p[%d] is in the IMT, but not colliding\n", slot, imt_slot));
 253                 return vtable_slot;
 254         }
 255 }
 256
 257 /*
 258  * This is a super-ugly hack to fix bug #616463.
 259  *
 260  * The problem is that we don't always set is_generic for generic
 261  * method definitions.  See the comment at the end of
 262  * mono_class_inflate_generic_method_full_checked() in class.c.
 263  */
 264 static gboolean
 265 is_generic_method_definition (MonoMethod *m)
 266 {
 267         MonoGenericContext *context;
 268         if (m->is_generic)
 269                 return TRUE;
 270         if (!m->is_inflated)
 271                 return FALSE;
 272
 273         context = mono_method_get_context (m);
 274         if (!context->method_inst)
 275                 return FALSE;
 276         if (context->method_inst == mono_method_get_generic_container (((MonoMethodInflated*)m)->declaring)->context.method_inst)
 277                 return TRUE;
 278         return FALSE;
 279 }
 280
 281 gboolean
 282 mini_jit_info_is_gsharedvt (MonoJitInfo *ji)
 283 {
 284         if (ji && ji->has_generic_jit_info && (mono_jit_info_get_generic_sharing_context (ji)->is_gsharedvt))
 285                 return TRUE;
 286         else
 287                 return FALSE;
 288 }
 289
 290 /**
 291  * mini_add_method_trampoline:
 292  * @m:
 293  * @compiled_method:
 294  * @add_static_rgctx_tramp: adds a static rgctx trampoline
 295  * @add_unbox_tramp: adds an unboxing trampoline
 296  *
 297  * Add static rgctx/gsharedvt_in/unbox trampolines to
 298  * M/COMPILED_METHOD if needed.
 299  *
 300  * Returns the trampoline address, or COMPILED_METHOD if no trampoline
 301  * is needed.
 302  */
 303 gpointer
 304 mini_add_method_trampoline (MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp)
 305 {
 306         gpointer addr = compiled_method;
 307         gboolean callee_gsharedvt, callee_array_helper;
 308         MonoMethod *jmethod = NULL;
 309         MonoJitInfo *ji;
 310
 311         // FIXME: This loads information from AOT (perf problem)
 312         ji = mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
 313         callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
 314
 315         callee_array_helper = FALSE;
 316         if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
 317                 WrapperInfo *info = mono_marshal_get_wrapper_info (m);
 318
 319                 /*
 320                  * generic array helpers.
 321                  * Have to replace the wrappers with the original generic instances.
 322                  */
 323                 if (info && info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER) {
 324                         callee_array_helper = TRUE;
 325                         m = info->d.generic_array_helper.method;
 326                 }
 327         } else if (m->wrapper_type == MONO_WRAPPER_UNKNOWN) {
 328                 WrapperInfo *info = mono_marshal_get_wrapper_info (m);
 329
 330                 /* Same for synchronized inner wrappers */
 331                 if (info && info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER) {
 332                         m = info->d.synchronized_inner.method;
 333                 }
 334         }
 335
 336         if (callee_gsharedvt)
 337                 g_assert (m->is_inflated);
 338
 339         addr = compiled_method;
 340
 341         if (add_unbox_tramp) {
 342                 /*
 343                  * The unbox trampolines call the method directly, so need to add
 344                  * an rgctx tramp before them.
 345                  */
 346                 if (mono_aot_only) {
 347                         addr = mono_aot_get_unbox_trampoline (m);
 348                 } else {
 349                         unbox_trampolines ++;
 350                         addr = mono_arch_get_unbox_trampoline (m, addr);
 351                 }
 352         }
 353
 354         if (ji && !ji->is_trampoline)
 355                 jmethod = jinfo_get_method (ji);
 356         if (callee_gsharedvt && mini_is_gsharedvt_variable_signature (mono_method_signature (jmethod))) {
 357                 MonoMethodSignature *sig, *gsig;
 358
 359                 /* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
 360
 361                 /* Call from normal/gshared code to gsharedvt code with variable signature */
 362                 sig = mono_method_signature (m);
 363                 gsig = mono_method_signature (jmethod);
 364
 365                 addr = mini_get_gsharedvt_wrapper (TRUE, addr, sig, gsig, -1, FALSE);
 366
 367                 if (mono_llvm_only)
 368                         g_assert_not_reached ();
 369                 //printf ("IN: %s\n", mono_method_full_name (m, TRUE));
 370         }
 371
 372         if (callee_array_helper) {
 373                 add_static_rgctx_tramp = FALSE;
 374                 /* In AOT mode, compiled_method points to one of the InternalArray methods in Array. */
 375                 if (ji && !mono_llvm_only && mono_method_needs_static_rgctx_invoke (jinfo_get_method (ji), TRUE))
 376                         add_static_rgctx_tramp = TRUE;
 377         }
 378
 379         if (mono_llvm_only)
 380                 add_static_rgctx_tramp = FALSE;
 381
 382         if (add_static_rgctx_tramp)
 383                 addr = mono_create_static_rgctx_trampoline (m, addr);
 384
 385         return addr;
 386 }
 387
 388 /*
 389  * mini_create_llvmonly_ftndesc:
 390  *
 391  *   Create a function descriptor of the form <addr, arg>, which
 392  * represents a callee ADDR with ARG as the last argument.
 393  * This is used for:
 394  * - generic sharing (ARG is the rgctx)
 395  * - gsharedvt signature wrappers (ARG is a function descriptor)
 396  */
 397 MonoFtnDesc*
 398 mini_create_llvmonly_ftndesc (MonoDomain *domain, gpointer addr, gpointer arg)
 399 {
 400         MonoFtnDesc *ftndesc = (MonoFtnDesc*)mono_domain_alloc0 (mono_domain_get (), 2 * sizeof (gpointer));
 401         ftndesc->addr = addr;
 402         ftndesc->arg = arg;
 403
 404         return ftndesc;
 405 }
 406
 407 /**
 408  * mini_add_method_wrappers_llvmonly:
 409  *
 410  *   Add unbox/gsharedvt wrappers around COMPILED_METHOD if needed. Return the wrapper address or COMPILED_METHOD
 411  * if no wrapper is needed. Set OUT_ARG to the rgctx/extra argument needed to be passed to the returned method.
 412  */
 413 gpointer
 414 mini_add_method_wrappers_llvmonly (MonoMethod *m, gpointer compiled_method, gboolean caller_gsharedvt, gboolean add_unbox_tramp, gpointer *out_arg)
 415 {
 416         gpointer addr;
 417         gboolean callee_gsharedvt, callee_array_helper;
 418         MonoMethod *jmethod = NULL;
 419         MonoJitInfo *ji;
 420
 421         // FIXME: This loads information from AOT (perf problem)
 422         ji = mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
 423         callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
 424
 425         callee_array_helper = FALSE;
 426         if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
 427                 WrapperInfo *info = mono_marshal_get_wrapper_info (m);
 428
 429                 /*
 430                  * generic array helpers.
 431                  * Have to replace the wrappers with the original generic instances.
 432                  */
 433                 if (info && info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER) {
 434                         callee_array_helper = TRUE;
 435                         m = info->d.generic_array_helper.method;
 436                 }
 437         } else if (m->wrapper_type == MONO_WRAPPER_UNKNOWN) {
 438                 WrapperInfo *info = mono_marshal_get_wrapper_info (m);
 439
 440                 /* Same for synchronized inner wrappers */
 441                 if (info && info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER) {
 442                         m = info->d.synchronized_inner.method;
 443                 }
 444         }
 445
 446         if (callee_gsharedvt)
 447                 g_assert (m->is_inflated);
 448
 449         addr = compiled_method;
 450
 451         if (add_unbox_tramp) {
 452                 /*
 453                  * The unbox trampolines call the method directly, so need to add
 454                  * an rgctx tramp before them.
 455                  */
 456                 if (mono_aot_only) {
 457                         addr = mono_aot_get_unbox_trampoline (m);
 458                 } else {
 459                         unbox_trampolines ++;
 460                         addr = mono_arch_get_unbox_trampoline (m, addr);
 461                 }
 462         }
 463
 464         g_assert (mono_llvm_only);
 465         g_assert (out_arg);
 466
 467         if (ji && !ji->is_trampoline)
 468                 jmethod = jinfo_get_method (ji);
 469
 470         if (callee_gsharedvt)
 471                 callee_gsharedvt = mini_is_gsharedvt_variable_signature (mono_method_signature (jmethod));
 472
 473         if (!caller_gsharedvt && callee_gsharedvt) {
 474                 MonoMethodSignature *sig, *gsig;
 475                 gpointer wrapper_addr;
 476
 477                 /* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
 478
 479                 /* Call from normal/gshared code to gsharedvt code with variable signature */
 480                 sig = mono_method_signature (m);
 481                 gsig = mono_method_signature (jmethod);
 482
 483                 wrapper_addr = mini_get_gsharedvt_wrapper (TRUE, addr, sig, gsig, -1, FALSE);
 484
 485                 /*
 486                  * This is a gsharedvt in wrapper, it gets passed a ftndesc for the gsharedvt method as an argument.
 487                  */
 488                 *out_arg = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, mini_method_get_rgctx (m));
 489                 addr = wrapper_addr;
 490                 //printf ("IN: %s\n", mono_method_full_name (m, TRUE));
 491         }
 492
 493         if (!(*out_arg) && mono_method_needs_static_rgctx_invoke (m, FALSE))
 494                 *out_arg = mini_method_get_rgctx (m);
 495
 496         if (caller_gsharedvt && !callee_gsharedvt) {
 497                 /*
 498                  * The callee uses the gsharedvt calling convention, have to add an out wrapper.
 499                  */
 500                 gpointer out_wrapper = mini_get_gsharedvt_wrapper (FALSE, NULL, mono_method_signature (m), NULL, -1, FALSE);
 501                 MonoFtnDesc *out_wrapper_arg = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, *out_arg);
 502
 503                 addr = out_wrapper;
 504                 *out_arg = out_wrapper_arg;
 505         }
 506
 507         return addr;
 508 }
 509
 510 /**
 511  * common_call_trampoline:
 512  *
 513  *   The code to handle normal, virtual, and interface method calls and jumps, both
 514  * from JITted and LLVM compiled code.
 515  */
 516 static gpointer
 517 common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable *vt, gpointer *vtable_slot, MonoError *error)
 518 {
 519         gpointer addr, compiled_method;
 520         gboolean generic_shared = FALSE;
 521         gboolean need_unbox_tramp = FALSE;
 522         gboolean need_rgctx_tramp = FALSE;
 523         MonoMethod *declaring = NULL;
 524         MonoMethod *generic_virtual = NULL, *variant_iface = NULL;
 525         int context_used;
 526         gboolean imt_call, virtual_;
 527         gpointer *orig_vtable_slot, *vtable_slot_to_patch = NULL;
 528         MonoJitInfo *ji = NULL;
 529
 530         error_init (error);
 531
 532         virtual_ = vt && (gpointer)vtable_slot > (gpointer)vt;
 533         imt_call = vt && (gpointer)vtable_slot < (gpointer)vt;
 534
 535         /*
 536          * rgctx trampolines are needed when the call is indirect so the caller can't pass
 537          * the rgctx argument needed by the callee.
 538          */
 539         if (virtual_ && m)
 540                 need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, FALSE);
 541
 542         orig_vtable_slot = vtable_slot;
 543         vtable_slot_to_patch = vtable_slot;
 544
 545         /* IMT call */
 546         if (imt_call) {
 547                 MonoMethod *imt_method = NULL, *impl_method = NULL;
 548                 MonoObject *this_arg;
 549
 550                 g_assert (vtable_slot);
 551
 552                 imt_method = mono_arch_find_imt_method (regs, code);
 553                 this_arg = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
 554
 555                 if (mono_object_is_transparent_proxy (this_arg)) {
 556                         /* Use the slow path for now */
 557                     m = mono_object_get_virtual_method (this_arg, imt_method);
 558                         vtable_slot_to_patch = NULL;
 559                 } else {
 560                         if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst) {
 561                                 /* Generic virtual method */
 562                                 generic_virtual = imt_method;
 563                                 need_rgctx_tramp = TRUE;
 564                         }
 565
 566                         vtable_slot = mini_resolve_imt_method (vt, vtable_slot, imt_method, &impl_method, &addr, &need_rgctx_tramp, &variant_iface, error);
 567                         return_val_if_nok (error, NULL);
 568
 569                         /* This is the vcall slot which gets called through the IMT trampoline */
 570                         vtable_slot_to_patch = vtable_slot;
 571
 572                         if (addr) {
 573                                 /*
 574                                  * We found AOT compiled code for the method, skip the rest.
 575                                  */
 576                                 if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot))
 577                                         *vtable_slot = addr;
 578
 579                                 return mono_create_ftnptr (mono_domain_get (), addr);
 580                         }
 581
 582                         m = impl_method;
 583                 }
 584         }
 585
 586         /*
 587          * The virtual check is needed because is_generic_method_definition (m) could
 588          * return TRUE for methods used in IMT calls too.
 589          */
 590         if (virtual_ && is_generic_method_definition (m)) {
 591                 MonoGenericContext context = { NULL, NULL };
 592                 MonoMethod *declaring;
 593
 594                 if (m->is_inflated)
 595                         declaring = mono_method_get_declaring_generic_method (m);
 596                 else
 597                         declaring = m;
 598
 599                 if (mono_class_is_ginst (m->klass))
 600                         context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
 601                 else
 602                         g_assert (!mono_class_is_gtd (m->klass));
 603
 604                 generic_virtual = mono_arch_find_imt_method (regs, code);
 605                 g_assert (generic_virtual);
 606                 g_assert (generic_virtual->is_inflated);
 607                 context.method_inst = ((MonoMethodInflated*)generic_virtual)->context.method_inst;
 608
 609                 m = mono_class_inflate_generic_method_checked (declaring, &context, error);
 610                 mono_error_assert_ok (error);
 611                 /* FIXME: only do this if the method is sharable */
 612                 need_rgctx_tramp = TRUE;
 613         } else if ((context_used = mono_method_check_context_used (m))) {
 614                 MonoClass *klass = NULL;
 615                 MonoMethod *actual_method = NULL;
 616                 MonoVTable *vt = NULL;
 617                 MonoGenericInst *method_inst = NULL;
 618
 619                 vtable_slot = NULL;
 620                 generic_shared = TRUE;
 621
 622                 g_assert (code);
 623
 624                 /*
 625                  * The caller is gshared code, compute the actual method to call from M and this/rgctx.
 626                  */
 627                 if (m->is_inflated && mono_method_get_context (m)->method_inst) {
 628                         MonoMethodRuntimeGenericContext *mrgctx = (MonoMethodRuntimeGenericContext*)mono_arch_find_static_call_vtable (regs, code);
 629
 630                         klass = mrgctx->class_vtable->klass;
 631                         method_inst = mrgctx->method_inst;
 632                 } else if ((m->flags & METHOD_ATTRIBUTE_STATIC) || m->klass->valuetype) {
 633                         MonoVTable *vtable = mono_arch_find_static_call_vtable (regs, code);
 634
 635                         klass = vtable->klass;
 636                 } else {
 637                         MonoObject *this_argument = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
 638
 639                         vt = this_argument->vtable;
 640                         vtable_slot = orig_vtable_slot;
 641
 642                         g_assert (this_argument->vtable->klass->inited);
 643
 644                         if (!vtable_slot) {
 645                                 mono_class_setup_supertypes (this_argument->vtable->klass);
 646                                 klass = this_argument->vtable->klass->supertypes [m->klass->idepth - 1];
 647                         }
 648                 }
 649
 650                 g_assert (vtable_slot || klass);
 651
 652                 if (vtable_slot) {
 653                         int displacement = vtable_slot - ((gpointer*)vt);
 654
 655                         g_assert_not_reached ();
 656
 657                         g_assert (displacement > 0);
 658
 659                         actual_method = vt->klass->vtable [displacement];
 660                 }
 661
 662                 if (method_inst || m->wrapper_type) {
 663                         MonoGenericContext context = { NULL, NULL };
 664
 665                         if (m->is_inflated)
 666                                 declaring = mono_method_get_declaring_generic_method (m);
 667                         else
 668                                 declaring = m;
 669
 670                         if (mono_class_is_ginst (klass))
 671                                 context.class_inst = mono_class_get_generic_class (klass)->context.class_inst;
 672                         else if (mono_class_is_gtd (klass))
 673                                 context.class_inst = mono_class_get_generic_container (klass)->context.class_inst;
 674                         context.method_inst = method_inst;
 675
 676                         actual_method = mono_class_inflate_generic_method_checked (declaring, &context, error);
 677                         mono_error_assert_ok (error);
 678                 } else {
 679                         actual_method = mono_class_get_method_generic (klass, m);
 680                 }
 681
 682                 g_assert (klass);
 683                 g_assert (actual_method);
 684                 g_assert (actual_method->klass == klass);
 685
 686                 if (actual_method->is_inflated)
 687                         declaring = mono_method_get_declaring_generic_method (actual_method);
 688                 else
 689                         declaring = NULL;
 690
 691                 m = actual_method;
 692         }
 693
 694         if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) {
 695                 m = mono_marshal_get_synchronized_wrapper (m);
 696                 need_rgctx_tramp = FALSE;
 697         }
 698
 699         /* Calls made through delegates on platforms without delegate trampolines */
 700         if (!code && mono_method_needs_static_rgctx_invoke (m, FALSE))
 701                 need_rgctx_tramp = TRUE;
 702
 703         addr = compiled_method = mono_jit_compile_method (m, error);
 704         if (!addr)
 705                 return NULL;
 706
 707         if (generic_virtual || variant_iface) {
 708                 if (vt->klass->valuetype) /*FIXME is this required variant iface?*/
 709                         need_unbox_tramp = TRUE;
 710         } else if (orig_vtable_slot) {
 711                 if (m->klass->valuetype)
 712                         need_unbox_tramp = TRUE;
 713         }
 714
 715         addr = mini_add_method_trampoline (m, compiled_method, need_rgctx_tramp, need_unbox_tramp);
 716
 717         if (generic_virtual || variant_iface) {
 718                 MonoMethod *target = generic_virtual ? generic_virtual : variant_iface;
 719
 720                 vtable_slot = orig_vtable_slot;
 721                 g_assert (vtable_slot);
 722
 723                 mono_method_add_generic_virtual_invocation (mono_domain_get (),
 724                                                                                                         vt, vtable_slot,
 725                                                                                                         target, addr);
 726
 727                 return addr;
 728         }
 729
 730         /* the method was jumped to */
 731         if (!code) {
 732                 MonoDomain *domain = mono_domain_get ();
 733
 734                 /* Patch the got entries pointing to this method */
 735                 /*
 736                  * We do this here instead of in mono_codegen () to cover the case when m
 737                  * was loaded from an aot image.
 738                  */
 739                 if (domain_jit_info (domain)->jump_target_got_slot_hash) {
 740                         GSList *list, *tmp;
 741
 742                         mono_domain_lock (domain);
 743                         list = (GSList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_got_slot_hash, m);
 744                         if (list) {
 745                                 for (tmp = list; tmp; tmp = tmp->next) {
 746                                         gpointer *got_slot = (gpointer *)tmp->data;
 747                                         *got_slot = addr;
 748                                 }
 749                                 g_hash_table_remove (domain_jit_info (domain)->jump_target_got_slot_hash, m);
 750                                 g_slist_free (list);
 751                         }
 752                         mono_domain_unlock (domain);
 753                 }
 754
 755                 return addr;
 756         }
 757
 758         vtable_slot = orig_vtable_slot;
 759
 760         if (vtable_slot) {
 761                 if (vtable_slot_to_patch && (mono_aot_is_got_entry (code, (guint8*)vtable_slot_to_patch) || mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot_to_patch))) {
 762                         g_assert (*vtable_slot_to_patch);
 763                         *vtable_slot_to_patch = mono_get_addr_from_ftnptr (addr);
 764                 }
 765         } else {
 766                 guint8 *plt_entry = mono_aot_get_plt_entry (code);
 767                 gboolean no_patch = FALSE;
 768                 MonoJitInfo *target_ji;
 769
 770                 if (plt_entry) {
 771                         if (generic_shared) {
 772                                 target_ji =
 773                                         mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
 774                                 if (!ji)
 775                                         ji = mini_jit_info_table_find (mono_domain_get (), (char*)code, NULL);
 776
 777                                 if (ji && target_ji && generic_shared && ji->has_generic_jit_info && !target_ji->has_generic_jit_info) {
 778                                         no_patch = TRUE;
 779                                 }
 780                         }
 781                         if (!no_patch)
 782                                 mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, (guint8 *)addr);
 783                 } else {
 784                         if (generic_shared) {
 785                                 if (m->wrapper_type != MONO_WRAPPER_NONE)
 786                                         m = mono_marshal_method_from_wrapper (m);
 787                                 //g_assert (mono_method_is_generic_sharable (m, FALSE));
 788                         }
 789
 790                         /* Patch calling code */
 791                         target_ji =
 792                                 mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method), NULL);
 793                         if (!ji)
 794                                 ji = mini_jit_info_table_find (mono_domain_get (), (char*)code, NULL);
 795
 796                         if (ji && target_ji && generic_shared && ji->has_generic_jit_info && !target_ji->has_generic_jit_info) {
 797                                 /*
 798                                  * Can't patch the call as the caller is gshared, but the callee is not. Happens when
 799                                  * generic sharing fails.
 800                                  * FIXME: Performance problem.
 801                                  */
 802                                 no_patch = TRUE;
 803                         }
 804 #if LLVM_API_VERSION > 100
 805                         /* LLVM code doesn't make direct calls */
 806                         if (ji && ji->from_llvm)
 807                                 no_patch = TRUE;
 808 #endif
 809                         if (!no_patch && mono_method_same_domain (ji, target_ji))
 810                                 mono_arch_patch_callsite ((guint8 *)ji->code_start, code, (guint8 *)addr);
 811                 }
 812         }
 813
 814         return addr;
 815 }
 816
 817 /**
 818  * mono_magic_trampoline:
 819  *
 820  * This trampoline handles normal calls from JITted code.
 821  */
 822 gpointer
 823 mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp)
 824 {
 825         gpointer res;
 826
 827         MONO_ENTER_GC_UNSAFE_UNBALANCED;
 828
 829         MonoError error;
 830
 831         trampoline_calls ++;
 832
 833         res = common_call_trampoline (regs, code, (MonoMethod *)arg, NULL, NULL, &error);
 834         mono_error_set_pending_exception (&error);
 835
 836         mono_interruption_checkpoint_from_trampoline ();
 837
 838         MONO_EXIT_GC_UNSAFE_UNBALANCED;
 839
 840         return res;
 841 }
 842
 843 /**
 844  * mono_vcall_trampoline:
 845  *
 846  * This trampoline handles virtual calls.
 847  */
 848 static gpointer
 849 mono_vcall_trampoline (mgreg_t *regs, guint8 *code, int slot, guint8 *tramp)
 850 {
 851         MONO_REQ_GC_UNSAFE_MODE;
 852
 853         MonoObject *this_arg;
 854         MonoVTable *vt;
 855         gpointer *vtable_slot;
 856         MonoMethod *m;
 857         MonoError error;
 858         gpointer addr, res = NULL;
 859
 860         trampoline_calls ++;
 861
 862         /*
 863          * We need to obtain the following pieces of information:
 864          * - the method which needs to be compiled.
 865          * - the vtable slot.
 866          * We use one vtable trampoline per vtable slot index, so we need only the vtable,
 867          * the other two can be computed from the vtable + the slot index.
 868          */
 869
 870         /*
 871          * Obtain the vtable from the 'this' arg.
 872          */
 873         this_arg = (MonoObject *)mono_arch_get_this_arg_from_call (regs, code);
 874         g_assert (this_arg);
 875
 876         vt = this_arg->vtable;
 877
 878         if (slot >= 0) {
 879                 /* Normal virtual call */
 880                 vtable_slot = &(vt->vtable [slot]);
 881
 882                 /* Avoid loading metadata or creating a generic vtable if possible */
 883                 addr = mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, slot, &error);
 884                 if (!is_ok (&error))
 885                         goto leave;
 886                 if (addr && !vt->klass->valuetype) {
 887                         if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot))
 888                                 *vtable_slot = addr;
 889
 890                         return mono_create_ftnptr (mono_domain_get (), addr);
 891                 }
 892
 893                 /*
 894                  * Bug #616463 (see
 895                  * is_generic_method_definition() above) also
 896                  * goes away if we do a
 897                  * mono_class_setup_vtable (vt->klass) here,
 898                  * because we then inflate the method
 899                  * correctly, put it in the cache, and the
 900                  * "wrong" inflation invocation still looks up
 901                  * the correctly inflated method.
 902                  *
 903                  * The hack above seems more stable and
 904                  * trustworthy.
 905                  */
 906                 m = mono_class_get_vtable_entry (vt->klass, slot);
 907         } else {
 908                 /* IMT call */
 909                 vtable_slot = &(((gpointer*)vt) [slot]);
 910
 911                 m = NULL;
 912         }
 913
 914         res = common_call_trampoline (regs, code, m, vt, vtable_slot, &error);
 915 leave:
 916         if (!mono_error_ok (&error)) {
 917                 mono_error_set_pending_exception (&error);
 918                 return NULL;
 919         }
 920         return res;
 921 }
 922
 923 #ifndef DISABLE_REMOTING
 924 gpointer
 925 mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp)
 926 {
 927         MONO_REQ_GC_UNSAFE_MODE;
 928
 929         MonoError error;
 930         MonoGenericContext context = { NULL, NULL };
 931         MonoMethod *imt_method, *declaring;
 932         gpointer addr;
 933
 934         trampoline_calls ++;
 935
 936         g_assert (m->is_generic);
 937
 938         if (m->is_inflated)
 939                 declaring = mono_method_get_declaring_generic_method (m);
 940         else
 941                 declaring = m;
 942
 943         if (mono_class_is_ginst (m->klass))
 944                 context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
 945         else
 946                 g_assert (!mono_class_is_gtd (m->klass));
 947
 948         imt_method = mono_arch_find_imt_method (regs, code);
 949         if (imt_method->is_inflated)
 950                 context.method_inst = ((MonoMethodInflated*)imt_method)->context.method_inst;
 951         m = mono_class_inflate_generic_method_checked (declaring, &context, &error);
 952         g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */;
 953         m = mono_marshal_get_remoting_invoke_with_check (m);
 954
 955         addr = mono_jit_compile_method (m, &error);
 956         if (!mono_error_ok (&error)) {
 957                 mono_error_set_pending_exception (&error);
 958                 return NULL;
 959         }
 960         g_assert (addr);
 961
 962         return addr;
 963 }
 964 #endif
 965
 966 /**
 967  * mono_aot_trampoline:
 968  *
 969  * This trampoline handles calls made from AOT code. We try to bypass the
 970  * normal JIT compilation logic to avoid loading the metadata for the method.
 971  */
 972 #ifdef MONO_ARCH_AOT_SUPPORTED
 973 gpointer
 974 mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
 975                                          guint8* tramp)
 976 {
 977         MONO_REQ_GC_UNSAFE_MODE;
 978
 979         MonoImage *image;
 980         guint32 token;
 981         MonoMethod *method = NULL;
 982         gpointer addr;
 983         guint8 *plt_entry;
 984         MonoError error;
 985
 986         trampoline_calls ++;
 987
 988         image = (MonoImage *)*(gpointer*)(gpointer)token_info;
 989         token_info += sizeof (gpointer);
 990         token = *(guint32*)(gpointer)token_info;
 991
 992         addr = mono_aot_get_method_from_token (mono_domain_get (), image, token, &error);
 993         if (!is_ok (&error))
 994                 mono_error_cleanup (&error);
 995         if (!addr) {
 996                 method = mono_get_method_checked (image, token, NULL, NULL, &error);
 997                 if (!method)
 998                         g_error ("Could not load AOT trampoline due to %s", mono_error_get_message (&error));
 999
1000                 /* Use the generic code */
1001                 return mono_magic_trampoline (regs, code, method, tramp);
1002         }
1003
1004         addr = mono_create_ftnptr (mono_domain_get (), addr);
1005
1006         /* This is a normal call through a PLT entry */
1007         plt_entry = mono_aot_get_plt_entry (code);
1008         g_assert (plt_entry);
1009
1010         mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, (guint8 *)addr);
1011
1012         return addr;
1013 }
1014
1015 /*
1016  * mono_aot_plt_trampoline:
1017  *
1018  *   This trampoline handles calls made from AOT code through the PLT table.
1019  */
1020 gpointer
1021 mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *aot_module,
1022                                                  guint8* tramp)
1023 {
1024         MONO_REQ_GC_UNSAFE_MODE;
1025
1026         guint32 plt_info_offset = mono_aot_get_plt_info_offset (regs, code);
1027         gpointer res;
1028         MonoError error;
1029
1030         trampoline_calls ++;
1031
1032         res = mono_aot_plt_resolve (aot_module, plt_info_offset, code, &error);
1033         if (!res) {
1034                 if (!mono_error_ok (&error)) {
1035                         mono_error_set_pending_exception (&error);
1036                         return NULL;
1037                 }
1038                 // FIXME: Error handling (how ?)
1039                 g_assert (res);
1040         }
1041
1042         return res;
1043 }
1044 #endif
1045
1046 static gpointer
1047 mono_rgctx_lazy_fetch_trampoline (mgreg_t *regs, guint8 *code, gpointer data, guint8 *tramp)
1048 {
1049         MONO_REQ_GC_UNSAFE_MODE;
1050
1051         static gboolean inited = FALSE;
1052         static int num_lookups = 0;
1053         guint32 slot = GPOINTER_TO_UINT (data);
1054         mgreg_t *r = (mgreg_t*)regs;
1055         gpointer arg = (gpointer)(gssize)r [MONO_ARCH_VTABLE_REG];
1056         guint32 index = MONO_RGCTX_SLOT_INDEX (slot);
1057         gboolean mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
1058         MonoError error;
1059         gpointer res;
1060
1061         trampoline_calls ++;
1062
1063         if (!inited) {
1064                 mono_counters_register ("RGCTX unmanaged lookups", MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &num_lookups);
1065                 inited = TRUE;
1066         }
1067
1068         num_lookups++;
1069
1070         if (mrgctx)
1071                 res = mono_method_fill_runtime_generic_context ((MonoMethodRuntimeGenericContext *)arg, index, &error);
1072         else
1073                 res = mono_class_fill_runtime_generic_context ((MonoVTable *)arg, index, &error);
1074         if (!mono_error_ok (&error)) {
1075                 mono_error_set_pending_exception (&error);
1076                 return NULL;
1077         }
1078         return res;
1079 }
1080
1081 /**
1082  * mono_delegate_trampoline:
1083  *
1084  *   This trampoline handles calls made to Delegate:Invoke ().
1085  * This is called once the first time a delegate is invoked, so it must be fast.
1086  */
1087 gpointer
1088 mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *arg, guint8* tramp)
1089 {
1090         MONO_REQ_GC_UNSAFE_MODE;
1091
1092         MonoDomain *domain = mono_domain_get ();
1093         MonoDelegate *delegate;
1094         MonoJitInfo *ji;
1095         MonoMethod *m;
1096         MonoMethod *method = NULL;
1097         MonoError error;
1098         gboolean multicast, callvirt = FALSE, closed_over_null = FALSE;
1099         gboolean need_rgctx_tramp = FALSE;
1100         gboolean need_unbox_tramp = FALSE;
1101         gboolean enable_caching = TRUE;
1102         MonoDelegateTrampInfo *tramp_info = (MonoDelegateTrampInfo*)arg;
1103         MonoMethod *invoke = tramp_info->invoke;
1104         guint8 *impl_this = (guint8 *)tramp_info->impl_this;
1105         guint8 *impl_nothis = (guint8 *)tramp_info->impl_nothis;
1106         MonoError err;
1107         MonoMethodSignature *sig;
1108         gpointer addr, compiled_method;
1109         gboolean is_remote = FALSE;
1110
1111         trampoline_calls ++;
1112
1113         /* Obtain the delegate object according to the calling convention */
1114         delegate = (MonoDelegate *)mono_arch_get_this_arg_from_call (regs, code);
1115         g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
1116
1117         if (delegate->method) {
1118                 method = delegate->method;
1119
1120                 /*
1121                  * delegate->method_ptr == NULL means the delegate was initialized by
1122                  * mini_delegate_ctor, while != NULL means it is initialized by
1123                  * mono_delegate_ctor_with_method (). In both cases, we need to add wrappers
1124                  * (ctor_with_method () does this, but it doesn't store the wrapper back into
1125                  * delegate->method).
1126                  */
1127 #ifndef DISABLE_REMOTING
1128                 if (delegate->target && mono_object_is_transparent_proxy (delegate->target)) {
1129                         is_remote = TRUE;
1130 #ifndef DISABLE_COM
1131                         if (((MonoTransparentProxy *)delegate->target)->remote_class->proxy_class != mono_class_get_com_object_class () &&
1132                            !mono_class_is_com_object (((MonoTransparentProxy *)delegate->target)->remote_class->proxy_class))
1133 #endif
1134                                 method = mono_marshal_get_remoting_invoke (method);
1135                 }
1136 #endif
1137                 if (!is_remote) {
1138                         sig = tramp_info->sig;
1139                         if (!(sig && method == tramp_info->method)) {
1140                                 error_init (&err);
1141                                 sig = mono_method_signature_checked (method, &err);
1142                                 if (!sig) {
1143                                         mono_error_set_pending_exception (&err);
1144                                         return NULL;
1145                                 }
1146                         }
1147
1148                         if (sig->hasthis && method->klass->valuetype) {
1149                                 gboolean need_unbox = TRUE;
1150
1151                                 if (tramp_info->invoke_sig->param_count > sig->param_count && tramp_info->invoke_sig->params [0]->byref)
1152                                         need_unbox = FALSE;
1153
1154                                 if (need_unbox) {
1155                                         if (mono_aot_only)
1156                                                 need_unbox_tramp = TRUE;
1157                                         else
1158                                                 method = mono_marshal_get_unbox_wrapper (method);
1159                                 }
1160                         }
1161                 }
1162         // If "delegate->method_ptr" is null mono_get_addr_from_ftnptr will fail if
1163         // ftnptrs are being used.  "method" would end up null on archtitectures without
1164         // ftnptrs so we can just skip this.
1165         } else if (delegate->method_ptr) {
1166                 ji = mono_jit_info_table_find (domain, (char *)mono_get_addr_from_ftnptr (delegate->method_ptr));
1167                 if (ji)
1168                         method = jinfo_get_method (ji);
1169         }
1170
1171         if (method) {
1172                 sig = tramp_info->sig;
1173                 if (!(sig && method == tramp_info->method)) {
1174                         error_init (&err);
1175                         sig = mono_method_signature_checked (method, &err);
1176                         if (!sig) {
1177                                 mono_error_set_pending_exception (&err);
1178                                 return NULL;
1179                         }
1180                 }
1181
1182                 callvirt = !delegate->target && sig->hasthis;
1183                 if (callvirt)
1184                         closed_over_null = tramp_info->invoke_sig->param_count == sig->param_count;
1185
1186                 if (callvirt && !closed_over_null) {
1187                         /*
1188                          * The delegate needs to make a virtual call to the target method using its
1189                          * first argument as the receiver. This is hard to support in full-aot, so
1190                          * optimize it in some cases if possible.
1191                          * If the target method is not virtual or is in a sealed class,
1192                          * the vcall will call it directly.
1193                          * If the call doesn't return a valuetype, then the vcall uses the same calling
1194                          * convention as a normal call.
1195                          */
1196                         if ((mono_class_is_sealed (method->klass) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) && !MONO_TYPE_ISSTRUCT (sig->ret)) {
1197                                 callvirt = FALSE;
1198                                 enable_caching = FALSE;
1199                         }
1200                 }
1201
1202                 if (delegate->target &&
1203                         method->flags & METHOD_ATTRIBUTE_VIRTUAL &&
1204                         method->flags & METHOD_ATTRIBUTE_ABSTRACT &&
1205                         mono_class_is_abstract (method->klass)) {
1206                         method = mono_object_get_virtual_method (delegate->target, method);
1207                         enable_caching = FALSE;
1208                 }
1209
1210                 if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1211                         method = mono_marshal_get_synchronized_wrapper (method);
1212
1213                 if (method == tramp_info->method)
1214                         need_rgctx_tramp = tramp_info->need_rgctx_tramp;
1215                 else if (mono_method_needs_static_rgctx_invoke (method, FALSE))
1216                         need_rgctx_tramp = TRUE;
1217         }
1218
1219         /*
1220          * If the called address is a trampoline, replace it with the compiled method so
1221          * further calls don't have to go through the trampoline.
1222          */
1223         if (method && !callvirt) {
1224                 /* Avoid the overhead of looking up an already compiled method if possible */
1225                 if (enable_caching && delegate->method_code && *delegate->method_code) {
1226                         delegate->method_ptr = *delegate->method_code;
1227                 } else {
1228                         compiled_method = addr = mono_jit_compile_method (method, &error);
1229                         if (!mono_error_ok (&error)) {
1230                                 mono_error_set_pending_exception (&error);
1231                                 return NULL;
1232                         }
1233                         addr = mini_add_method_trampoline (method, compiled_method, need_rgctx_tramp, need_unbox_tramp);
1234                         delegate->method_ptr = addr;
1235                         if (enable_caching && delegate->method_code)
1236                                 *delegate->method_code = (guint8 *)delegate->method_ptr;
1237                 }
1238         } else {
1239                 if (need_rgctx_tramp)
1240                         delegate->method_ptr = mono_create_static_rgctx_trampoline (method, delegate->method_ptr);
1241         }
1242
1243         /* Necessary for !code condition to fallback to slow path */
1244         code = NULL;
1245
1246         multicast = ((MonoMulticastDelegate*)delegate)->delegates != NULL;
1247         if (!multicast && !callvirt) {
1248                 if (method && (method->flags & METHOD_ATTRIBUTE_STATIC) && mono_method_signature (method)->param_count == mono_method_signature (invoke)->param_count + 1)
1249                         /* Closed static delegate */
1250                         code = impl_this;
1251                 else
1252                         code = delegate->target ? impl_this : impl_nothis;
1253         }
1254
1255         if (!code) {
1256                 /* The general, unoptimized case */
1257                 m = mono_marshal_get_delegate_invoke (invoke, delegate);
1258                 code = (guint8 *)mono_jit_compile_method (m, &error);
1259                 if (!mono_error_ok (&error)) {
1260                         mono_error_set_pending_exception (&error);
1261                         return NULL;
1262                 }
1263                 code = (guint8 *)mini_add_method_trampoline (m, code, mono_method_needs_static_rgctx_invoke (m, FALSE), FALSE);
1264         }
1265
1266         delegate->invoke_impl = mono_get_addr_from_ftnptr (code);
1267         if (enable_caching && !callvirt && tramp_info->method) {
1268                 tramp_info->method_ptr = delegate->method_ptr;
1269                 tramp_info->invoke_impl = delegate->invoke_impl;
1270         }
1271
1272         return code;
1273 }
1274
1275 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
1276 static gpointer
1277 mono_handler_block_guard_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_info, guint8* tramp)
1278 {
1279         MONO_REQ_GC_UNSAFE_MODE;
1280
1281         MonoContext ctx;
1282         MonoException *exc;
1283         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
1284         gpointer resume_ip = jit_tls->handler_block_return_address;
1285
1286         memcpy (&ctx, &jit_tls->handler_block_context, sizeof (MonoContext));
1287         MONO_CONTEXT_SET_IP (&ctx, jit_tls->handler_block_return_address);
1288
1289         jit_tls->handler_block_return_address = NULL;
1290         jit_tls->handler_block = NULL;
1291
1292         if (!resume_ip) /*this should not happen, but we should avoid crashing */
1293                 exc = mono_get_exception_execution_engine ("Invalid internal state, resuming abort after handler block but no resume ip found");
1294         else
1295                 exc = mono_thread_resume_interruption ();
1296
1297         if (exc) {
1298                 mono_handle_exception (&ctx, (MonoObject *)exc);
1299                 mono_restore_context (&ctx);
1300         }
1301
1302         return resume_ip;
1303 }
1304
1305 gpointer
1306 mono_create_handler_block_trampoline (void)
1307 {
1308         static gpointer code;
1309
1310         if (code)
1311                 return code;
1312
1313         if (mono_aot_only) {
1314                 gpointer tmp = mono_aot_get_trampoline ("handler_block_trampoline");
1315                 g_assert (tmp);
1316                 mono_memory_barrier ();
1317                 code = tmp;
1318                 return code;
1319         }
1320
1321         mono_trampolines_lock ();
1322         if (!code) {
1323                 MonoTrampInfo *info;
1324                 gpointer tmp;
1325
1326                 tmp = mono_arch_create_handler_block_trampoline (&info, FALSE);
1327                 mono_tramp_info_register (info, NULL);
1328                 mono_memory_barrier ();
1329                 code = tmp;
1330         }
1331         mono_trampolines_unlock ();
1332
1333         return code;
1334 }
1335 #endif
1336
1337 /*
1338  * mono_get_trampoline_func:
1339  *
1340  *   Return the C function which needs to be called by the generic trampoline of type
1341  * TRAMP_TYPE.
1342  */
1343 gconstpointer
1344 mono_get_trampoline_func (MonoTrampolineType tramp_type)
1345 {
1346         switch (tramp_type) {
1347         case MONO_TRAMPOLINE_JIT:
1348         case MONO_TRAMPOLINE_JUMP:
1349                 return mono_magic_trampoline;
1350         case MONO_TRAMPOLINE_RGCTX_LAZY_FETCH:
1351                 return mono_rgctx_lazy_fetch_trampoline;
1352 #ifdef MONO_ARCH_AOT_SUPPORTED
1353         case MONO_TRAMPOLINE_AOT:
1354                 return mono_aot_trampoline;
1355         case MONO_TRAMPOLINE_AOT_PLT:
1356                 return mono_aot_plt_trampoline;
1357 #endif
1358         case MONO_TRAMPOLINE_DELEGATE:
1359                 return mono_delegate_trampoline;
1360         case MONO_TRAMPOLINE_RESTORE_STACK_PROT:
1361                 return mono_altstack_restore_prot;
1362 #ifndef DISABLE_REMOTING
1363         case MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING:
1364                 return mono_generic_virtual_remoting_trampoline;
1365 #endif
1366         case MONO_TRAMPOLINE_VCALL:
1367                 return mono_vcall_trampoline;
1368 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
1369         case MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD:
1370                 return mono_handler_block_guard_trampoline;
1371 #endif
1372         default:
1373                 g_assert_not_reached ();
1374                 return NULL;
1375         }
1376 }
1377
1378 static guchar*
1379 create_trampoline_code (MonoTrampolineType tramp_type)
1380 {
1381         MonoTrampInfo *info;
1382         guchar *code;
1383
1384         code = mono_arch_create_generic_trampoline (tramp_type, &info, FALSE);
1385         mono_tramp_info_register (info, NULL);
1386
1387         return code;
1388 }
1389
1390 void
1391 mono_trampolines_init (void)
1392 {
1393         mono_os_mutex_init_recursive (&trampolines_mutex);
1394
1395         if (mono_aot_only)
1396                 return;
1397
1398         mono_trampoline_code [MONO_TRAMPOLINE_JIT] = create_trampoline_code (MONO_TRAMPOLINE_JIT);
1399         mono_trampoline_code [MONO_TRAMPOLINE_JUMP] = create_trampoline_code (MONO_TRAMPOLINE_JUMP);
1400         mono_trampoline_code [MONO_TRAMPOLINE_RGCTX_LAZY_FETCH] = create_trampoline_code (MONO_TRAMPOLINE_RGCTX_LAZY_FETCH);
1401 #ifdef MONO_ARCH_AOT_SUPPORTED
1402         mono_trampoline_code [MONO_TRAMPOLINE_AOT] = create_trampoline_code (MONO_TRAMPOLINE_AOT);
1403         mono_trampoline_code [MONO_TRAMPOLINE_AOT_PLT] = create_trampoline_code (MONO_TRAMPOLINE_AOT_PLT);
1404 #endif
1405         mono_trampoline_code [MONO_TRAMPOLINE_DELEGATE] = create_trampoline_code (MONO_TRAMPOLINE_DELEGATE);
1406         mono_trampoline_code [MONO_TRAMPOLINE_RESTORE_STACK_PROT] = create_trampoline_code (MONO_TRAMPOLINE_RESTORE_STACK_PROT);
1407 #ifndef DISABLE_REMOTING
1408         mono_trampoline_code [MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING] = create_trampoline_code (MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING);
1409 #endif
1410         mono_trampoline_code [MONO_TRAMPOLINE_VCALL] = create_trampoline_code (MONO_TRAMPOLINE_VCALL);
1411 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
1412         mono_trampoline_code [MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD] = create_trampoline_code (MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD);
1413         mono_create_handler_block_trampoline ();
1414 #endif
1415
1416         mono_counters_register ("Calls to trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &trampoline_calls);
1417         mono_counters_register ("JIT trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &jit_trampolines);
1418         mono_counters_register ("Unbox trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &unbox_trampolines);
1419         mono_counters_register ("Static rgctx trampolines", MONO_COUNTER_JIT | MONO_COUNTER_INT, &static_rgctx_trampolines);
1420 }
1421
1422 void
1423 mono_trampolines_cleanup (void)
1424 {
1425         if (rgctx_lazy_fetch_trampoline_hash)
1426                 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash);
1427         if (rgctx_lazy_fetch_trampoline_hash_addr)
1428                 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr);
1429
1430         mono_os_mutex_destroy (&trampolines_mutex);
1431 }
1432
1433 guint8 *
1434 mono_get_trampoline_code (MonoTrampolineType tramp_type)
1435 {
1436         g_assert (mono_trampoline_code [tramp_type]);
1437
1438         return mono_trampoline_code [tramp_type];
1439 }
1440
1441 gpointer
1442 mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
1443 {
1444         gpointer code;
1445         guint32 len;
1446
1447         if (mono_aot_only)
1448                 code = mono_aot_create_specific_trampoline (mono_defaults.corlib, arg1, tramp_type, domain, &len);
1449         else
1450                 code = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, &len);
1451         mono_lldb_save_specific_trampoline_info (arg1, tramp_type, domain, code, len);
1452         if (code_len)
1453                 *code_len = len;
1454         return code;
1455 }
1456
1457 gpointer
1458 mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error)
1459 {
1460         MonoJitInfo *ji;
1461         gpointer code;
1462         guint32 code_size = 0;
1463
1464         error_init (error);
1465
1466 #ifdef ENABLE_INTERPRETER
1467         if (mono_use_interpreter) {
1468                 gpointer ret = mono_interp_create_trampoline (domain, method, error);
1469                 if (!mono_error_ok (error))
1470                         return NULL;
1471                 return ret;
1472         }
1473 #endif
1474
1475         code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
1476         /*
1477          * We cannot recover the correct type of a shared generic
1478          * method from its native code address, so we use the
1479          * trampoline instead.
1480          * For synchronized methods, the trampoline adds the wrapper.
1481          */
1482         if (code && !ji->has_generic_jit_info && !(method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED))
1483                 return code;
1484
1485         if (mono_llvm_only) {
1486                 code = mono_jit_compile_method (method, error);
1487                 if (!mono_error_ok (error))
1488                         return NULL;
1489                 return code;
1490         }
1491
1492         mono_domain_lock (domain);
1493         code = g_hash_table_lookup (domain_jit_info (domain)->jump_trampoline_hash, method);
1494         mono_domain_unlock (domain);
1495         if (code)
1496                 return code;
1497
1498         code = mono_create_specific_trampoline (method, MONO_TRAMPOLINE_JUMP, mono_domain_get (), &code_size);
1499         g_assert (code_size);
1500
1501         ji = (MonoJitInfo *)mono_domain_alloc0 (domain, MONO_SIZEOF_JIT_INFO);
1502         ji->code_start = code;
1503         ji->code_size = code_size;
1504         ji->d.method = method;
1505
1506         /*
1507          * mono_delegate_ctor needs to find the method metadata from the
1508          * trampoline address, so we save it here.
1509          */
1510
1511         mono_jit_info_table_add (domain, ji);
1512
1513         mono_domain_lock (domain);
1514         g_hash_table_insert (domain_jit_info (domain)->jump_trampoline_hash, method, ji->code_start);
1515         mono_domain_unlock (domain);
1516
1517         return ji->code_start;
1518 }
1519
1520 static void
1521 method_not_found (void)
1522 {
1523         g_assert_not_reached ();
1524 }
1525
1526 gpointer
1527 mono_create_jit_trampoline (MonoDomain *domain, MonoMethod *method, MonoError *error)
1528 {
1529         gpointer tramp;
1530
1531         error_init (error);
1532
1533         if (mono_aot_only) {
1534                 if (mono_llvm_only && method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1535                         method = mono_marshal_get_synchronized_wrapper (method);
1536
1537                 /* Avoid creating trampolines if possible */
1538                 gpointer code = mono_jit_find_compiled_method (domain, method);
1539
1540                 if (code)
1541                         return code;
1542                 if (mono_llvm_only) {
1543                         if (method->wrapper_type == MONO_WRAPPER_PROXY_ISINST)
1544                                 /* These wrappers are not generated */
1545                                 return method_not_found;
1546                         /* Methods are lazily initialized on first call, so this can't lead recursion */
1547                         code = mono_jit_compile_method (method, error);
1548                         if (!mono_error_ok (error))
1549                                 return NULL;
1550                         return code;
1551                 }
1552         }
1553
1554         mono_domain_lock (domain);
1555         tramp = g_hash_table_lookup (domain_jit_info (domain)->jit_trampoline_hash, method);
1556         mono_domain_unlock (domain);
1557         if (tramp)
1558                 return tramp;
1559
1560         tramp = mono_create_specific_trampoline (method, MONO_TRAMPOLINE_JIT, domain, NULL);
1561
1562         mono_domain_lock (domain);
1563         g_hash_table_insert (domain_jit_info (domain)->jit_trampoline_hash, method, tramp);
1564         mono_domain_unlock (domain);
1565
1566         jit_trampolines++;
1567
1568         return tramp;
1569 }
1570
1571 gpointer
1572 mono_create_jit_trampoline_from_token (MonoImage *image, guint32 token)
1573 {
1574         gpointer tramp;
1575
1576         MonoDomain *domain = mono_domain_get ();
1577         guint8 *buf, *start;
1578
1579         buf = start = (guint8 *)mono_domain_alloc0 (domain, 2 * sizeof (gpointer));
1580
1581         *(gpointer*)(gpointer)buf = image;
1582         buf += sizeof (gpointer);
1583         *(guint32*)(gpointer)buf = token;
1584
1585         tramp = mono_create_specific_trampoline (start, MONO_TRAMPOLINE_AOT, domain, NULL);
1586
1587         jit_trampolines++;
1588
1589         return tramp;
1590 }
1591
1592
1593 /*
1594  * mono_create_delegate_trampoline_info:
1595  *
1596  *  Create a trampoline info structure for the KLASS+METHOD pair.
1597  */
1598 MonoDelegateTrampInfo*
1599 mono_create_delegate_trampoline_info (MonoDomain *domain, MonoClass *klass, MonoMethod *method)
1600 {
1601         MonoMethod *invoke;
1602         MonoError error;
1603         MonoDelegateTrampInfo *tramp_info;
1604         MonoClassMethodPair pair, *dpair;
1605         guint32 code_size = 0;
1606
1607         pair.klass = klass;
1608         pair.method = method;
1609         mono_domain_lock (domain);
1610         tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair);
1611         mono_domain_unlock (domain);
1612         if (tramp_info)
1613                 return tramp_info;
1614
1615         invoke = mono_get_delegate_invoke (klass);
1616         g_assert (invoke);
1617
1618         tramp_info = (MonoDelegateTrampInfo *)mono_domain_alloc0 (domain, sizeof (MonoDelegateTrampInfo));
1619         tramp_info->invoke = invoke;
1620         tramp_info->invoke_sig = mono_method_signature (invoke);
1621         tramp_info->impl_this = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), TRUE);
1622         tramp_info->impl_nothis = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), FALSE);
1623         tramp_info->method = method;
1624         if (method) {
1625                 error_init (&error);
1626                 tramp_info->sig = mono_method_signature_checked (method, &error);
1627                 tramp_info->need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (method, FALSE);
1628         }
1629         tramp_info->invoke_impl = mono_create_specific_trampoline (tramp_info, MONO_TRAMPOLINE_DELEGATE, domain, &code_size);
1630         g_assert (code_size);
1631
1632         dpair = (MonoClassMethodPair *)mono_domain_alloc0 (domain, sizeof (MonoClassMethodPair));
1633         memcpy (dpair, &pair, sizeof (MonoClassMethodPair));
1634
1635         /* store trampoline address */
1636         mono_domain_lock (domain);
1637         g_hash_table_insert (domain_jit_info (domain)->delegate_trampoline_hash, dpair, tramp_info);
1638         mono_domain_unlock (domain);
1639
1640         return tramp_info;
1641 }
1642
1643 static void
1644 no_delegate_trampoline (void)
1645 {
1646         g_assert_not_reached ();
1647 }
1648
1649 gpointer
1650 mono_create_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
1651 {
1652         if (mono_llvm_only || mono_use_interpreter)
1653                 return no_delegate_trampoline;
1654
1655         return mono_create_delegate_trampoline_info (domain, klass, NULL)->invoke_impl;
1656 }
1657
1658 gpointer
1659 mono_create_delegate_virtual_trampoline (MonoDomain *domain, MonoClass *klass, MonoMethod *method)
1660 {
1661         MonoMethod *invoke = mono_get_delegate_invoke (klass);
1662         g_assert (invoke);
1663
1664         return mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke), method);
1665 }
1666
1667 gpointer
1668 mono_create_rgctx_lazy_fetch_trampoline (guint32 offset)
1669 {
1670         static gboolean inited = FALSE;
1671         static int num_trampolines = 0;
1672         MonoTrampInfo *info;
1673
1674         gpointer tramp, ptr;
1675
1676         mono_trampolines_lock ();
1677         if (rgctx_lazy_fetch_trampoline_hash)
1678                 tramp = g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash, GUINT_TO_POINTER (offset));
1679         else
1680                 tramp = NULL;
1681         mono_trampolines_unlock ();
1682         if (tramp)
1683                 return tramp;
1684
1685         if (mono_aot_only) {
1686                 ptr = mono_aot_get_lazy_fetch_trampoline (offset);
1687         } else {
1688                 tramp = mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, FALSE);
1689                 mono_tramp_info_register (info, NULL);
1690                 ptr = mono_create_ftnptr (mono_get_root_domain (), tramp);
1691         }
1692
1693         mono_trampolines_lock ();
1694         if (!rgctx_lazy_fetch_trampoline_hash) {
1695                 rgctx_lazy_fetch_trampoline_hash = g_hash_table_new (NULL, NULL);
1696                 rgctx_lazy_fetch_trampoline_hash_addr = g_hash_table_new (NULL, NULL);
1697         }
1698         g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash, GUINT_TO_POINTER (offset), ptr);
1699         g_assert (offset != -1);
1700         g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash_addr, ptr, GUINT_TO_POINTER (offset + 1));
1701         mono_trampolines_unlock ();
1702
1703         if (!inited) {
1704                 mono_counters_register ("RGCTX num lazy fetch trampolines",
1705                                 MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &num_trampolines);
1706                 inited = TRUE;
1707         }
1708         num_trampolines++;
1709
1710         return ptr;
1711 }
1712
1713 guint32
1714 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr)
1715 {
1716         int offset;
1717
1718         mono_trampolines_lock ();
1719         if (rgctx_lazy_fetch_trampoline_hash_addr) {
1720                 /* We store the real offset + 1 so we can detect when the lookup fails */
1721                 offset = GPOINTER_TO_INT (g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr, addr));
1722                 if (offset)
1723                         offset -= 1;
1724                 else
1725                         offset = -1;
1726         } else {
1727                 offset = -1;
1728         }
1729         mono_trampolines_unlock ();
1730         return offset;
1731 }
1732
1733 static const char*tramp_names [MONO_TRAMPOLINE_NUM] = {
1734         "jit",
1735         "jump",
1736         "rgctx_lazy_fetch",
1737         "aot",
1738         "aot_plt",
1739         "delegate",
1740         "restore_stack_prot",
1741         "generic_virtual_remoting",
1742         "vcall",
1743         "handler_block_guard"
1744 };
1745
1746 /*
1747  * mono_get_generic_trampoline_simple_name:
1748  *
1749  */
1750 const char*
1751 mono_get_generic_trampoline_simple_name (MonoTrampolineType tramp_type)
1752 {
1753         return tramp_names [tramp_type];
1754 }
1755
1756 /*
1757  * mono_get_generic_trampoline_name:
1758  *
1759  *   Returns a pointer to malloc-ed memory.
1760  */
1761 char*
1762 mono_get_generic_trampoline_name (MonoTrampolineType tramp_type)
1763 {
1764         return g_strdup_printf ("generic_trampoline_%s", tramp_names [tramp_type]);
1765 }
1766
1767 /*
1768  * mono_get_rgctx_fetch_trampoline_name:
1769  *
1770  *   Returns a pointer to malloc-ed memory.
1771  */
1772 char*
1773 mono_get_rgctx_fetch_trampoline_name (int slot)
1774 {
1775         gboolean mrgctx;
1776         int index;
1777
1778         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
1779         index = MONO_RGCTX_SLOT_INDEX (slot);
1780
1781         return g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", mrgctx ? "mrgctx" : "rgctx", index);
1782 }
1783
1784 /*
1785  * mini_get_single_step_trampoline:
1786  *
1787  *   Return a trampoline which calls debugger_agent_single_step_from_context ().
1788  */
1789 gpointer
1790 mini_get_single_step_trampoline (void)
1791 {
1792         static gpointer trampoline;
1793
1794         if (!trampoline) {
1795                 gpointer tramp;
1796
1797                 if (mono_aot_only) {
1798                         tramp = mono_aot_get_trampoline ("sdb_single_step_trampoline");
1799                 } else {
1800 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1801                         MonoTrampInfo *info;
1802                         tramp = mono_arch_create_sdb_trampoline (TRUE, &info, FALSE);
1803                         mono_tramp_info_register (info, NULL);
1804 #else
1805                         tramp = NULL;
1806                         g_assert_not_reached ();
1807 #endif
1808                 }
1809                 mono_memory_barrier ();
1810                 trampoline = tramp;
1811         }
1812
1813         return trampoline;
1814 }
1815
1816 /*
1817  * mini_get_breakpoint_trampoline:
1818  *
1819  *   Return a trampoline which calls debugger_agent_breakpoint_from_context ().
1820  */
1821 gpointer
1822 mini_get_breakpoint_trampoline (void)
1823 {
1824         static gpointer trampoline;
1825
1826         if (!trampoline) {
1827                 gpointer tramp;
1828
1829                 if (mono_aot_only) {
1830                         tramp = mono_aot_get_trampoline ("sdb_breakpoint_trampoline");
1831                 } else {
1832 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1833                         MonoTrampInfo *info;
1834                         tramp = mono_arch_create_sdb_trampoline (FALSE, &info, FALSE);
1835                         mono_tramp_info_register (info, NULL);
1836 #else
1837                         tramp = NULL;
1838                         g_assert_not_reached ();
1839 #endif
1840                 }
1841                 mono_memory_barrier ();
1842                 trampoline = tramp;
1843         }
1844
1845         return trampoline;
1846 }