3 * (C) 2003 Ximian, Inc.
4 * (C) 2003-2011 Novell, Inc.
5 * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
6 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
11 #include <mono/metadata/appdomain.h>
12 #include <mono/metadata/metadata-internals.h>
13 #include <mono/metadata/marshal.h>
14 #include <mono/metadata/tabledefs.h>
15 #include <mono/utils/mono-counters.h>
16 #include <mono/utils/mono-error-internals.h>
17 #include <mono/utils/mono-membar.h>
18 #include <mono/utils/mono-compiler.h>
19 #include <mono/utils/mono-threads-coop.h>
20 #include <mono/utils/unlocked.h>
24 #include "aot-runtime.h"
25 #include "mini-runtime.h"
27 #include "interp/interp.h"
30 * Address of the trampoline code. This is used by the debugger to check
31 * whether a method is a trampoline.
33 guint8
* mono_trampoline_code
[MONO_TRAMPOLINE_NUM
];
35 static GHashTable
*rgctx_lazy_fetch_trampoline_hash
;
36 static GHashTable
*rgctx_lazy_fetch_trampoline_hash_addr
;
38 static gint32 trampoline_calls
;
39 static gint32 jit_trampolines
;
40 static gint32 unbox_trampolines
;
41 static gint32 static_rgctx_trampolines
;
42 static gint32 rgctx_unmanaged_lookups
;
43 static gint32 rgctx_num_lazy_fetch_trampolines
;
45 #define mono_trampolines_lock() mono_os_mutex_lock (&trampolines_mutex)
46 #define mono_trampolines_unlock() mono_os_mutex_unlock (&trampolines_mutex)
47 static mono_mutex_t trampolines_mutex
;
49 #ifdef MONO_ARCH_GSHARED_SUPPORTED
57 rgctx_tramp_info_equal (gconstpointer ka
, gconstpointer kb
)
59 const RgctxTrampInfo
*i1
= (const RgctxTrampInfo
*)ka
;
60 const RgctxTrampInfo
*i2
= (const RgctxTrampInfo
*)kb
;
62 if (i1
->m
== i2
->m
&& i1
->addr
== i2
->addr
)
69 rgctx_tramp_info_hash (gconstpointer data
)
71 const RgctxTrampInfo
*info
= (const RgctxTrampInfo
*)data
;
73 return GPOINTER_TO_UINT (info
->m
) ^ GPOINTER_TO_UINT (info
->addr
);
77 * mono_create_static_rgctx_trampoline:
78 * \param m the mono method to create a trampoline for
79 * \param addr the address to jump to (where the compiled code for M lives)
81 * Creates a static rgctx trampoline for M which branches to ADDR which should
82 * point to the compiled code of M.
84 * Static rgctx trampolines are used when a shared generic method which doesn't
85 * have a this argument is called indirectly, ie. from code which can't pass in
86 * the rgctx argument. The trampoline sets the rgctx argument and jumps to the
87 * methods code. These trampolines are similar to the unbox trampolines, they
88 * perform the same task as the static rgctx wrappers, but they are smaller/faster,
89 * and can be made to work with full AOT.
91 * On PPC addr should be an ftnptr and the return value is an ftnptr too.
93 * \returns the generated static rgctx trampoline.
96 mono_create_static_rgctx_trampoline (MonoMethod
*m
, gpointer addr
)
101 RgctxTrampInfo tmp_info
;
102 RgctxTrampInfo
*info
;
104 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
105 g_assert (((gpointer
*)addr
) [2] == 0);
108 ctx
= mini_method_get_rgctx (m
);
110 domain
= mono_domain_get ();
113 * In the AOT case, addr might point to either the method, or to an unbox trampoline,
114 * so make the hash keyed on the m+addr pair.
116 mono_domain_lock (domain
);
117 if (!domain_jit_info (domain
)->static_rgctx_trampoline_hash
)
118 domain_jit_info (domain
)->static_rgctx_trampoline_hash
= g_hash_table_new (rgctx_tramp_info_hash
, rgctx_tramp_info_equal
);
120 tmp_info
.addr
= addr
;
121 res
= g_hash_table_lookup (domain_jit_info (domain
)->static_rgctx_trampoline_hash
,
123 mono_domain_unlock (domain
);
128 res
= mono_aot_get_static_rgctx_trampoline (ctx
, addr
);
130 res
= mono_arch_get_static_rgctx_trampoline (ctx
, addr
);
132 mono_domain_lock (domain
);
133 /* Duplicates inserted while we didn't hold the lock are OK */
134 info
= (RgctxTrampInfo
*)mono_domain_alloc (domain
, sizeof (RgctxTrampInfo
));
137 g_hash_table_insert (domain_jit_info (domain
)->static_rgctx_trampoline_hash
, info
, res
);
139 UnlockedIncrement (&static_rgctx_trampolines
);
140 mono_domain_unlock (domain
);
146 mono_create_static_rgctx_trampoline (MonoMethod
*m
, gpointer addr
)
149 * This shouldn't happen as all arches which support generic sharing support
150 * static rgctx trampolines as well.
152 g_assert_not_reached ();
157 #define DEBUG_IMT(stmt) do { stmt; } while (0)
159 #define DEBUG_IMT(stmt) do { } while (0)
163 * mini_resolve_imt_method:
165 * Resolve the actual method called when making an IMT call through VTABLE_SLOT with IMT_METHOD as the interface method.
167 * Either IMPL_METHOD or OUT_AOT_ADDR will be set on return.
170 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
)
172 MonoMethod
*impl
= NULL
, *generic_virtual
= NULL
;
173 gboolean lookup_aot
, variance_used
= FALSE
, need_rgctx_tramp
= FALSE
;
175 guint8
*aot_addr
= NULL
;
176 int displacement
= vtable_slot
- ((gpointer
*)vt
);
177 int interface_offset
;
178 int imt_slot
= MONO_IMT_SIZE
+ displacement
;
180 g_assert (imt_slot
< MONO_IMT_SIZE
);
183 /* This has to be variance aware since imt_method can be from an interface that vt->klass doesn't directly implement */
184 interface_offset
= mono_class_interface_offset_with_variance (vt
->klass
, imt_method
->klass
, &variance_used
);
185 if (interface_offset
< 0)
186 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
));
188 *variant_iface
= NULL
;
189 if (imt_method
->is_inflated
&& ((MonoMethodInflated
*)imt_method
)->context
.method_inst
) {
190 /* Generic virtual method */
191 generic_virtual
= imt_method
;
192 need_rgctx_tramp
= TRUE
;
193 } else if (variance_used
&& mono_class_has_variant_generic_params (imt_method
->klass
)) {
194 *variant_iface
= imt_method
;
198 /* We can only use the AOT compiled code if we don't require further processing */
199 lookup_aot
= !generic_virtual
& !variant_iface
;
202 mono_vtable_build_imt_slot (vt
, mono_method_get_imt_slot (imt_method
));
204 if (imt_method
->is_inflated
&& ((MonoMethodInflated
*)imt_method
)->context
.method_inst
) {
205 MonoGenericContext context
= { NULL
, NULL
};
208 * Generic virtual method, imt_method contains the inflated interface
209 * method, need to get the inflated impl method.
211 /* imt_method->slot might not be set */
212 impl
= mono_class_get_vtable_entry (vt
->klass
, interface_offset
+ mono_method_get_declaring_generic_method (imt_method
)->slot
);
214 if (mono_class_is_ginst (impl
->klass
))
215 context
.class_inst
= mono_class_get_generic_class (impl
->klass
)->context
.class_inst
;
216 context
.method_inst
= ((MonoMethodInflated
*)imt_method
)->context
.method_inst
;
217 impl
= mono_class_inflate_generic_method_checked (impl
, &context
, error
);
218 mono_error_assert_ok (error
);
221 /* Avoid loading metadata or creating a generic vtable if possible */
222 if (lookup_aot
&& !vt
->klass
->valuetype
) {
223 aot_addr
= (guint8
*)mono_aot_get_method_from_vt_slot (mono_domain_get (), vt
, interface_offset
+ mono_method_get_vtable_slot (imt_method
), error
);
224 return_val_if_nok (error
, NULL
);
231 impl
= mono_class_get_vtable_entry (vt
->klass
, interface_offset
+ mono_method_get_vtable_slot (imt_method
));
234 if (impl
&& mono_method_needs_static_rgctx_invoke (impl
, FALSE
))
235 need_rgctx_tramp
= TRUE
;
236 if (impl
&& impl
->wrapper_type
== MONO_WRAPPER_MANAGED_TO_MANAGED
) {
237 WrapperInfo
*info
= mono_marshal_get_wrapper_info (impl
);
239 if (info
&& info
->subtype
== WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER
)
240 need_rgctx_tramp
= TRUE
;
243 *out_need_rgctx_tramp
= need_rgctx_tramp
;
244 *out_aot_addr
= aot_addr
;
246 DEBUG_IMT (printf ("mono_convert_imt_slot_to_vtable_slot: method = %s.%s.%s, imt_method = %s.%s.%s\n",
247 method
->klass
->name_space
, method
->klass
->name
, method
->name
,
248 imt_method
->klass
->name_space
, imt_method
->klass
->name
, imt_method
->name
));
250 if (vt
->imt_collisions_bitmap
& (1 << imt_slot
)) {
251 int slot
= mono_method_get_vtable_index (imt_method
);
254 g_assert (slot
!= -1);
255 vtable_offset
= interface_offset
+ slot
;
256 vtable_slot
= & (vt
->vtable
[vtable_offset
]);
257 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
));
260 DEBUG_IMT (printf ("mono_convert_imt_slot_to_vtable_slot: slot %p[%d] is in the IMT, but not colliding\n", slot
, imt_slot
));
266 * This is a super-ugly hack to fix bug #616463.
268 * The problem is that we don't always set is_generic for generic
269 * method definitions. See the comment at the end of
270 * mono_class_inflate_generic_method_full_checked() in class.c.
273 is_generic_method_definition (MonoMethod
*m
)
275 MonoGenericContext
*context
;
281 context
= mono_method_get_context (m
);
282 if (!context
->method_inst
)
284 if (context
->method_inst
== mono_method_get_generic_container (((MonoMethodInflated
*)m
)->declaring
)->context
.method_inst
)
290 mini_jit_info_is_gsharedvt (MonoJitInfo
*ji
)
292 if (ji
&& ji
->has_generic_jit_info
&& (mono_jit_info_get_generic_sharing_context (ji
)->is_gsharedvt
))
299 * mini_add_method_trampoline:
302 * @add_static_rgctx_tramp: adds a static rgctx trampoline
303 * @add_unbox_tramp: adds an unboxing trampoline
305 * Add static rgctx/gsharedvt_in/unbox trampolines to
306 * M/COMPILED_METHOD if needed.
308 * Returns the trampoline address, or COMPILED_METHOD if no trampoline
312 mini_add_method_trampoline (MonoMethod
*m
, gpointer compiled_method
, gboolean add_static_rgctx_tramp
, gboolean add_unbox_tramp
)
314 gpointer addr
= compiled_method
;
315 gboolean callee_gsharedvt
, callee_array_helper
;
316 MonoMethod
*jmethod
= NULL
;
319 // FIXME: This loads information from AOT (perf problem)
320 ji
= mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
321 callee_gsharedvt
= mini_jit_info_is_gsharedvt (ji
);
323 callee_array_helper
= FALSE
;
324 if (m
->wrapper_type
== MONO_WRAPPER_MANAGED_TO_MANAGED
) {
325 WrapperInfo
*info
= mono_marshal_get_wrapper_info (m
);
328 * generic array helpers.
329 * Have to replace the wrappers with the original generic instances.
331 if (info
&& info
->subtype
== WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER
) {
332 callee_array_helper
= TRUE
;
333 m
= info
->d
.generic_array_helper
.method
;
335 } else if (m
->wrapper_type
== MONO_WRAPPER_UNKNOWN
) {
336 WrapperInfo
*info
= mono_marshal_get_wrapper_info (m
);
338 /* Same for synchronized inner wrappers */
339 if (info
&& info
->subtype
== WRAPPER_SUBTYPE_SYNCHRONIZED_INNER
) {
340 m
= info
->d
.synchronized_inner
.method
;
344 if (callee_gsharedvt
)
345 g_assert (m
->is_inflated
);
347 addr
= compiled_method
;
349 if (add_unbox_tramp
) {
351 * The unbox trampolines call the method directly, so need to add
352 * an rgctx tramp before them.
355 addr
= mono_aot_get_unbox_trampoline (m
);
357 unbox_trampolines
++;
358 addr
= mono_arch_get_unbox_trampoline (m
, addr
);
362 if (ji
&& !ji
->is_trampoline
)
363 jmethod
= jinfo_get_method (ji
);
364 if (callee_gsharedvt
&& mini_is_gsharedvt_variable_signature (mono_method_signature (jmethod
))) {
365 MonoMethodSignature
*sig
, *gsig
;
367 /* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
369 /* Call from normal/gshared code to gsharedvt code with variable signature */
370 sig
= mono_method_signature (m
);
371 gsig
= mono_method_signature (jmethod
);
373 addr
= mini_get_gsharedvt_wrapper (TRUE
, addr
, sig
, gsig
, -1, FALSE
);
376 g_assert_not_reached ();
377 //printf ("IN: %s\n", mono_method_full_name (m, TRUE));
380 if (callee_array_helper
) {
381 add_static_rgctx_tramp
= FALSE
;
382 /* In AOT mode, compiled_method points to one of the InternalArray methods in Array. */
383 if (ji
&& !mono_llvm_only
&& mono_method_needs_static_rgctx_invoke (jinfo_get_method (ji
), TRUE
))
384 add_static_rgctx_tramp
= TRUE
;
388 add_static_rgctx_tramp
= FALSE
;
390 if (add_static_rgctx_tramp
)
391 addr
= mono_create_static_rgctx_trampoline (m
, addr
);
397 * mini_create_llvmonly_ftndesc:
399 * Create a function descriptor of the form <addr, arg>, which
400 * represents a callee ADDR with ARG as the last argument.
402 * - generic sharing (ARG is the rgctx)
403 * - gsharedvt signature wrappers (ARG is a function descriptor)
406 mini_create_llvmonly_ftndesc (MonoDomain
*domain
, gpointer addr
, gpointer arg
)
408 MonoFtnDesc
*ftndesc
= (MonoFtnDesc
*)mono_domain_alloc0 (mono_domain_get (), 2 * sizeof (gpointer
));
409 ftndesc
->addr
= addr
;
416 * mini_add_method_wrappers_llvmonly:
418 * Add unbox/gsharedvt wrappers around COMPILED_METHOD if needed. Return the wrapper address or COMPILED_METHOD
419 * if no wrapper is needed. Set OUT_ARG to the rgctx/extra argument needed to be passed to the returned method.
422 mini_add_method_wrappers_llvmonly (MonoMethod
*m
, gpointer compiled_method
, gboolean caller_gsharedvt
, gboolean add_unbox_tramp
, gpointer
*out_arg
)
425 gboolean callee_gsharedvt
, callee_array_helper
;
426 MonoMethod
*jmethod
= NULL
;
429 // FIXME: This loads information from AOT (perf problem)
430 ji
= mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
431 callee_gsharedvt
= mini_jit_info_is_gsharedvt (ji
);
433 callee_array_helper
= FALSE
;
434 if (m
->wrapper_type
== MONO_WRAPPER_MANAGED_TO_MANAGED
) {
435 WrapperInfo
*info
= mono_marshal_get_wrapper_info (m
);
438 * generic array helpers.
439 * Have to replace the wrappers with the original generic instances.
441 if (info
&& info
->subtype
== WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER
) {
442 callee_array_helper
= TRUE
;
443 m
= info
->d
.generic_array_helper
.method
;
445 } else if (m
->wrapper_type
== MONO_WRAPPER_UNKNOWN
) {
446 WrapperInfo
*info
= mono_marshal_get_wrapper_info (m
);
448 /* Same for synchronized inner wrappers */
449 if (info
&& info
->subtype
== WRAPPER_SUBTYPE_SYNCHRONIZED_INNER
) {
450 m
= info
->d
.synchronized_inner
.method
;
454 if (callee_gsharedvt
)
455 g_assert (m
->is_inflated
);
457 addr
= compiled_method
;
459 if (add_unbox_tramp
) {
461 * The unbox trampolines call the method directly, so need to add
462 * an rgctx tramp before them.
465 addr
= mono_aot_get_unbox_trampoline (m
);
467 unbox_trampolines
++;
468 addr
= mono_arch_get_unbox_trampoline (m
, addr
);
472 g_assert (mono_llvm_only
);
475 if (ji
&& !ji
->is_trampoline
)
476 jmethod
= jinfo_get_method (ji
);
478 if (callee_gsharedvt
)
479 callee_gsharedvt
= mini_is_gsharedvt_variable_signature (mono_method_signature (jmethod
));
481 if (!caller_gsharedvt
&& callee_gsharedvt
) {
482 MonoMethodSignature
*sig
, *gsig
;
483 gpointer wrapper_addr
;
485 /* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
487 /* Call from normal/gshared code to gsharedvt code with variable signature */
488 sig
= mono_method_signature (m
);
489 gsig
= mono_method_signature (jmethod
);
491 wrapper_addr
= mini_get_gsharedvt_wrapper (TRUE
, addr
, sig
, gsig
, -1, FALSE
);
494 * This is a gsharedvt in wrapper, it gets passed a ftndesc for the gsharedvt method as an argument.
496 *out_arg
= mini_create_llvmonly_ftndesc (mono_domain_get (), addr
, mini_method_get_rgctx (m
));
498 //printf ("IN: %s\n", mono_method_full_name (m, TRUE));
501 if (!(*out_arg
) && mono_method_needs_static_rgctx_invoke (m
, FALSE
))
502 *out_arg
= mini_method_get_rgctx (m
);
504 if (caller_gsharedvt
&& !callee_gsharedvt
) {
506 * The callee uses the gsharedvt calling convention, have to add an out wrapper.
508 gpointer out_wrapper
= mini_get_gsharedvt_wrapper (FALSE
, NULL
, mono_method_signature (m
), NULL
, -1, FALSE
);
509 MonoFtnDesc
*out_wrapper_arg
= mini_create_llvmonly_ftndesc (mono_domain_get (), addr
, *out_arg
);
512 *out_arg
= out_wrapper_arg
;
519 * common_call_trampoline:
521 * The code to handle normal, virtual, and interface method calls and jumps, both
522 * from JITted and LLVM compiled code.
525 common_call_trampoline (mgreg_t
*regs
, guint8
*code
, MonoMethod
*m
, MonoVTable
*vt
, gpointer
*vtable_slot
, MonoError
*error
)
527 gpointer addr
, compiled_method
;
528 gboolean generic_shared
= FALSE
;
529 gboolean need_unbox_tramp
= FALSE
;
530 gboolean need_rgctx_tramp
= FALSE
;
531 MonoMethod
*declaring
= NULL
;
532 MonoMethod
*generic_virtual
= NULL
, *variant_iface
= NULL
;
534 gboolean imt_call
, virtual_
;
535 gpointer
*orig_vtable_slot
, *vtable_slot_to_patch
= NULL
;
536 MonoJitInfo
*ji
= NULL
;
540 virtual_
= vt
&& (gpointer
)vtable_slot
> (gpointer
)vt
;
541 imt_call
= vt
&& (gpointer
)vtable_slot
< (gpointer
)vt
;
544 * rgctx trampolines are needed when the call is indirect so the caller can't pass
545 * the rgctx argument needed by the callee.
548 need_rgctx_tramp
= mono_method_needs_static_rgctx_invoke (m
, FALSE
);
550 orig_vtable_slot
= vtable_slot
;
551 vtable_slot_to_patch
= vtable_slot
;
555 MonoMethod
*imt_method
= NULL
, *impl_method
= NULL
;
556 MonoObject
*this_arg
;
558 g_assert (vtable_slot
);
560 imt_method
= mono_arch_find_imt_method (regs
, code
);
561 this_arg
= (MonoObject
*)mono_arch_get_this_arg_from_call (regs
, code
);
563 if (mono_object_is_transparent_proxy (this_arg
)) {
564 /* Use the slow path for now */
565 m
= mono_object_get_virtual_method (this_arg
, imt_method
);
566 vtable_slot_to_patch
= NULL
;
568 if (imt_method
->is_inflated
&& ((MonoMethodInflated
*)imt_method
)->context
.method_inst
) {
569 /* Generic virtual method */
570 generic_virtual
= imt_method
;
571 need_rgctx_tramp
= TRUE
;
574 vtable_slot
= mini_resolve_imt_method (vt
, vtable_slot
, imt_method
, &impl_method
, &addr
, &need_rgctx_tramp
, &variant_iface
, error
);
575 return_val_if_nok (error
, NULL
);
577 /* We must handle magic interfaces on rank 1 arrays of ref types as if they were variant */
578 if (!variant_iface
&& vt
->klass
->rank
== 1 && !vt
->klass
->element_class
->valuetype
&& imt_method
->klass
->is_array_special_interface
)
579 variant_iface
= imt_method
;
581 /* This is the vcall slot which gets called through the IMT trampoline */
582 vtable_slot_to_patch
= vtable_slot
;
586 * We found AOT compiled code for the method, skip the rest.
588 if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot
))
591 return mono_create_ftnptr (mono_domain_get (), addr
);
599 * The virtual check is needed because is_generic_method_definition (m) could
600 * return TRUE for methods used in IMT calls too.
602 if (virtual_
&& is_generic_method_definition (m
)) {
603 MonoGenericContext context
= { NULL
, NULL
};
604 MonoMethod
*declaring
;
607 declaring
= mono_method_get_declaring_generic_method (m
);
611 if (mono_class_is_ginst (m
->klass
))
612 context
.class_inst
= mono_class_get_generic_class (m
->klass
)->context
.class_inst
;
614 g_assert (!mono_class_is_gtd (m
->klass
));
616 generic_virtual
= mono_arch_find_imt_method (regs
, code
);
617 g_assert (generic_virtual
);
618 g_assert (generic_virtual
->is_inflated
);
619 context
.method_inst
= ((MonoMethodInflated
*)generic_virtual
)->context
.method_inst
;
621 m
= mono_class_inflate_generic_method_checked (declaring
, &context
, error
);
622 mono_error_assert_ok (error
);
623 /* FIXME: only do this if the method is sharable */
624 need_rgctx_tramp
= TRUE
;
625 } else if ((context_used
= mono_method_check_context_used (m
))) {
626 MonoClass
*klass
= NULL
;
627 MonoMethod
*actual_method
= NULL
;
628 MonoVTable
*vt
= NULL
;
629 MonoGenericInst
*method_inst
= NULL
;
632 generic_shared
= TRUE
;
637 * The caller is gshared code, compute the actual method to call from M and this/rgctx.
639 if (m
->is_inflated
&& mono_method_get_context (m
)->method_inst
) {
640 MonoMethodRuntimeGenericContext
*mrgctx
= (MonoMethodRuntimeGenericContext
*)mono_arch_find_static_call_vtable (regs
, code
);
642 klass
= mrgctx
->class_vtable
->klass
;
643 method_inst
= mrgctx
->method_inst
;
644 } else if ((m
->flags
& METHOD_ATTRIBUTE_STATIC
) || m
->klass
->valuetype
) {
645 MonoVTable
*vtable
= mono_arch_find_static_call_vtable (regs
, code
);
647 klass
= vtable
->klass
;
649 MonoObject
*this_argument
= (MonoObject
*)mono_arch_get_this_arg_from_call (regs
, code
);
651 vt
= this_argument
->vtable
;
652 vtable_slot
= orig_vtable_slot
;
654 g_assert (this_argument
->vtable
->klass
->inited
);
657 mono_class_setup_supertypes (this_argument
->vtable
->klass
);
658 klass
= this_argument
->vtable
->klass
->supertypes
[m
->klass
->idepth
- 1];
662 g_assert (vtable_slot
|| klass
);
665 int displacement
= vtable_slot
- ((gpointer
*)vt
);
667 g_assert_not_reached ();
669 g_assert (displacement
> 0);
671 actual_method
= vt
->klass
->vtable
[displacement
];
674 if (method_inst
|| m
->wrapper_type
) {
675 MonoGenericContext context
= { NULL
, NULL
};
678 declaring
= mono_method_get_declaring_generic_method (m
);
682 if (mono_class_is_ginst (klass
))
683 context
.class_inst
= mono_class_get_generic_class (klass
)->context
.class_inst
;
684 else if (mono_class_is_gtd (klass
))
685 context
.class_inst
= mono_class_get_generic_container (klass
)->context
.class_inst
;
686 context
.method_inst
= method_inst
;
688 actual_method
= mono_class_inflate_generic_method_checked (declaring
, &context
, error
);
689 mono_error_assert_ok (error
);
691 actual_method
= mono_class_get_method_generic (klass
, m
, error
);
692 mono_error_assert_ok (error
);
696 g_assert (actual_method
);
697 g_assert (actual_method
->klass
== klass
);
699 if (actual_method
->is_inflated
)
700 declaring
= mono_method_get_declaring_generic_method (actual_method
);
707 if (m
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
) {
708 m
= mono_marshal_get_synchronized_wrapper (m
);
709 need_rgctx_tramp
= FALSE
;
712 /* Calls made through delegates on platforms without delegate trampolines */
713 if (!code
&& mono_method_needs_static_rgctx_invoke (m
, FALSE
))
714 need_rgctx_tramp
= TRUE
;
716 addr
= compiled_method
= mono_jit_compile_method (m
, error
);
720 if (generic_virtual
|| variant_iface
) {
721 if (vt
->klass
->valuetype
) /*FIXME is this required variant iface?*/
722 need_unbox_tramp
= TRUE
;
723 } else if (orig_vtable_slot
) {
724 if (m
->klass
->valuetype
)
725 need_unbox_tramp
= TRUE
;
728 addr
= mini_add_method_trampoline (m
, compiled_method
, need_rgctx_tramp
, need_unbox_tramp
);
730 if (generic_virtual
|| variant_iface
) {
731 MonoMethod
*target
= generic_virtual
? generic_virtual
: variant_iface
;
733 vtable_slot
= orig_vtable_slot
;
734 g_assert (vtable_slot
);
736 mono_method_add_generic_virtual_invocation (mono_domain_get (),
743 /* the method was jumped to */
745 MonoDomain
*domain
= mono_domain_get ();
747 /* Patch the got entries pointing to this method */
749 * We do this here instead of in mono_codegen () to cover the case when m
750 * was loaded from an aot image.
752 if (domain_jit_info (domain
)->jump_target_got_slot_hash
) {
755 mono_domain_lock (domain
);
756 list
= (GSList
*)g_hash_table_lookup (domain_jit_info (domain
)->jump_target_got_slot_hash
, m
);
758 for (tmp
= list
; tmp
; tmp
= tmp
->next
) {
759 gpointer
*got_slot
= (gpointer
*)tmp
->data
;
762 g_hash_table_remove (domain_jit_info (domain
)->jump_target_got_slot_hash
, m
);
765 mono_domain_unlock (domain
);
771 vtable_slot
= orig_vtable_slot
;
774 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
))) {
775 g_assert (*vtable_slot_to_patch
);
776 *vtable_slot_to_patch
= mono_get_addr_from_ftnptr (addr
);
779 guint8
*plt_entry
= mono_aot_get_plt_entry (code
);
780 gboolean no_patch
= FALSE
;
781 MonoJitInfo
*target_ji
;
784 if (generic_shared
) {
786 mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
788 ji
= mini_jit_info_table_find (mono_domain_get (), (char*)code
, NULL
);
790 if (ji
&& target_ji
&& generic_shared
&& ji
->has_generic_jit_info
&& !target_ji
->has_generic_jit_info
) {
795 mono_aot_patch_plt_entry (code
, plt_entry
, NULL
, regs
, (guint8
*)addr
);
797 if (generic_shared
) {
798 if (m
->wrapper_type
!= MONO_WRAPPER_NONE
)
799 m
= mono_marshal_method_from_wrapper (m
);
800 //g_assert (mono_method_is_generic_sharable (m, FALSE));
803 /* Patch calling code */
805 mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
807 ji
= mini_jit_info_table_find (mono_domain_get (), (char*)code
, NULL
);
809 if (ji
&& target_ji
&& generic_shared
&& ji
->has_generic_jit_info
&& !target_ji
->has_generic_jit_info
) {
811 * Can't patch the call as the caller is gshared, but the callee is not. Happens when
812 * generic sharing fails.
813 * FIXME: Performance problem.
817 #if LLVM_API_VERSION > 100
818 /* LLVM code doesn't make direct calls */
819 if (ji
&& ji
->from_llvm
)
822 if (!no_patch
&& mono_method_same_domain (ji
, target_ji
))
823 mono_arch_patch_callsite ((guint8
*)ji
->code_start
, code
, (guint8
*)addr
);
831 * mono_magic_trampoline:
833 * This trampoline handles normal calls from JITted code.
836 mono_magic_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer arg
, guint8
* tramp
)
841 MONO_REQ_GC_UNSAFE_MODE
;
843 g_assert (mono_thread_is_gc_unsafe_mode ());
845 UnlockedIncrement (&trampoline_calls
);
847 res
= common_call_trampoline (regs
, code
, (MonoMethod
*)arg
, NULL
, NULL
, &error
);
848 if (!is_ok (&error
)) {
849 mono_error_set_pending_exception (&error
);
857 * mono_vcall_trampoline:
859 * This trampoline handles virtual calls.
862 mono_vcall_trampoline (mgreg_t
*regs
, guint8
*code
, int slot
, guint8
*tramp
)
864 MONO_REQ_GC_UNSAFE_MODE
;
866 MonoObject
*this_arg
;
868 gpointer
*vtable_slot
;
871 gpointer addr
, res
= NULL
;
873 UnlockedIncrement (&trampoline_calls
);
876 * We need to obtain the following pieces of information:
877 * - the method which needs to be compiled.
879 * We use one vtable trampoline per vtable slot index, so we need only the vtable,
880 * the other two can be computed from the vtable + the slot index.
884 * Obtain the vtable from the 'this' arg.
886 this_arg
= (MonoObject
*)mono_arch_get_this_arg_from_call (regs
, code
);
889 vt
= this_arg
->vtable
;
892 /* Normal virtual call */
893 vtable_slot
= &(vt
->vtable
[slot
]);
895 /* Avoid loading metadata or creating a generic vtable if possible */
896 addr
= mono_aot_get_method_from_vt_slot (mono_domain_get (), vt
, slot
, &error
);
897 goto_if_nok (&error
, leave
);
898 if (addr
&& !vt
->klass
->valuetype
) {
899 if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot
))
902 return mono_create_ftnptr (mono_domain_get (), addr
);
907 * is_generic_method_definition() above) also
908 * goes away if we do a
909 * mono_class_setup_vtable (vt->klass) here,
910 * because we then inflate the method
911 * correctly, put it in the cache, and the
912 * "wrong" inflation invocation still looks up
913 * the correctly inflated method.
915 * The hack above seems more stable and
918 m
= mono_class_get_vtable_entry (vt
->klass
, slot
);
921 vtable_slot
= &(((gpointer
*)vt
) [slot
]);
926 res
= common_call_trampoline (regs
, code
, m
, vt
, vtable_slot
, &error
);
928 if (!mono_error_ok (&error
)) {
929 mono_error_set_pending_exception (&error
);
935 #ifndef DISABLE_REMOTING
937 mono_generic_virtual_remoting_trampoline (mgreg_t
*regs
, guint8
*code
, MonoMethod
*m
, guint8
*tramp
)
939 MONO_REQ_GC_UNSAFE_MODE
;
942 MonoGenericContext context
= { NULL
, NULL
};
943 MonoMethod
*imt_method
, *declaring
;
946 UnlockedIncrement (&trampoline_calls
);
948 g_assert (m
->is_generic
);
951 declaring
= mono_method_get_declaring_generic_method (m
);
955 if (mono_class_is_ginst (m
->klass
))
956 context
.class_inst
= mono_class_get_generic_class (m
->klass
)->context
.class_inst
;
958 g_assert (!mono_class_is_gtd (m
->klass
));
960 imt_method
= mono_arch_find_imt_method (regs
, code
);
961 if (imt_method
->is_inflated
)
962 context
.method_inst
= ((MonoMethodInflated
*)imt_method
)->context
.method_inst
;
963 m
= mono_class_inflate_generic_method_checked (declaring
, &context
, &error
);
964 g_assert (mono_error_ok (&error
)); /* FIXME don't swallow the error */;
965 m
= mono_marshal_get_remoting_invoke_with_check (m
, &error
);
966 if (!is_ok (&error
)) {
967 mono_error_set_pending_exception (&error
);
971 addr
= mono_jit_compile_method (m
, &error
);
972 if (!mono_error_ok (&error
)) {
973 mono_error_set_pending_exception (&error
);
983 * mono_aot_trampoline:
985 * This trampoline handles calls made from AOT code. We try to bypass the
986 * normal JIT compilation logic to avoid loading the metadata for the method.
988 #ifdef MONO_ARCH_AOT_SUPPORTED
990 mono_aot_trampoline (mgreg_t
*regs
, guint8
*code
, guint8
*token_info
,
993 MONO_REQ_GC_UNSAFE_MODE
;
997 MonoMethod
*method
= NULL
;
1002 UnlockedIncrement (&trampoline_calls
);
1004 image
= (MonoImage
*)*(gpointer
*)(gpointer
)token_info
;
1005 token_info
+= sizeof (gpointer
);
1006 token
= *(guint32
*)(gpointer
)token_info
;
1008 addr
= mono_aot_get_method_from_token (mono_domain_get (), image
, token
, &error
);
1009 if (!is_ok (&error
))
1010 mono_error_cleanup (&error
);
1012 method
= mono_get_method_checked (image
, token
, NULL
, NULL
, &error
);
1014 g_error ("Could not load AOT trampoline due to %s", mono_error_get_message (&error
));
1016 /* Use the generic code */
1017 return mono_magic_trampoline (regs
, code
, method
, tramp
);
1020 addr
= mono_create_ftnptr (mono_domain_get (), addr
);
1022 /* This is a normal call through a PLT entry */
1023 plt_entry
= mono_aot_get_plt_entry (code
);
1024 g_assert (plt_entry
);
1026 mono_aot_patch_plt_entry (code
, plt_entry
, NULL
, regs
, (guint8
*)addr
);
1032 * mono_aot_plt_trampoline:
1034 * This trampoline handles calls made from AOT code through the PLT table.
1037 mono_aot_plt_trampoline (mgreg_t
*regs
, guint8
*code
, guint8
*aot_module
,
1040 MONO_REQ_GC_UNSAFE_MODE
;
1042 guint32 plt_info_offset
= mono_aot_get_plt_info_offset (regs
, code
);
1046 UnlockedIncrement (&trampoline_calls
);
1048 res
= mono_aot_plt_resolve (aot_module
, plt_info_offset
, code
, &error
);
1050 if (!mono_error_ok (&error
)) {
1051 mono_error_set_pending_exception (&error
);
1054 // FIXME: Error handling (how ?)
1063 mono_rgctx_lazy_fetch_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer data
, guint8
*tramp
)
1065 MONO_REQ_GC_UNSAFE_MODE
;
1067 guint32 slot
= GPOINTER_TO_UINT (data
);
1068 mgreg_t
*r
= (mgreg_t
*)regs
;
1069 gpointer arg
= (gpointer
)(gssize
)r
[MONO_ARCH_VTABLE_REG
];
1070 guint32 index
= MONO_RGCTX_SLOT_INDEX (slot
);
1071 gboolean mrgctx
= MONO_RGCTX_SLOT_IS_MRGCTX (slot
);
1075 UnlockedIncrement (&trampoline_calls
);
1076 UnlockedIncrement (&rgctx_unmanaged_lookups
);
1079 res
= mono_method_fill_runtime_generic_context ((MonoMethodRuntimeGenericContext
*)arg
, index
, &error
);
1081 res
= mono_class_fill_runtime_generic_context ((MonoVTable
*)arg
, index
, &error
);
1082 if (!mono_error_ok (&error
)) {
1083 mono_error_set_pending_exception (&error
);
1090 * mono_delegate_trampoline:
1092 * This trampoline handles calls made to Delegate:Invoke ().
1093 * This is called once the first time a delegate is invoked, so it must be fast.
1096 mono_delegate_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer
*arg
, guint8
* tramp
)
1098 MONO_REQ_GC_UNSAFE_MODE
;
1100 MonoDomain
*domain
= mono_domain_get ();
1101 MonoDelegate
*delegate
;
1104 MonoMethod
*method
= NULL
;
1106 gboolean multicast
, callvirt
= FALSE
, closed_over_null
= FALSE
;
1107 gboolean need_rgctx_tramp
= FALSE
;
1108 gboolean need_unbox_tramp
= FALSE
;
1109 gboolean enable_caching
= TRUE
;
1110 MonoDelegateTrampInfo
*tramp_info
= (MonoDelegateTrampInfo
*)arg
;
1111 MonoMethod
*invoke
= tramp_info
->invoke
;
1112 guint8
*impl_this
= (guint8
*)tramp_info
->impl_this
;
1113 guint8
*impl_nothis
= (guint8
*)tramp_info
->impl_nothis
;
1115 MonoMethodSignature
*sig
;
1116 gpointer addr
, compiled_method
;
1117 gboolean is_remote
= FALSE
;
1119 UnlockedIncrement (&trampoline_calls
);
1121 /* Obtain the delegate object according to the calling convention */
1122 delegate
= (MonoDelegate
*)mono_arch_get_this_arg_from_call (regs
, code
);
1123 g_assert (mono_class_has_parent (mono_object_class (delegate
), mono_defaults
.multicastdelegate_class
));
1125 if (delegate
->method
) {
1126 method
= delegate
->method
;
1129 * delegate->method_ptr == NULL means the delegate was initialized by
1130 * mini_delegate_ctor, while != NULL means it is initialized by
1131 * mono_delegate_ctor_with_method (). In both cases, we need to add wrappers
1132 * (ctor_with_method () does this, but it doesn't store the wrapper back into
1133 * delegate->method).
1135 #ifndef DISABLE_REMOTING
1136 if (delegate
->target
&& mono_object_is_transparent_proxy (delegate
->target
)) {
1140 if (((MonoTransparentProxy
*)delegate
->target
)->remote_class
->proxy_class
!= mono_class_get_com_object_class () &&
1141 !mono_class_is_com_object (((MonoTransparentProxy
*)delegate
->target
)->remote_class
->proxy_class
))
1143 method
= mono_marshal_get_remoting_invoke (method
, &err
);
1144 if (!is_ok (&err
)) {
1145 mono_error_set_pending_exception (&err
);
1151 sig
= tramp_info
->sig
;
1152 if (!(sig
&& method
== tramp_info
->method
)) {
1154 sig
= mono_method_signature_checked (method
, &err
);
1156 mono_error_set_pending_exception (&err
);
1161 if (sig
->hasthis
&& method
->klass
->valuetype
) {
1162 gboolean need_unbox
= TRUE
;
1164 if (tramp_info
->invoke_sig
->param_count
> sig
->param_count
&& tramp_info
->invoke_sig
->params
[0]->byref
)
1169 need_unbox_tramp
= TRUE
;
1171 method
= mono_marshal_get_unbox_wrapper (method
);
1175 // If "delegate->method_ptr" is null mono_get_addr_from_ftnptr will fail if
1176 // ftnptrs are being used. "method" would end up null on archtitectures without
1177 // ftnptrs so we can just skip this.
1178 } else if (delegate
->method_ptr
) {
1179 ji
= mono_jit_info_table_find (domain
, (char *)mono_get_addr_from_ftnptr (delegate
->method_ptr
));
1181 method
= jinfo_get_method (ji
);
1185 sig
= tramp_info
->sig
;
1186 if (!(sig
&& method
== tramp_info
->method
)) {
1188 sig
= mono_method_signature_checked (method
, &err
);
1190 mono_error_set_pending_exception (&err
);
1195 callvirt
= !delegate
->target
&& sig
->hasthis
;
1197 closed_over_null
= tramp_info
->invoke_sig
->param_count
== sig
->param_count
;
1199 if (callvirt
&& !closed_over_null
) {
1201 * The delegate needs to make a virtual call to the target method using its
1202 * first argument as the receiver. This is hard to support in full-aot, so
1203 * optimize it in some cases if possible.
1204 * If the target method is not virtual or is in a sealed class,
1205 * the vcall will call it directly.
1206 * If the call doesn't return a valuetype, then the vcall uses the same calling
1207 * convention as a normal call.
1209 if ((mono_class_is_sealed (method
->klass
) || !(method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
)) && !MONO_TYPE_ISSTRUCT (sig
->ret
)) {
1211 enable_caching
= FALSE
;
1215 if (delegate
->target
&&
1216 method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
&&
1217 method
->flags
& METHOD_ATTRIBUTE_ABSTRACT
&&
1218 mono_class_is_abstract (method
->klass
)) {
1219 method
= mono_object_get_virtual_method (delegate
->target
, method
);
1220 enable_caching
= FALSE
;
1223 if (method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
)
1224 method
= mono_marshal_get_synchronized_wrapper (method
);
1226 if (method
== tramp_info
->method
)
1227 need_rgctx_tramp
= tramp_info
->need_rgctx_tramp
;
1228 else if (mono_method_needs_static_rgctx_invoke (method
, FALSE
))
1229 need_rgctx_tramp
= TRUE
;
1233 * If the called address is a trampoline, replace it with the compiled method so
1234 * further calls don't have to go through the trampoline.
1236 if (method
&& !callvirt
) {
1237 /* Avoid the overhead of looking up an already compiled method if possible */
1238 if (enable_caching
&& delegate
->method_code
&& *delegate
->method_code
) {
1239 delegate
->method_ptr
= *delegate
->method_code
;
1241 compiled_method
= addr
= mono_jit_compile_method (method
, &error
);
1242 if (!mono_error_ok (&error
)) {
1243 mono_error_set_pending_exception (&error
);
1246 addr
= mini_add_method_trampoline (method
, compiled_method
, need_rgctx_tramp
, need_unbox_tramp
);
1247 delegate
->method_ptr
= addr
;
1248 if (enable_caching
&& delegate
->method_code
)
1249 *delegate
->method_code
= (guint8
*)delegate
->method_ptr
;
1252 if (need_rgctx_tramp
)
1253 delegate
->method_ptr
= mono_create_static_rgctx_trampoline (method
, delegate
->method_ptr
);
1256 /* Necessary for !code condition to fallback to slow path */
1259 multicast
= ((MonoMulticastDelegate
*)delegate
)->delegates
!= NULL
;
1260 if (!multicast
&& !callvirt
) {
1261 if (method
&& (method
->flags
& METHOD_ATTRIBUTE_STATIC
) && mono_method_signature (method
)->param_count
== mono_method_signature (invoke
)->param_count
+ 1)
1262 /* Closed static delegate */
1265 code
= delegate
->target
? impl_this
: impl_nothis
;
1269 /* The general, unoptimized case */
1270 m
= mono_marshal_get_delegate_invoke (invoke
, delegate
);
1271 code
= (guint8
*)mono_jit_compile_method (m
, &error
);
1272 if (!mono_error_ok (&error
)) {
1273 mono_error_set_pending_exception (&error
);
1276 code
= (guint8
*)mini_add_method_trampoline (m
, code
, mono_method_needs_static_rgctx_invoke (m
, FALSE
), FALSE
);
1279 delegate
->invoke_impl
= mono_get_addr_from_ftnptr (code
);
1280 if (enable_caching
&& !callvirt
&& tramp_info
->method
) {
1281 tramp_info
->method_ptr
= delegate
->method_ptr
;
1282 tramp_info
->invoke_impl
= delegate
->invoke_impl
;
1289 * mono_get_trampoline_func:
1291 * Return the C function which needs to be called by the generic trampoline of type
1295 mono_get_trampoline_func (MonoTrampolineType tramp_type
)
1297 switch (tramp_type
) {
1298 case MONO_TRAMPOLINE_JIT
:
1299 case MONO_TRAMPOLINE_JUMP
:
1300 return mono_magic_trampoline
;
1301 case MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
:
1302 return mono_rgctx_lazy_fetch_trampoline
;
1303 #ifdef MONO_ARCH_AOT_SUPPORTED
1304 case MONO_TRAMPOLINE_AOT
:
1305 return mono_aot_trampoline
;
1306 case MONO_TRAMPOLINE_AOT_PLT
:
1307 return mono_aot_plt_trampoline
;
1309 case MONO_TRAMPOLINE_DELEGATE
:
1310 return mono_delegate_trampoline
;
1311 case MONO_TRAMPOLINE_RESTORE_STACK_PROT
:
1312 return mono_altstack_restore_prot
;
1313 #ifndef DISABLE_REMOTING
1314 case MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
:
1315 return mono_generic_virtual_remoting_trampoline
;
1317 case MONO_TRAMPOLINE_VCALL
:
1318 return mono_vcall_trampoline
;
1320 g_assert_not_reached ();
1326 create_trampoline_code (MonoTrampolineType tramp_type
)
1328 MonoTrampInfo
*info
;
1331 code
= mono_arch_create_generic_trampoline (tramp_type
, &info
, FALSE
);
1332 mono_tramp_info_register (info
, NULL
);
1338 mono_trampolines_init (void)
1340 mono_os_mutex_init_recursive (&trampolines_mutex
);
1345 mono_trampoline_code
[MONO_TRAMPOLINE_JIT
] = create_trampoline_code (MONO_TRAMPOLINE_JIT
);
1346 mono_trampoline_code
[MONO_TRAMPOLINE_JUMP
] = create_trampoline_code (MONO_TRAMPOLINE_JUMP
);
1347 mono_trampoline_code
[MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
] = create_trampoline_code (MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
);
1348 #ifdef MONO_ARCH_AOT_SUPPORTED
1349 mono_trampoline_code
[MONO_TRAMPOLINE_AOT
] = create_trampoline_code (MONO_TRAMPOLINE_AOT
);
1350 mono_trampoline_code
[MONO_TRAMPOLINE_AOT_PLT
] = create_trampoline_code (MONO_TRAMPOLINE_AOT_PLT
);
1352 mono_trampoline_code
[MONO_TRAMPOLINE_DELEGATE
] = create_trampoline_code (MONO_TRAMPOLINE_DELEGATE
);
1353 mono_trampoline_code
[MONO_TRAMPOLINE_RESTORE_STACK_PROT
] = create_trampoline_code (MONO_TRAMPOLINE_RESTORE_STACK_PROT
);
1354 #ifndef DISABLE_REMOTING
1355 mono_trampoline_code
[MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
] = create_trampoline_code (MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
);
1357 mono_trampoline_code
[MONO_TRAMPOLINE_VCALL
] = create_trampoline_code (MONO_TRAMPOLINE_VCALL
);
1359 mono_counters_register ("Calls to trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &trampoline_calls
);
1360 mono_counters_register ("JIT trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &jit_trampolines
);
1361 mono_counters_register ("Unbox trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &unbox_trampolines
);
1362 mono_counters_register ("Static rgctx trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &static_rgctx_trampolines
);
1363 mono_counters_register ("RGCTX unmanaged lookups", MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &rgctx_unmanaged_lookups
);
1364 mono_counters_register ("RGCTX num lazy fetch trampolines", MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &rgctx_num_lazy_fetch_trampolines
);
1368 mono_trampolines_cleanup (void)
1370 if (rgctx_lazy_fetch_trampoline_hash
)
1371 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash
);
1372 if (rgctx_lazy_fetch_trampoline_hash_addr
)
1373 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr
);
1375 mono_os_mutex_destroy (&trampolines_mutex
);
1379 mono_get_trampoline_code (MonoTrampolineType tramp_type
)
1381 g_assert (mono_trampoline_code
[tramp_type
]);
1383 return mono_trampoline_code
[tramp_type
];
1387 mono_create_specific_trampoline (gpointer arg1
, MonoTrampolineType tramp_type
, MonoDomain
*domain
, guint32
*code_len
)
1393 code
= mono_aot_create_specific_trampoline (mono_defaults
.corlib
, arg1
, tramp_type
, domain
, &len
);
1395 code
= mono_arch_create_specific_trampoline (arg1
, tramp_type
, domain
, &len
);
1396 mono_lldb_save_specific_trampoline_info (arg1
, tramp_type
, domain
, code
, len
);
1403 mono_create_jump_trampoline (MonoDomain
*domain
, MonoMethod
*method
, gboolean add_sync_wrapper
, MonoError
*error
)
1407 guint32 code_size
= 0;
1411 if (mono_use_interpreter
) {
1412 gpointer ret
= mini_get_interp_callbacks ()->create_trampoline (domain
, method
, error
);
1413 if (!mono_error_ok (error
))
1418 code
= mono_jit_find_compiled_method_with_jit_info (domain
, method
, &ji
);
1420 * We cannot recover the correct type of a shared generic
1421 * method from its native code address, so we use the
1422 * trampoline instead.
1423 * For synchronized methods, the trampoline adds the wrapper.
1425 if (code
&& !ji
->has_generic_jit_info
&& !(method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
))
1428 if (mono_llvm_only
) {
1429 code
= mono_jit_compile_method (method
, error
);
1430 if (!mono_error_ok (error
))
1435 mono_domain_lock (domain
);
1436 code
= g_hash_table_lookup (domain_jit_info (domain
)->jump_trampoline_hash
, method
);
1437 mono_domain_unlock (domain
);
1441 code
= mono_create_specific_trampoline (method
, MONO_TRAMPOLINE_JUMP
, mono_domain_get (), &code_size
);
1442 g_assert (code_size
);
1444 ji
= (MonoJitInfo
*)mono_domain_alloc0 (domain
, MONO_SIZEOF_JIT_INFO
);
1445 ji
->code_start
= code
;
1446 ji
->code_size
= code_size
;
1447 ji
->d
.method
= method
;
1450 * mono_delegate_ctor needs to find the method metadata from the
1451 * trampoline address, so we save it here.
1454 mono_jit_info_table_add (domain
, ji
);
1456 mono_domain_lock (domain
);
1457 g_hash_table_insert (domain_jit_info (domain
)->jump_trampoline_hash
, method
, ji
->code_start
);
1458 mono_domain_unlock (domain
);
1460 return ji
->code_start
;
1464 method_not_found (void)
1466 g_assert_not_reached ();
1470 mono_create_jit_trampoline (MonoDomain
*domain
, MonoMethod
*method
, MonoError
*error
)
1476 if (mono_aot_only
) {
1477 if (mono_llvm_only
&& method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
)
1478 method
= mono_marshal_get_synchronized_wrapper (method
);
1480 /* Avoid creating trampolines if possible */
1481 gpointer code
= mono_jit_find_compiled_method (domain
, method
);
1485 if (mono_llvm_only
) {
1486 if (method
->wrapper_type
== MONO_WRAPPER_PROXY_ISINST
)
1487 /* These wrappers are not generated */
1488 return method_not_found
;
1489 /* Methods are lazily initialized on first call, so this can't lead recursion */
1490 code
= mono_jit_compile_method (method
, error
);
1491 if (!mono_error_ok (error
))
1497 mono_domain_lock (domain
);
1498 tramp
= g_hash_table_lookup (domain_jit_info (domain
)->jit_trampoline_hash
, method
);
1499 mono_domain_unlock (domain
);
1503 tramp
= mono_create_specific_trampoline (method
, MONO_TRAMPOLINE_JIT
, domain
, NULL
);
1505 mono_domain_lock (domain
);
1506 g_hash_table_insert (domain_jit_info (domain
)->jit_trampoline_hash
, method
, tramp
);
1507 UnlockedIncrement (&jit_trampolines
);
1508 mono_domain_unlock (domain
);
1514 mono_create_jit_trampoline_from_token (MonoImage
*image
, guint32 token
)
1518 MonoDomain
*domain
= mono_domain_get ();
1519 guint8
*buf
, *start
;
1521 buf
= start
= (guint8
*)mono_domain_alloc0 (domain
, 2 * sizeof (gpointer
));
1523 *(gpointer
*)(gpointer
)buf
= image
;
1524 buf
+= sizeof (gpointer
);
1525 *(guint32
*)(gpointer
)buf
= token
;
1527 tramp
= mono_create_specific_trampoline (start
, MONO_TRAMPOLINE_AOT
, domain
, NULL
);
1529 UnlockedIncrement (&jit_trampolines
);
1536 * mono_create_delegate_trampoline_info:
1538 * Create a trampoline info structure for the KLASS+METHOD pair.
1540 MonoDelegateTrampInfo
*
1541 mono_create_delegate_trampoline_info (MonoDomain
*domain
, MonoClass
*klass
, MonoMethod
*method
)
1545 MonoDelegateTrampInfo
*tramp_info
;
1546 MonoClassMethodPair pair
, *dpair
;
1547 guint32 code_size
= 0;
1550 pair
.method
= method
;
1551 mono_domain_lock (domain
);
1552 tramp_info
= (MonoDelegateTrampInfo
*)g_hash_table_lookup (domain_jit_info (domain
)->delegate_trampoline_hash
, &pair
);
1553 mono_domain_unlock (domain
);
1557 invoke
= mono_get_delegate_invoke (klass
);
1560 tramp_info
= (MonoDelegateTrampInfo
*)mono_domain_alloc0 (domain
, sizeof (MonoDelegateTrampInfo
));
1561 tramp_info
->invoke
= invoke
;
1562 tramp_info
->invoke_sig
= mono_method_signature (invoke
);
1563 tramp_info
->impl_this
= mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke
), TRUE
);
1564 tramp_info
->impl_nothis
= mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke
), FALSE
);
1565 tramp_info
->method
= method
;
1567 error_init (&error
);
1568 tramp_info
->sig
= mono_method_signature_checked (method
, &error
);
1569 tramp_info
->need_rgctx_tramp
= mono_method_needs_static_rgctx_invoke (method
, FALSE
);
1571 tramp_info
->invoke_impl
= mono_create_specific_trampoline (tramp_info
, MONO_TRAMPOLINE_DELEGATE
, domain
, &code_size
);
1572 g_assert (code_size
);
1574 dpair
= (MonoClassMethodPair
*)mono_domain_alloc0 (domain
, sizeof (MonoClassMethodPair
));
1575 memcpy (dpair
, &pair
, sizeof (MonoClassMethodPair
));
1577 /* store trampoline address */
1578 mono_domain_lock (domain
);
1579 g_hash_table_insert (domain_jit_info (domain
)->delegate_trampoline_hash
, dpair
, tramp_info
);
1580 mono_domain_unlock (domain
);
1586 no_delegate_trampoline (void)
1588 g_assert_not_reached ();
1592 mono_create_delegate_trampoline (MonoDomain
*domain
, MonoClass
*klass
)
1594 if (mono_llvm_only
|| mono_use_interpreter
)
1595 return no_delegate_trampoline
;
1597 return mono_create_delegate_trampoline_info (domain
, klass
, NULL
)->invoke_impl
;
1601 mono_create_delegate_virtual_trampoline (MonoDomain
*domain
, MonoClass
*klass
, MonoMethod
*method
)
1603 MonoMethod
*invoke
= mono_get_delegate_invoke (klass
);
1606 return mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke
), method
);
1610 mono_create_rgctx_lazy_fetch_trampoline (guint32 offset
)
1612 MonoTrampInfo
*info
;
1613 gpointer tramp
, ptr
;
1615 mono_trampolines_lock ();
1616 if (rgctx_lazy_fetch_trampoline_hash
)
1617 tramp
= g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash
, GUINT_TO_POINTER (offset
));
1620 mono_trampolines_unlock ();
1624 if (mono_aot_only
) {
1625 ptr
= mono_aot_get_lazy_fetch_trampoline (offset
);
1627 tramp
= mono_arch_create_rgctx_lazy_fetch_trampoline (offset
, &info
, FALSE
);
1628 mono_tramp_info_register (info
, NULL
);
1629 ptr
= mono_create_ftnptr (mono_get_root_domain (), tramp
);
1632 mono_trampolines_lock ();
1633 if (!rgctx_lazy_fetch_trampoline_hash
) {
1634 rgctx_lazy_fetch_trampoline_hash
= g_hash_table_new (NULL
, NULL
);
1635 rgctx_lazy_fetch_trampoline_hash_addr
= g_hash_table_new (NULL
, NULL
);
1637 g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash
, GUINT_TO_POINTER (offset
), ptr
);
1638 g_assert (offset
!= -1);
1639 g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash_addr
, ptr
, GUINT_TO_POINTER (offset
+ 1));
1640 rgctx_num_lazy_fetch_trampolines
++;
1641 mono_trampolines_unlock ();
1647 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr
)
1651 mono_trampolines_lock ();
1652 if (rgctx_lazy_fetch_trampoline_hash_addr
) {
1653 /* We store the real offset + 1 so we can detect when the lookup fails */
1654 offset
= GPOINTER_TO_INT (g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr
, addr
));
1662 mono_trampolines_unlock ();
1666 static const char*tramp_names
[MONO_TRAMPOLINE_NUM
] = {
1673 "restore_stack_prot",
1674 "generic_virtual_remoting",
1679 * mono_get_generic_trampoline_simple_name:
1683 mono_get_generic_trampoline_simple_name (MonoTrampolineType tramp_type
)
1685 return tramp_names
[tramp_type
];
1689 * mono_get_generic_trampoline_name:
1691 * Returns a pointer to malloc-ed memory.
1694 mono_get_generic_trampoline_name (MonoTrampolineType tramp_type
)
1696 return g_strdup_printf ("generic_trampoline_%s", tramp_names
[tramp_type
]);
1700 * mono_get_rgctx_fetch_trampoline_name:
1702 * Returns a pointer to malloc-ed memory.
1705 mono_get_rgctx_fetch_trampoline_name (int slot
)
1710 mrgctx
= MONO_RGCTX_SLOT_IS_MRGCTX (slot
);
1711 index
= MONO_RGCTX_SLOT_INDEX (slot
);
1713 return g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", mrgctx
? "mrgctx" : "rgctx", index
);
1717 * mini_get_single_step_trampoline:
1719 * Return a trampoline which calls debugger_agent_single_step_from_context ().
1722 mini_get_single_step_trampoline (void)
1724 static gpointer trampoline
;
1729 if (mono_aot_only
) {
1730 tramp
= mono_aot_get_trampoline ("sdb_single_step_trampoline");
1732 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1733 MonoTrampInfo
*info
;
1734 tramp
= mono_arch_create_sdb_trampoline (TRUE
, &info
, FALSE
);
1735 mono_tramp_info_register (info
, NULL
);
1738 g_assert_not_reached ();
1741 mono_memory_barrier ();
1749 * mini_get_breakpoint_trampoline:
1751 * Return a trampoline which calls debugger_agent_breakpoint_from_context ().
1754 mini_get_breakpoint_trampoline (void)
1756 static gpointer trampoline
;
1761 if (mono_aot_only
) {
1762 tramp
= mono_aot_get_trampoline ("sdb_breakpoint_trampoline");
1764 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1765 MonoTrampInfo
*info
;
1766 tramp
= mono_arch_create_sdb_trampoline (FALSE
, &info
, FALSE
);
1767 mono_tramp_info_register (info
, NULL
);
1770 g_assert_not_reached ();
1773 mono_memory_barrier ();