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 (m_class_get_byval_arg (vt
->klass
), MONO_TYPE_NAME_FORMAT_IL
), mono_type_get_name_full (m_class_get_byval_arg (imt_method
->klass
), 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
&& !m_class_is_valuetype (vt
->klass
)) {
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 if (mono_class_has_dim_conflicts (vt
->klass
)) {
578 GSList
*conflicts
= mono_class_get_dim_conflicts (vt
->klass
);
580 MonoMethod
*decl
= imt_method
;
582 if (decl
->is_inflated
)
583 decl
= mono_method_get_declaring_generic_method (decl
);
585 gboolean in_conflict
= FALSE
;
586 for (l
= conflicts
; l
; l
= l
->next
) {
587 if (decl
== l
->data
) {
593 char *class_name
= mono_class_full_name (vt
->klass
);
594 char *method_name
= mono_method_full_name (decl
, TRUE
);
595 mono_error_set_not_supported (error
, "Interface method '%s' in class '%s' has multiple candidate implementations.", method_name
, class_name
);
597 g_free (method_name
);
602 /* We must handle magic interfaces on rank 1 arrays of ref types as if they were variant */
603 if (!variant_iface
&& m_class_get_rank (vt
->klass
) == 1 && !m_class_is_valuetype (m_class_get_element_class (vt
->klass
)) && m_class_is_array_special_interface (imt_method
->klass
))
604 variant_iface
= imt_method
;
606 /* This is the vcall slot which gets called through the IMT trampoline */
607 vtable_slot_to_patch
= vtable_slot
;
611 * We found AOT compiled code for the method, skip the rest.
613 if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot
))
616 return mono_create_ftnptr (mono_domain_get (), addr
);
624 * The virtual check is needed because is_generic_method_definition (m) could
625 * return TRUE for methods used in IMT calls too.
627 if (virtual_
&& is_generic_method_definition (m
)) {
628 MonoGenericContext context
= { NULL
, NULL
};
629 MonoMethod
*declaring
;
632 declaring
= mono_method_get_declaring_generic_method (m
);
636 if (mono_class_is_ginst (m
->klass
))
637 context
.class_inst
= mono_class_get_generic_class (m
->klass
)->context
.class_inst
;
639 g_assert (!mono_class_is_gtd (m
->klass
));
641 generic_virtual
= mono_arch_find_imt_method (regs
, code
);
642 g_assert (generic_virtual
);
643 g_assert (generic_virtual
->is_inflated
);
644 context
.method_inst
= ((MonoMethodInflated
*)generic_virtual
)->context
.method_inst
;
646 m
= mono_class_inflate_generic_method_checked (declaring
, &context
, error
);
647 mono_error_assert_ok (error
);
648 /* FIXME: only do this if the method is sharable */
649 need_rgctx_tramp
= TRUE
;
650 } else if ((context_used
= mono_method_check_context_used (m
))) {
651 MonoClass
*klass
= NULL
;
652 MonoMethod
*actual_method
= NULL
;
653 MonoVTable
*vt
= NULL
;
654 MonoGenericInst
*method_inst
= NULL
;
657 generic_shared
= TRUE
;
660 * The caller is gshared code, compute the actual method to call from M and this/rgctx.
662 if (m
->is_inflated
&& mono_method_get_context (m
)->method_inst
) {
663 MonoMethodRuntimeGenericContext
*mrgctx
= (MonoMethodRuntimeGenericContext
*)mono_arch_find_static_call_vtable (regs
, code
);
665 klass
= mrgctx
->class_vtable
->klass
;
666 method_inst
= mrgctx
->method_inst
;
667 } else if ((m
->flags
& METHOD_ATTRIBUTE_STATIC
) || m_class_is_valuetype (m
->klass
)) {
668 MonoVTable
*vtable
= mono_arch_find_static_call_vtable (regs
, code
);
670 klass
= vtable
->klass
;
672 MonoObject
*this_argument
= (MonoObject
*)mono_arch_get_this_arg_from_call (regs
, code
);
674 vt
= this_argument
->vtable
;
675 vtable_slot
= orig_vtable_slot
;
677 g_assert (m_class_is_inited (this_argument
->vtable
->klass
));
680 mono_class_setup_supertypes (this_argument
->vtable
->klass
);
681 klass
= m_class_get_supertypes (this_argument
->vtable
->klass
) [m_class_get_idepth (m
->klass
) - 1];
685 g_assert (vtable_slot
|| klass
);
688 int displacement
= vtable_slot
- ((gpointer
*)vt
);
690 g_assert_not_reached ();
692 g_assert (displacement
> 0);
694 actual_method
= m_class_get_vtable (vt
->klass
) [displacement
];
697 if (method_inst
|| m
->wrapper_type
) {
698 MonoGenericContext context
= { NULL
, NULL
};
701 declaring
= mono_method_get_declaring_generic_method (m
);
705 if (mono_class_is_ginst (klass
))
706 context
.class_inst
= mono_class_get_generic_class (klass
)->context
.class_inst
;
707 else if (mono_class_is_gtd (klass
))
708 context
.class_inst
= mono_class_get_generic_container (klass
)->context
.class_inst
;
709 context
.method_inst
= method_inst
;
711 actual_method
= mono_class_inflate_generic_method_checked (declaring
, &context
, error
);
712 mono_error_assert_ok (error
);
714 actual_method
= mono_class_get_method_generic (klass
, m
, error
);
715 mono_error_assert_ok (error
);
719 g_assert (actual_method
);
720 g_assert (actual_method
->klass
== klass
);
722 if (actual_method
->is_inflated
)
723 declaring
= mono_method_get_declaring_generic_method (actual_method
);
730 if (m
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
) {
731 m
= mono_marshal_get_synchronized_wrapper (m
);
732 need_rgctx_tramp
= FALSE
;
735 addr
= compiled_method
= mono_jit_compile_method (m
, error
);
739 if (generic_virtual
|| variant_iface
) {
740 if (m_class_is_valuetype (vt
->klass
)) /*FIXME is this required variant iface?*/
741 need_unbox_tramp
= TRUE
;
742 } else if (orig_vtable_slot
) {
743 if (m_class_is_valuetype (m
->klass
))
744 need_unbox_tramp
= TRUE
;
747 addr
= mini_add_method_trampoline (m
, compiled_method
, need_rgctx_tramp
, need_unbox_tramp
);
749 if (generic_virtual
|| variant_iface
) {
750 MonoMethod
*target
= generic_virtual
? generic_virtual
: variant_iface
;
752 vtable_slot
= orig_vtable_slot
;
753 g_assert (vtable_slot
);
755 mono_method_add_generic_virtual_invocation (mono_domain_get (),
762 /* the method was jumped to */
764 MonoDomain
*domain
= mono_domain_get ();
766 mini_patch_jump_sites (domain
, m
, mono_get_addr_from_ftnptr (addr
));
768 /* Patch the got entries pointing to this method */
770 * We do this here instead of in mono_codegen () to cover the case when m
771 * was loaded from an aot image.
773 if (domain_jit_info (domain
)->jump_target_got_slot_hash
) {
776 mono_domain_lock (domain
);
777 list
= (GSList
*)g_hash_table_lookup (domain_jit_info (domain
)->jump_target_got_slot_hash
, m
);
779 for (tmp
= list
; tmp
; tmp
= tmp
->next
) {
780 gpointer
*got_slot
= (gpointer
*)tmp
->data
;
783 g_hash_table_remove (domain_jit_info (domain
)->jump_target_got_slot_hash
, m
);
786 mono_domain_unlock (domain
);
792 vtable_slot
= orig_vtable_slot
;
795 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
))) {
796 g_assert (*vtable_slot_to_patch
);
797 *vtable_slot_to_patch
= mono_get_addr_from_ftnptr (addr
);
800 guint8
*plt_entry
= mono_aot_get_plt_entry (code
);
801 gboolean no_patch
= FALSE
;
802 MonoJitInfo
*target_ji
;
805 if (generic_shared
) {
807 mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
809 ji
= mini_jit_info_table_find (mono_domain_get (), (char*)code
, NULL
);
811 if (ji
&& target_ji
&& generic_shared
&& ji
->has_generic_jit_info
&& !target_ji
->has_generic_jit_info
) {
816 mono_aot_patch_plt_entry (code
, plt_entry
, NULL
, regs
, (guint8
*)addr
);
818 if (generic_shared
) {
819 if (m
->wrapper_type
!= MONO_WRAPPER_NONE
)
820 m
= mono_marshal_method_from_wrapper (m
);
821 //g_assert (mono_method_is_generic_sharable (m, FALSE));
824 /* Patch calling code */
826 mini_jit_info_table_find (mono_domain_get (), (char *)mono_get_addr_from_ftnptr (compiled_method
), NULL
);
828 ji
= mini_jit_info_table_find (mono_domain_get (), (char*)code
, NULL
);
830 if (ji
&& target_ji
&& generic_shared
&& ji
->has_generic_jit_info
&& !target_ji
->has_generic_jit_info
) {
832 * Can't patch the call as the caller is gshared, but the callee is not. Happens when
833 * generic sharing fails.
834 * FIXME: Performance problem.
838 #if LLVM_API_VERSION > 100
839 /* LLVM code doesn't make direct calls */
840 if (ji
&& ji
->from_llvm
)
843 if (!no_patch
&& mono_method_same_domain (ji
, target_ji
))
844 mono_arch_patch_callsite ((guint8
*)ji
->code_start
, code
, (guint8
*)addr
);
852 * mono_magic_trampoline:
854 * This trampoline handles normal calls from JITted code.
857 mono_magic_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer arg
, guint8
* tramp
)
862 MONO_REQ_GC_UNSAFE_MODE
;
864 g_assert (mono_thread_is_gc_unsafe_mode ());
866 UnlockedIncrement (&trampoline_calls
);
868 res
= common_call_trampoline (regs
, code
, (MonoMethod
*)arg
, NULL
, NULL
, error
);
869 if (!is_ok (error
)) {
870 mono_error_set_pending_exception (error
);
878 * mono_vcall_trampoline:
880 * This trampoline handles virtual calls.
883 mono_vcall_trampoline (mgreg_t
*regs
, guint8
*code
, int slot
, guint8
*tramp
)
885 MONO_REQ_GC_UNSAFE_MODE
;
887 MonoObject
*this_arg
;
889 gpointer
*vtable_slot
;
892 gpointer addr
, res
= NULL
;
894 UnlockedIncrement (&trampoline_calls
);
897 * We need to obtain the following pieces of information:
898 * - the method which needs to be compiled.
900 * We use one vtable trampoline per vtable slot index, so we need only the vtable,
901 * the other two can be computed from the vtable + the slot index.
905 * Obtain the vtable from the 'this' arg.
907 this_arg
= (MonoObject
*)mono_arch_get_this_arg_from_call (regs
, code
);
910 vt
= this_arg
->vtable
;
913 /* Normal virtual call */
914 vtable_slot
= &(vt
->vtable
[slot
]);
916 /* Avoid loading metadata or creating a generic vtable if possible */
917 addr
= mono_aot_get_method_from_vt_slot (mono_domain_get (), vt
, slot
, error
);
918 goto_if_nok (error
, leave
);
919 if (addr
&& !m_class_is_valuetype (vt
->klass
)) {
920 if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot
))
923 return mono_create_ftnptr (mono_domain_get (), addr
);
928 * is_generic_method_definition() above) also
929 * goes away if we do a
930 * mono_class_setup_vtable (vt->klass) here,
931 * because we then inflate the method
932 * correctly, put it in the cache, and the
933 * "wrong" inflation invocation still looks up
934 * the correctly inflated method.
936 * The hack above seems more stable and
939 m
= mono_class_get_vtable_entry (vt
->klass
, slot
);
942 vtable_slot
= &(((gpointer
*)vt
) [slot
]);
947 res
= common_call_trampoline (regs
, code
, m
, vt
, vtable_slot
, error
);
949 if (!mono_error_ok (error
)) {
950 mono_error_set_pending_exception (error
);
956 #ifndef DISABLE_REMOTING
958 mono_generic_virtual_remoting_trampoline (mgreg_t
*regs
, guint8
*code
, MonoMethod
*m
, guint8
*tramp
)
960 MONO_REQ_GC_UNSAFE_MODE
;
963 MonoGenericContext context
= { NULL
, NULL
};
964 MonoMethod
*imt_method
, *declaring
;
967 UnlockedIncrement (&trampoline_calls
);
969 g_assert (m
->is_generic
);
972 declaring
= mono_method_get_declaring_generic_method (m
);
976 if (mono_class_is_ginst (m
->klass
))
977 context
.class_inst
= mono_class_get_generic_class (m
->klass
)->context
.class_inst
;
979 g_assert (!mono_class_is_gtd (m
->klass
));
981 imt_method
= mono_arch_find_imt_method (regs
, code
);
982 if (imt_method
->is_inflated
)
983 context
.method_inst
= ((MonoMethodInflated
*)imt_method
)->context
.method_inst
;
984 m
= mono_class_inflate_generic_method_checked (declaring
, &context
, error
);
985 g_assert (mono_error_ok (error
)); /* FIXME don't swallow the error */;
986 m
= mono_marshal_get_remoting_invoke_with_check (m
, error
);
987 if (!is_ok (error
)) {
988 mono_error_set_pending_exception (error
);
992 addr
= mono_jit_compile_method (m
, error
);
993 if (!mono_error_ok (error
)) {
994 mono_error_set_pending_exception (error
);
1004 * mono_aot_trampoline:
1006 * This trampoline handles calls made from AOT code. We try to bypass the
1007 * normal JIT compilation logic to avoid loading the metadata for the method.
1009 #ifdef MONO_ARCH_AOT_SUPPORTED
1011 mono_aot_trampoline (mgreg_t
*regs
, guint8
*code
, guint8
*token_info
,
1014 MONO_REQ_GC_UNSAFE_MODE
;
1018 MonoMethod
*method
= NULL
;
1023 UnlockedIncrement (&trampoline_calls
);
1025 image
= (MonoImage
*)*(gpointer
*)(gpointer
)token_info
;
1026 token_info
+= sizeof (gpointer
);
1027 token
= *(guint32
*)(gpointer
)token_info
;
1029 addr
= mono_aot_get_method_from_token (mono_domain_get (), image
, token
, error
);
1031 mono_error_cleanup (error
);
1033 method
= mono_get_method_checked (image
, token
, NULL
, NULL
, error
);
1035 g_error ("Could not load AOT trampoline due to %s", mono_error_get_message (error
));
1037 /* Use the generic code */
1038 return mono_magic_trampoline (regs
, code
, method
, tramp
);
1041 addr
= mono_create_ftnptr (mono_domain_get (), addr
);
1043 /* This is a normal call through a PLT entry */
1044 plt_entry
= mono_aot_get_plt_entry (code
);
1045 g_assert (plt_entry
);
1047 mono_aot_patch_plt_entry (code
, plt_entry
, NULL
, regs
, (guint8
*)addr
);
1053 * mono_aot_plt_trampoline:
1055 * This trampoline handles calls made from AOT code through the PLT table.
1058 mono_aot_plt_trampoline (mgreg_t
*regs
, guint8
*code
, guint8
*aot_module
,
1061 MONO_REQ_GC_UNSAFE_MODE
;
1063 guint32 plt_info_offset
= mono_aot_get_plt_info_offset (regs
, code
);
1067 UnlockedIncrement (&trampoline_calls
);
1069 res
= mono_aot_plt_resolve (aot_module
, plt_info_offset
, code
, error
);
1071 if (!mono_error_ok (error
)) {
1072 mono_error_set_pending_exception (error
);
1075 // FIXME: Error handling (how ?)
1084 mono_rgctx_lazy_fetch_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer data
, guint8
*tramp
)
1086 MONO_REQ_GC_UNSAFE_MODE
;
1088 guint32 slot
= GPOINTER_TO_UINT (data
);
1089 mgreg_t
*r
= (mgreg_t
*)regs
;
1090 gpointer arg
= (gpointer
)(gssize
)r
[MONO_ARCH_VTABLE_REG
];
1091 guint32 index
= MONO_RGCTX_SLOT_INDEX (slot
);
1092 gboolean mrgctx
= MONO_RGCTX_SLOT_IS_MRGCTX (slot
);
1096 UnlockedIncrement (&trampoline_calls
);
1097 UnlockedIncrement (&rgctx_unmanaged_lookups
);
1100 res
= mono_method_fill_runtime_generic_context ((MonoMethodRuntimeGenericContext
*)arg
, index
, error
);
1102 res
= mono_class_fill_runtime_generic_context ((MonoVTable
*)arg
, index
, error
);
1103 if (!mono_error_ok (error
)) {
1104 mono_error_set_pending_exception (error
);
1111 * mono_delegate_trampoline:
1113 * This trampoline handles calls made to Delegate:Invoke ().
1114 * This is called once the first time a delegate is invoked, so it must be fast.
1117 mono_delegate_trampoline (mgreg_t
*regs
, guint8
*code
, gpointer
*arg
, guint8
* tramp
)
1119 MONO_REQ_GC_UNSAFE_MODE
;
1121 MonoDomain
*domain
= mono_domain_get ();
1122 MonoDelegate
*delegate
;
1125 MonoMethod
*method
= NULL
;
1127 gboolean multicast
, callvirt
= FALSE
, closed_over_null
= FALSE
;
1128 gboolean need_rgctx_tramp
= FALSE
;
1129 gboolean need_unbox_tramp
= FALSE
;
1130 gboolean enable_caching
= TRUE
;
1131 MonoDelegateTrampInfo
*tramp_info
= (MonoDelegateTrampInfo
*)arg
;
1132 MonoMethod
*invoke
= tramp_info
->invoke
;
1133 guint8
*impl_this
= (guint8
*)tramp_info
->impl_this
;
1134 guint8
*impl_nothis
= (guint8
*)tramp_info
->impl_nothis
;
1135 ERROR_DECL_VALUE (err
);
1136 MonoMethodSignature
*sig
;
1137 gpointer addr
, compiled_method
;
1138 gboolean is_remote
= FALSE
;
1140 UnlockedIncrement (&trampoline_calls
);
1142 /* Obtain the delegate object according to the calling convention */
1143 delegate
= (MonoDelegate
*)mono_arch_get_this_arg_from_call (regs
, code
);
1144 g_assert (mono_class_has_parent (mono_object_class (delegate
), mono_defaults
.multicastdelegate_class
));
1146 if (delegate
->method
) {
1147 method
= delegate
->method
;
1150 * delegate->method_ptr == NULL means the delegate was initialized by
1151 * mini_delegate_ctor, while != NULL means it is initialized by
1152 * mono_delegate_ctor_with_method (). In both cases, we need to add wrappers
1153 * (ctor_with_method () does this, but it doesn't store the wrapper back into
1154 * delegate->method).
1156 #ifndef DISABLE_REMOTING
1157 if (delegate
->target
&& mono_object_is_transparent_proxy (delegate
->target
)) {
1161 if (((MonoTransparentProxy
*)delegate
->target
)->remote_class
->proxy_class
!= mono_class_get_com_object_class () &&
1162 !mono_class_is_com_object (((MonoTransparentProxy
*)delegate
->target
)->remote_class
->proxy_class
))
1164 method
= mono_marshal_get_remoting_invoke (method
, &err
);
1165 if (!is_ok (&err
)) {
1166 mono_error_set_pending_exception (&err
);
1172 sig
= tramp_info
->sig
;
1173 if (!(sig
&& method
== tramp_info
->method
)) {
1175 sig
= mono_method_signature_checked (method
, &err
);
1177 mono_error_set_pending_exception (&err
);
1182 if (sig
->hasthis
&& m_class_is_valuetype (method
->klass
)) {
1183 gboolean need_unbox
= TRUE
;
1185 if (tramp_info
->invoke_sig
->param_count
> sig
->param_count
&& tramp_info
->invoke_sig
->params
[0]->byref
)
1190 need_unbox_tramp
= TRUE
;
1192 method
= mono_marshal_get_unbox_wrapper (method
);
1196 // If "delegate->method_ptr" is null mono_get_addr_from_ftnptr will fail if
1197 // ftnptrs are being used. "method" would end up null on archtitectures without
1198 // ftnptrs so we can just skip this.
1199 } else if (delegate
->method_ptr
) {
1200 ji
= mono_jit_info_table_find (domain
, mono_get_addr_from_ftnptr (delegate
->method_ptr
));
1202 method
= jinfo_get_method (ji
);
1206 sig
= tramp_info
->sig
;
1207 if (!(sig
&& method
== tramp_info
->method
)) {
1209 sig
= mono_method_signature_checked (method
, &err
);
1211 mono_error_set_pending_exception (&err
);
1216 callvirt
= !delegate
->target
&& sig
->hasthis
;
1218 closed_over_null
= tramp_info
->invoke_sig
->param_count
== sig
->param_count
;
1220 if (callvirt
&& !closed_over_null
) {
1222 * The delegate needs to make a virtual call to the target method using its
1223 * first argument as the receiver. This is hard to support in full-aot, so
1224 * optimize it in some cases if possible.
1225 * If the target method is not virtual or is in a sealed class,
1226 * the vcall will call it directly.
1227 * If the call doesn't return a valuetype, then the vcall uses the same calling
1228 * convention as a normal call.
1230 if ((mono_class_is_sealed (method
->klass
) || !(method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
)) && !MONO_TYPE_ISSTRUCT (sig
->ret
)) {
1232 enable_caching
= FALSE
;
1236 if (delegate
->target
&&
1237 method
->flags
& METHOD_ATTRIBUTE_VIRTUAL
&&
1238 method
->flags
& METHOD_ATTRIBUTE_ABSTRACT
&&
1239 mono_class_is_abstract (method
->klass
)) {
1240 method
= mono_object_get_virtual_method (delegate
->target
, method
);
1241 enable_caching
= FALSE
;
1244 if (method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
)
1245 method
= mono_marshal_get_synchronized_wrapper (method
);
1247 if (method
== tramp_info
->method
)
1248 need_rgctx_tramp
= tramp_info
->need_rgctx_tramp
;
1249 else if (mono_method_needs_static_rgctx_invoke (method
, FALSE
))
1250 need_rgctx_tramp
= TRUE
;
1254 * If the called address is a trampoline, replace it with the compiled method so
1255 * further calls don't have to go through the trampoline.
1257 if (method
&& !callvirt
) {
1258 /* Avoid the overhead of looking up an already compiled method if possible */
1259 if (enable_caching
&& delegate
->method_code
&& *delegate
->method_code
) {
1260 delegate
->method_ptr
= *delegate
->method_code
;
1262 compiled_method
= addr
= mono_jit_compile_method (method
, error
);
1263 if (!mono_error_ok (error
)) {
1264 mono_error_set_pending_exception (error
);
1267 addr
= mini_add_method_trampoline (method
, compiled_method
, need_rgctx_tramp
, need_unbox_tramp
);
1268 delegate
->method_ptr
= addr
;
1269 if (enable_caching
&& delegate
->method_code
)
1270 *delegate
->method_code
= (guint8
*)delegate
->method_ptr
;
1273 if (need_rgctx_tramp
)
1274 delegate
->method_ptr
= mono_create_static_rgctx_trampoline (method
, delegate
->method_ptr
);
1277 /* Necessary for !code condition to fallback to slow path */
1280 multicast
= ((MonoMulticastDelegate
*)delegate
)->delegates
!= NULL
;
1281 if (!multicast
&& !callvirt
) {
1282 if (method
&& (method
->flags
& METHOD_ATTRIBUTE_STATIC
) && mono_method_signature (method
)->param_count
== mono_method_signature (invoke
)->param_count
+ 1)
1283 /* Closed static delegate */
1286 code
= delegate
->target
? impl_this
: impl_nothis
;
1290 /* The general, unoptimized case */
1291 m
= mono_marshal_get_delegate_invoke (invoke
, delegate
);
1292 code
= (guint8
*)mono_jit_compile_method (m
, error
);
1293 if (!mono_error_ok (error
)) {
1294 mono_error_set_pending_exception (error
);
1297 code
= (guint8
*)mini_add_method_trampoline (m
, code
, mono_method_needs_static_rgctx_invoke (m
, FALSE
), FALSE
);
1300 delegate
->invoke_impl
= mono_get_addr_from_ftnptr (code
);
1301 if (enable_caching
&& !callvirt
&& tramp_info
->method
) {
1302 tramp_info
->method_ptr
= delegate
->method_ptr
;
1303 tramp_info
->invoke_impl
= delegate
->invoke_impl
;
1310 * mono_get_trampoline_func:
1312 * Return the C function which needs to be called by the generic trampoline of type
1316 mono_get_trampoline_func (MonoTrampolineType tramp_type
)
1318 switch (tramp_type
) {
1319 case MONO_TRAMPOLINE_JIT
:
1320 case MONO_TRAMPOLINE_JUMP
:
1321 return mono_magic_trampoline
;
1322 case MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
:
1323 return mono_rgctx_lazy_fetch_trampoline
;
1324 #ifdef MONO_ARCH_AOT_SUPPORTED
1325 case MONO_TRAMPOLINE_AOT
:
1326 return mono_aot_trampoline
;
1327 case MONO_TRAMPOLINE_AOT_PLT
:
1328 return mono_aot_plt_trampoline
;
1330 case MONO_TRAMPOLINE_DELEGATE
:
1331 return mono_delegate_trampoline
;
1332 #ifndef DISABLE_REMOTING
1333 case MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
:
1334 return mono_generic_virtual_remoting_trampoline
;
1336 case MONO_TRAMPOLINE_VCALL
:
1337 return mono_vcall_trampoline
;
1339 g_assert_not_reached ();
1345 create_trampoline_code (MonoTrampolineType tramp_type
)
1347 MonoTrampInfo
*info
;
1350 code
= mono_arch_create_generic_trampoline (tramp_type
, &info
, FALSE
);
1351 mono_tramp_info_register (info
, NULL
);
1357 mono_trampolines_init (void)
1359 mono_os_mutex_init_recursive (&trampolines_mutex
);
1364 mono_trampoline_code
[MONO_TRAMPOLINE_JIT
] = create_trampoline_code (MONO_TRAMPOLINE_JIT
);
1365 mono_trampoline_code
[MONO_TRAMPOLINE_JUMP
] = create_trampoline_code (MONO_TRAMPOLINE_JUMP
);
1366 mono_trampoline_code
[MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
] = create_trampoline_code (MONO_TRAMPOLINE_RGCTX_LAZY_FETCH
);
1367 #ifdef MONO_ARCH_AOT_SUPPORTED
1368 mono_trampoline_code
[MONO_TRAMPOLINE_AOT
] = create_trampoline_code (MONO_TRAMPOLINE_AOT
);
1369 mono_trampoline_code
[MONO_TRAMPOLINE_AOT_PLT
] = create_trampoline_code (MONO_TRAMPOLINE_AOT_PLT
);
1371 mono_trampoline_code
[MONO_TRAMPOLINE_DELEGATE
] = create_trampoline_code (MONO_TRAMPOLINE_DELEGATE
);
1372 #ifndef DISABLE_REMOTING
1373 mono_trampoline_code
[MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
] = create_trampoline_code (MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING
);
1375 mono_trampoline_code
[MONO_TRAMPOLINE_VCALL
] = create_trampoline_code (MONO_TRAMPOLINE_VCALL
);
1377 mono_counters_register ("Calls to trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &trampoline_calls
);
1378 mono_counters_register ("JIT trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &jit_trampolines
);
1379 mono_counters_register ("Unbox trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &unbox_trampolines
);
1380 mono_counters_register ("Static rgctx trampolines", MONO_COUNTER_JIT
| MONO_COUNTER_INT
, &static_rgctx_trampolines
);
1381 mono_counters_register ("RGCTX unmanaged lookups", MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &rgctx_unmanaged_lookups
);
1382 mono_counters_register ("RGCTX num lazy fetch trampolines", MONO_COUNTER_GENERICS
| MONO_COUNTER_INT
, &rgctx_num_lazy_fetch_trampolines
);
1386 mono_trampolines_cleanup (void)
1388 if (rgctx_lazy_fetch_trampoline_hash
)
1389 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash
);
1390 if (rgctx_lazy_fetch_trampoline_hash_addr
)
1391 g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr
);
1393 mono_os_mutex_destroy (&trampolines_mutex
);
1397 mono_get_trampoline_code (MonoTrampolineType tramp_type
)
1399 g_assert (mono_trampoline_code
[tramp_type
]);
1401 return mono_trampoline_code
[tramp_type
];
1405 mono_create_specific_trampoline (gpointer arg1
, MonoTrampolineType tramp_type
, MonoDomain
*domain
, guint32
*code_len
)
1411 code
= mono_aot_create_specific_trampoline (mono_defaults
.corlib
, arg1
, tramp_type
, domain
, &len
);
1413 code
= mono_arch_create_specific_trampoline (arg1
, tramp_type
, domain
, &len
);
1414 mono_lldb_save_specific_trampoline_info (arg1
, tramp_type
, domain
, code
, len
);
1421 mono_create_jump_trampoline (MonoDomain
*domain
, MonoMethod
*method
, gboolean add_sync_wrapper
, MonoError
*error
)
1425 guint32 code_size
= 0;
1429 if (mono_use_interpreter
) {
1430 gpointer ret
= mini_get_interp_callbacks ()->create_trampoline (domain
, method
, error
);
1431 if (!mono_error_ok (error
))
1436 code
= mono_jit_find_compiled_method_with_jit_info (domain
, method
, &ji
);
1438 * We cannot recover the correct type of a shared generic
1439 * method from its native code address, so we use the
1440 * trampoline instead.
1441 * For synchronized methods, the trampoline adds the wrapper.
1443 if (code
&& !ji
->has_generic_jit_info
&& !(method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
))
1446 if (mono_llvm_only
) {
1447 code
= mono_jit_compile_method (method
, error
);
1448 if (!mono_error_ok (error
))
1453 mono_domain_lock (domain
);
1454 code
= g_hash_table_lookup (domain_jit_info (domain
)->jump_trampoline_hash
, method
);
1455 mono_domain_unlock (domain
);
1459 code
= mono_create_specific_trampoline (method
, MONO_TRAMPOLINE_JUMP
, mono_domain_get (), &code_size
);
1460 g_assert (code_size
);
1462 ji
= (MonoJitInfo
*)mono_domain_alloc0 (domain
, MONO_SIZEOF_JIT_INFO
);
1463 ji
->code_start
= code
;
1464 ji
->code_size
= code_size
;
1465 ji
->d
.method
= method
;
1468 * mono_delegate_ctor needs to find the method metadata from the
1469 * trampoline address, so we save it here.
1472 mono_jit_info_table_add (domain
, ji
);
1474 mono_domain_lock (domain
);
1475 g_hash_table_insert (domain_jit_info (domain
)->jump_trampoline_hash
, method
, ji
->code_start
);
1476 mono_domain_unlock (domain
);
1478 return ji
->code_start
;
1482 method_not_found (void)
1484 g_assert_not_reached ();
1488 mono_create_jit_trampoline (MonoDomain
*domain
, MonoMethod
*method
, MonoError
*error
)
1494 if (mono_aot_only
) {
1495 if (mono_llvm_only
&& method
->iflags
& METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED
)
1496 method
= mono_marshal_get_synchronized_wrapper (method
);
1498 /* Avoid creating trampolines if possible */
1499 gpointer code
= mono_jit_find_compiled_method (domain
, method
);
1503 if (mono_llvm_only
) {
1504 if (method
->wrapper_type
== MONO_WRAPPER_PROXY_ISINST
)
1505 /* These wrappers are not generated */
1506 return method_not_found
;
1507 /* Methods are lazily initialized on first call, so this can't lead recursion */
1508 code
= mono_jit_compile_method (method
, error
);
1509 if (!mono_error_ok (error
))
1515 mono_domain_lock (domain
);
1516 tramp
= g_hash_table_lookup (domain_jit_info (domain
)->jit_trampoline_hash
, method
);
1517 mono_domain_unlock (domain
);
1521 tramp
= mono_create_specific_trampoline (method
, MONO_TRAMPOLINE_JIT
, domain
, NULL
);
1523 mono_domain_lock (domain
);
1524 g_hash_table_insert (domain_jit_info (domain
)->jit_trampoline_hash
, method
, tramp
);
1525 UnlockedIncrement (&jit_trampolines
);
1526 mono_domain_unlock (domain
);
1532 mono_create_jit_trampoline_from_token (MonoImage
*image
, guint32 token
)
1536 MonoDomain
*domain
= mono_domain_get ();
1537 guint8
*buf
, *start
;
1539 buf
= start
= (guint8
*)mono_domain_alloc0 (domain
, 2 * sizeof (gpointer
));
1541 *(gpointer
*)(gpointer
)buf
= image
;
1542 buf
+= sizeof (gpointer
);
1543 *(guint32
*)(gpointer
)buf
= token
;
1545 tramp
= mono_create_specific_trampoline (start
, MONO_TRAMPOLINE_AOT
, domain
, NULL
);
1547 UnlockedIncrement (&jit_trampolines
);
1554 * mono_create_delegate_trampoline_info:
1556 * Create a trampoline info structure for the KLASS+METHOD pair.
1558 MonoDelegateTrampInfo
*
1559 mono_create_delegate_trampoline_info (MonoDomain
*domain
, MonoClass
*klass
, MonoMethod
*method
)
1563 MonoDelegateTrampInfo
*tramp_info
;
1564 MonoClassMethodPair pair
, *dpair
;
1565 guint32 code_size
= 0;
1568 pair
.method
= method
;
1569 mono_domain_lock (domain
);
1570 tramp_info
= (MonoDelegateTrampInfo
*)g_hash_table_lookup (domain_jit_info (domain
)->delegate_trampoline_hash
, &pair
);
1571 mono_domain_unlock (domain
);
1575 invoke
= mono_get_delegate_invoke (klass
);
1578 tramp_info
= (MonoDelegateTrampInfo
*)mono_domain_alloc0 (domain
, sizeof (MonoDelegateTrampInfo
));
1579 tramp_info
->invoke
= invoke
;
1580 tramp_info
->invoke_sig
= mono_method_signature (invoke
);
1581 tramp_info
->impl_this
= mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke
), TRUE
);
1582 tramp_info
->impl_nothis
= mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke
), FALSE
);
1583 tramp_info
->method
= method
;
1586 tramp_info
->sig
= mono_method_signature_checked (method
, error
);
1587 tramp_info
->need_rgctx_tramp
= mono_method_needs_static_rgctx_invoke (method
, FALSE
);
1589 tramp_info
->invoke_impl
= mono_create_specific_trampoline (tramp_info
, MONO_TRAMPOLINE_DELEGATE
, domain
, &code_size
);
1590 g_assert (code_size
);
1592 dpair
= (MonoClassMethodPair
*)mono_domain_alloc0 (domain
, sizeof (MonoClassMethodPair
));
1593 memcpy (dpair
, &pair
, sizeof (MonoClassMethodPair
));
1595 /* store trampoline address */
1596 mono_domain_lock (domain
);
1597 g_hash_table_insert (domain_jit_info (domain
)->delegate_trampoline_hash
, dpair
, tramp_info
);
1598 mono_domain_unlock (domain
);
1604 no_delegate_trampoline (void)
1606 g_assert_not_reached ();
1610 mono_create_delegate_trampoline (MonoDomain
*domain
, MonoClass
*klass
)
1612 if (mono_llvm_only
|| (mono_use_interpreter
&& !mono_aot_only
))
1613 return no_delegate_trampoline
;
1615 return mono_create_delegate_trampoline_info (domain
, klass
, NULL
)->invoke_impl
;
1619 mono_create_delegate_virtual_trampoline (MonoDomain
*domain
, MonoClass
*klass
, MonoMethod
*method
)
1621 MonoMethod
*invoke
= mono_get_delegate_invoke (klass
);
1624 return mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke
), method
);
1628 mono_create_rgctx_lazy_fetch_trampoline (guint32 offset
)
1630 MonoTrampInfo
*info
;
1631 gpointer tramp
, ptr
;
1633 mono_trampolines_lock ();
1634 if (rgctx_lazy_fetch_trampoline_hash
)
1635 tramp
= g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash
, GUINT_TO_POINTER (offset
));
1638 mono_trampolines_unlock ();
1642 if (mono_aot_only
) {
1643 ptr
= mono_aot_get_lazy_fetch_trampoline (offset
);
1645 tramp
= mono_arch_create_rgctx_lazy_fetch_trampoline (offset
, &info
, FALSE
);
1646 mono_tramp_info_register (info
, NULL
);
1647 ptr
= mono_create_ftnptr (mono_get_root_domain (), tramp
);
1650 mono_trampolines_lock ();
1651 if (!rgctx_lazy_fetch_trampoline_hash
) {
1652 rgctx_lazy_fetch_trampoline_hash
= g_hash_table_new (NULL
, NULL
);
1653 rgctx_lazy_fetch_trampoline_hash_addr
= g_hash_table_new (NULL
, NULL
);
1655 g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash
, GUINT_TO_POINTER (offset
), ptr
);
1656 g_assert (offset
!= -1);
1657 g_hash_table_insert (rgctx_lazy_fetch_trampoline_hash_addr
, ptr
, GUINT_TO_POINTER (offset
+ 1));
1658 rgctx_num_lazy_fetch_trampolines
++;
1659 mono_trampolines_unlock ();
1665 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr
)
1669 mono_trampolines_lock ();
1670 if (rgctx_lazy_fetch_trampoline_hash_addr
) {
1671 /* We store the real offset + 1 so we can detect when the lookup fails */
1672 offset
= GPOINTER_TO_INT (g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr
, addr
));
1680 mono_trampolines_unlock ();
1684 static const char*tramp_names
[MONO_TRAMPOLINE_NUM
] = {
1691 "generic_virtual_remoting",
1696 * mono_get_generic_trampoline_simple_name:
1700 mono_get_generic_trampoline_simple_name (MonoTrampolineType tramp_type
)
1702 return tramp_names
[tramp_type
];
1706 * mono_get_generic_trampoline_name:
1708 * Returns a pointer to malloc-ed memory.
1711 mono_get_generic_trampoline_name (MonoTrampolineType tramp_type
)
1713 return g_strdup_printf ("generic_trampoline_%s", tramp_names
[tramp_type
]);
1717 * mono_get_rgctx_fetch_trampoline_name:
1719 * Returns a pointer to malloc-ed memory.
1722 mono_get_rgctx_fetch_trampoline_name (int slot
)
1727 mrgctx
= MONO_RGCTX_SLOT_IS_MRGCTX (slot
);
1728 index
= MONO_RGCTX_SLOT_INDEX (slot
);
1730 return g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", mrgctx
? "mrgctx" : "rgctx", index
);
1734 * mini_get_single_step_trampoline:
1736 * Return a trampoline which calls debugger_agent_single_step_from_context ().
1739 mini_get_single_step_trampoline (void)
1741 static gpointer trampoline
;
1746 if (mono_aot_only
) {
1747 tramp
= mono_aot_get_trampoline ("sdb_single_step_trampoline");
1749 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1750 MonoTrampInfo
*info
;
1751 tramp
= mono_arch_create_sdb_trampoline (TRUE
, &info
, FALSE
);
1752 mono_tramp_info_register (info
, NULL
);
1755 g_assert_not_reached ();
1758 mono_memory_barrier ();
1766 * mini_get_breakpoint_trampoline:
1768 * Return a trampoline which calls mono_debugger_agent_breakpoint_from_context ().
1771 mini_get_breakpoint_trampoline (void)
1773 static gpointer trampoline
;
1778 if (mono_aot_only
) {
1779 tramp
= mono_aot_get_trampoline ("sdb_breakpoint_trampoline");
1781 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
1782 MonoTrampInfo
*info
;
1783 tramp
= mono_arch_create_sdb_trampoline (FALSE
, &info
, FALSE
);
1784 mono_tramp_info_register (info
, NULL
);
1787 g_assert_not_reached ();
1790 mono_memory_barrier ();