1 #ifndef __MONO_OBJECT_INTERNALS_H__
2 #define __MONO_OBJECT_INTERNALS_H__
4 #include <mono/metadata/object.h>
5 #include <mono/metadata/threads.h>
6 #include <mono/metadata/reflection.h>
7 #include <mono/metadata/mempool.h>
8 #include <mono/metadata/class-internals.h>
9 #include <mono/metadata/threads-types.h>
10 #include <mono/metadata/handle.h>
11 #include <mono/io-layer/io-layer.h>
12 #include "mono/utils/mono-compiler.h"
13 #include "mono/utils/mono-error.h"
14 #include "mono/utils/mono-stack-unwinding.h"
15 #include "mono/utils/mono-tls.h"
16 #include "mono/utils/mono-coop-mutex.h"
20 #define mono_assert(expr) G_STMT_START{ \
24 char *msg = g_strdup_printf ("file %s: line %d (%s): " \
25 "assertion failed: (%s)", __FILE__, __LINE__, \
26 __PRETTY_FUNCTION__, #expr); \
27 ex = mono_get_exception_execution_engine (msg); \
29 mono_raise_exception (ex); \
32 #define mono_assert_not_reached() G_STMT_START{ \
34 char *msg = g_strdup_printf ("file %s: line %d (%s): " \
35 "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__); \
36 ex = mono_get_exception_execution_engine (msg); \
38 mono_raise_exception (ex); \
41 #define mono_assert(expr) G_STMT_START{ \
45 char *msg = g_strdup_printf ("file %s: line %d: " \
46 "assertion failed: (%s)", __FILE__, __LINE__, \
48 ex = mono_get_exception_execution_engine (msg); \
50 mono_raise_exception (ex); \
53 #define mono_assert_not_reached() G_STMT_START{ \
55 char *msg = g_strdup_printf ("file %s: line %d): " \
56 "should not be reached", __FILE__, __LINE__); \
57 ex = mono_get_exception_execution_engine (msg); \
59 mono_raise_exception (ex); \
63 #define mono_assert(expr) g_assert(expr)
64 #define mono_assert_not_reached() g_assert_not_reached()
67 /* Use this as MONO_CHECK_ARG_NULL (arg,expr,) in functions returning void */
68 #define MONO_CHECK_ARG(arg, expr, retval) G_STMT_START{ \
69 if (G_UNLIKELY (!(expr))) \
72 char *msg = g_strdup_printf ("assertion `%s' failed", \
74 if (arg) {} /* check if the name exists */ \
75 ex = mono_get_exception_argument (#arg, msg); \
77 mono_set_pending_exception (ex); \
81 /* Use this as MONO_CHECK_ARG_NULL (arg,) in functions returning void */
82 #define MONO_CHECK_ARG_NULL(arg, retval) G_STMT_START{ \
83 if (G_UNLIKELY (arg == NULL)) \
86 if (arg) {} /* check if the name exists */ \
87 ex = mono_get_exception_argument_null (#arg); \
88 mono_set_pending_exception (ex); \
92 #define mono_string_builder_capacity(sb) sb->chunkOffset + sb->chunkChars->max_length
93 #define mono_string_builder_string_length(sb) sb->chunkOffset + sb->chunkLength
96 * Macros which cache the results of lookups locally.
97 * These should be used instead of the original versions, if the __GNUC__
98 * restriction is acceptable.
103 /* namespace and name should be a constant */
104 /* image must be mscorlib since other assemblies can be unloaded */
105 #define mono_class_from_name_cached(image,namespace,name) ({ \
106 static MonoClass *tmp_klass; \
108 g_assert (image == mono_defaults.corlib); \
109 tmp_klass = mono_class_from_name ((image), (namespace), (name)); \
110 g_assert (tmp_klass); \
113 /* name should be a compile-time constant */
114 #define mono_class_get_field_from_name_cached(klass,name) ({ \
115 static MonoClassField *tmp_field; \
117 tmp_field = mono_class_get_field_from_name ((klass), (name)); \
118 g_assert (tmp_field); \
121 /* eclass should be a run-time constant */
122 #define mono_array_class_get_cached(eclass,rank) ({ \
123 static MonoClass *tmp_klass; \
125 tmp_klass = mono_array_class_get ((eclass), (rank)); \
126 g_assert (tmp_klass); \
129 /* eclass should be a run-time constant */
130 #define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size))
134 #define mono_class_from_name_cached(image,namespace,name) mono_class_from_name ((image), (namespace), (name))
135 #define mono_class_get_field_from_name_cached(klass,name) mono_class_get_field_from_name ((klass), (name))
136 #define mono_array_class_get_cached(eclass,rank) mono_array_class_get ((eclass), (rank))
137 #define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size))
141 #ifdef MONO_BIG_ARRAYS
142 typedef uint64_t mono_array_size_t
;
143 typedef int64_t mono_array_lower_bound_t
;
144 #define MONO_ARRAY_MAX_INDEX G_MAXINT64
145 #define MONO_ARRAY_MAX_SIZE G_MAXUINT64
147 typedef uint32_t mono_array_size_t
;
148 typedef int32_t mono_array_lower_bound_t
;
149 #define MONO_ARRAY_MAX_INDEX ((int32_t) 0x7fffffff)
150 #define MONO_ARRAY_MAX_SIZE ((uint32_t) 0xffffffff)
154 mono_array_size_t length
;
155 mono_array_lower_bound_t lower_bound
;
160 /* bounds is NULL for szarrays */
161 MonoArrayBounds
*bounds
;
162 /* total number of elements of the array */
163 mono_array_size_t max_length
;
164 /* we use double to ensure proper alignment on platforms that need it */
165 double vector
[MONO_ZERO_LEN_ARRAY
];
168 #define MONO_SIZEOF_MONO_ARRAY (sizeof (MonoArray) - MONO_ZERO_LEN_ARRAY * sizeof (double))
173 mono_unichar2 chars
[MONO_ZERO_LEN_ARRAY
];
176 #define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass)
177 #define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain)
179 #define mono_string_chars_fast(s) ((mono_unichar2*)(s)->chars)
180 #define mono_string_length_fast(s) ((s)->length)
182 #define mono_array_length_fast(array) ((array)->max_length)
183 #define mono_array_addr_with_size_fast(array,size,index) ( ((char*)(array)->vector) + (size) * (index) )
185 #define mono_array_addr_fast(array,type,index) ((type*)(void*) mono_array_addr_with_size_fast (array, sizeof (type), index))
186 #define mono_array_get_fast(array,type,index) ( *(type*)mono_array_addr_fast ((array), type, (index)) )
187 #define mono_array_set_fast(array,type,index,value) \
189 type *__p = (type *) mono_array_addr_fast ((array), type, (index)); \
192 #define mono_array_setref_fast(array,index,value) \
194 void **__p = (void **) mono_array_addr_fast ((array), void*, (index)); \
195 mono_gc_wbarrier_set_arrayref ((array), __p, (MonoObject*)(value)); \
196 /* *__p = (value);*/ \
198 #define mono_array_memcpy_refs_fast(dest,destidx,src,srcidx,count) \
200 void **__p = (void **) mono_array_addr_fast ((dest), void*, (destidx)); \
201 void **__s = mono_array_addr_fast ((src), void*, (srcidx)); \
202 mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \
208 MonoObject
*identity
;
209 } MonoMarshalByRefObject
;
211 /* This is a copy of System.AppDomain */
212 struct _MonoAppDomain
{
213 MonoMarshalByRefObject mbr
;
217 typedef struct _MonoStringBuilder MonoStringBuilder
;
219 struct _MonoStringBuilder
{
221 MonoArray
*chunkChars
;
222 MonoStringBuilder
* chunkPrevious
; // Link to the block logically before this block
223 int chunkLength
; // The index in ChunkChars that represent the end of the block
224 int chunkOffset
; // The logial offset (sum of all characters in previous blocks)
236 } MonoArgumentHandle
;
239 MonoMethodSignature
*sig
;
245 struct _MonoException
{
247 /* Stores the IPs and the generic sharing infos
248 (vtable/MRGCTX) of the frames. */
249 MonoArray
*trace_ips
;
250 MonoObject
*inner_ex
;
252 MonoString
*help_link
;
253 MonoString
*class_name
;
254 MonoString
*stack_trace
;
255 MonoString
*remote_stack_trace
;
256 gint32 remote_stack_index
;
260 MonoObject
*captured_traces
;
261 MonoArray
*native_trace_ips
;
262 /* Dynamic methods referenced by the stack trace */
263 MonoObject
*dynamic_methods
;
268 } MonoSystemException
;
271 MonoSystemException base
;
272 MonoString
*param_name
;
273 } MonoArgumentException
;
277 MonoObject
*async_state
;
279 MonoObject
*async_delegate
;
281 MonoObject
*object_data
;
282 MonoBoolean sync_completed
;
283 MonoBoolean completed
;
284 MonoBoolean endinvoke_called
;
285 MonoObject
*async_callback
;
286 MonoObject
*execution_context
;
287 MonoObject
*original_context
;
292 MonoMarshalByRefObject object
;
294 MonoBoolean disposed
;
297 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
300 CallType_BeginInvoke
= 1,
301 CallType_EndInvoke
= 2,
305 /* This corresponds to System.Type */
306 struct _MonoReflectionType
{
312 MonoReflectionType type
;
313 MonoObject
*type_info
;
314 } MonoReflectionMonoType
;
318 MonoReflectionType
*class_to_proxy
;
320 MonoObject
*unwrapped_server
;
321 gint32 target_domain_id
;
322 MonoString
*target_uri
;
323 MonoObject
*object_identity
;
325 MonoObject
*stub_data
;
329 MonoMarshalByRefObject object
;
331 GHashTable
* itf_hash
;
332 MonoObject
*synchronization_context
;
336 MonoRealProxy real_proxy
;
337 MonoComObject
*com_object
;
339 } MonoComInteropProxy
;
344 MonoRemoteClass
*remote_class
;
345 MonoBoolean custom_type_info
;
346 } MonoTransparentProxy
;
350 MonoReflectionMethod
*method
;
353 MonoArray
*arg_types
;
357 MonoAsyncResult
*async_result
;
361 /* Keep in sync with the System.MonoAsyncCall */
364 MonoMethodMessage
*msg
;
365 MonoMethod
*cb_method
;
366 MonoDelegate
*cb_target
;
375 gint32 native_offset
;
376 gint64 method_address
;
378 MonoReflectionMethod
*method
;
379 MonoString
*filename
;
382 MonoString
*internal_method_name
;
386 MONO_THREAD_FLAG_DONT_MANAGE
= 1, // Don't wait for or abort this thread
387 MONO_THREAD_FLAG_NAME_SET
= 2, // Thread name set from managed code
390 struct _MonoInternalThread
{
392 volatile int lock_thread_id
; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
394 MonoArray
*cached_culture_info
;
398 MonoException
*abort_exc
;
399 int abort_state_handle
;
400 guint64 tid
; /* This is accessed as a gsize in the code (so it can hold a 64bit pointer on systems that need it), but needs to reserve 64 bits of space on all machines as it corresponds to a field in managed code */
403 gpointer
*static_data
;
404 void *thread_info
; /*This is MonoThreadInfo*, but to simplify dependencies, let's make it a void* here. */
405 MonoAppContext
*current_appcontext
;
406 MonoException
*pending_exception
;
407 MonoThread
*root_domain_thread
;
408 MonoObject
*_serialized_principal
;
409 int _serialized_principal_version
;
410 gpointer appdomain_refs
;
411 /* This is modified using atomic ops, so keep it a gint32 */
412 gint32 interruption_requested
;
413 MonoCoopMutex
*synch_cs
;
414 MonoBoolean threadpool_thread
;
415 MonoBoolean thread_interrupt_requested
;
417 guint8 apartment_state
;
418 gint32 critical_region_level
;
421 MonoThreadManageCallback manage_callback
;
422 gpointer interrupt_on_stop
;
424 gpointer thread_pinning_ref
;
426 * These fields are used to avoid having to increment corlib versions
427 * when a new field is added to this structure.
428 * Please synchronize any changes with InternalThread in Thread.cs, i.e. add the
437 struct _MonoInternalThread
*internal_thread
;
438 MonoObject
*start_obj
;
443 MonoObject
*additional
;
444 } MonoStreamingContext
;
448 MonoBoolean readOnly
;
449 MonoString
*AMDesignator
;
450 MonoString
*PMDesignator
;
451 MonoString
*DateSeparator
;
452 MonoString
*TimeSeparator
;
453 MonoString
*ShortDatePattern
;
454 MonoString
*LongDatePattern
;
455 MonoString
*ShortTimePattern
;
456 MonoString
*LongTimePattern
;
457 MonoString
*MonthDayPattern
;
458 MonoString
*YearMonthPattern
;
459 guint32 FirstDayOfWeek
;
460 guint32 CalendarWeekRule
;
461 MonoArray
*AbbreviatedDayNames
;
463 MonoArray
*MonthNames
;
464 MonoArray
*GenitiveMonthNames
;
465 MonoArray
*AbbreviatedMonthNames
;
466 MonoArray
*GenitiveAbbreviatedMonthNames
;
467 MonoArray
*ShortDatePatterns
;
468 MonoArray
*LongDatePatterns
;
469 MonoArray
*ShortTimePatterns
;
470 MonoArray
*LongTimePatterns
;
471 MonoArray
*MonthDayPatterns
;
472 MonoArray
*YearMonthPatterns
;
473 MonoArray
*ShortestDayNames
;
474 } MonoDateTimeFormatInfo
;
479 MonoArray
*numberGroupSizes
;
480 MonoArray
*currencyGroupSizes
;
481 MonoArray
*percentGroupSizes
;
482 MonoString
*positiveSign
;
483 MonoString
*negativeSign
;
484 MonoString
*numberDecimalSeparator
;
485 MonoString
*numberGroupSeparator
;
486 MonoString
*currencyGroupSeparator
;
487 MonoString
*currencyDecimalSeparator
;
488 MonoString
*currencySymbol
;
489 MonoString
*ansiCurrencySymbol
; /* unused */
490 MonoString
*naNSymbol
;
491 MonoString
*positiveInfinitySymbol
;
492 MonoString
*negativeInfinitySymbol
;
493 MonoString
*percentDecimalSeparator
;
494 MonoString
*percentGroupSeparator
;
495 MonoString
*percentSymbol
;
496 MonoString
*perMilleSymbol
;
497 MonoString
*nativeDigits
; /* unused */
498 gint32 dataItem
; /* unused */
499 guint32 numberDecimalDigits
;
500 gint32 currencyDecimalDigits
;
501 gint32 currencyPositivePattern
;
502 gint32 currencyNegativePattern
;
503 gint32 numberNegativePattern
;
504 gint32 percentPositivePattern
;
505 gint32 percentNegativePattern
;
506 gint32 percentDecimalDigits
;
507 } MonoNumberFormatInfo
;
512 MonoString
*icu_name
;
513 gpointer ICU_collator
;
518 MonoString
*NativeName
;
519 MonoArray
*ShortDatePatterns
;
520 MonoArray
*YearMonthPatterns
;
521 MonoArray
*LongDatePatterns
;
522 MonoString
*MonthDayPattern
;
525 MonoArray
*AbbreviatedEraNames
;
526 MonoArray
*AbbreviatedEnglishEraNames
;
528 MonoArray
*AbbreviatedDayNames
;
529 MonoArray
*SuperShortDayNames
;
530 MonoArray
*MonthNames
;
531 MonoArray
*AbbreviatedMonthNames
;
532 MonoArray
*GenitiveMonthNames
;
533 MonoArray
*GenitiveAbbreviatedMonthNames
;
538 MonoString
*AMDesignator
;
539 MonoString
*PMDesignator
;
540 MonoString
*TimeSeparator
;
541 MonoArray
*LongTimePatterns
;
542 MonoArray
*ShortTimePatterns
;
543 guint32 FirstDayOfWeek
;
544 guint32 CalendarWeekRule
;
549 MonoBoolean is_read_only
;
552 gint32 datetime_index
;
554 gint32 calendar_type
;
555 MonoBoolean use_user_override
;
556 MonoNumberFormatInfo
*number_format
;
557 MonoDateTimeFormatInfo
*datetime_format
;
558 MonoObject
*textinfo
;
560 MonoString
*englishname
;
561 MonoString
*nativename
;
562 MonoString
*iso3lang
;
563 MonoString
*iso2lang
;
564 MonoString
*win3lang
;
565 MonoString
*territory
;
566 MonoArray
*native_calendar_names
;
567 MonoCompareInfo
*compareinfo
;
568 const void* text_info_data
;
574 MonoString
*iso2name
;
575 MonoString
*iso3name
;
576 MonoString
*win3name
;
577 MonoString
*english_name
;
578 MonoString
*native_name
;
579 MonoString
*currency_symbol
;
580 MonoString
*iso_currency_symbol
;
581 MonoString
*currency_english_name
;
582 MonoString
*currency_native_name
;
596 } MonoInterfaceTypeAttribute
;
599 * Callbacks supplied by the runtime and called by the modules in metadata/
600 * This interface is easier to extend than adding a new function type +
601 * a new 'install' function for every callback.
604 gpointer (*create_ftnptr
) (MonoDomain
*domain
, gpointer addr
);
605 gpointer (*get_addr_from_ftnptr
) (gpointer descr
);
606 char* (*get_runtime_build_info
) (void);
607 gpointer (*get_vtable_trampoline
) (int slot_index
);
608 gpointer (*get_imt_trampoline
) (int imt_slot_index
);
609 void (*set_cast_details
) (MonoClass
*from
, MonoClass
*to
);
610 void (*debug_log
) (int level
, MonoString
*category
, MonoString
*message
);
611 gboolean (*debug_log_is_enabled
) (void);
612 gboolean (*tls_key_supported
) (MonoTlsKey key
);
613 } MonoRuntimeCallbacks
;
615 typedef gboolean (*MonoInternalStackWalk
) (MonoStackFrameInfo
*frame
, MonoContext
*ctx
, gpointer data
);
616 typedef gboolean (*MonoInternalExceptionFrameWalk
) (MonoMethod
*method
, gpointer ip
, size_t native_offset
, gboolean managed
, gpointer user_data
);
619 void (*mono_walk_stack_with_ctx
) (MonoInternalStackWalk func
, MonoContext
*ctx
, MonoUnwindOptions options
, void *user_data
);
620 void (*mono_walk_stack_with_state
) (MonoInternalStackWalk func
, MonoThreadUnwindState
*state
, MonoUnwindOptions options
, void *user_data
);
621 void (*mono_raise_exception
) (MonoException
*ex
);
622 void (*mono_raise_exception_with_ctx
) (MonoException
*ex
, MonoContext
*ctx
);
623 gboolean (*mono_exception_walk_trace
) (MonoException
*ex
, MonoInternalExceptionFrameWalk func
, gpointer user_data
);
624 gboolean (*mono_install_handler_block_guard
) (MonoThreadUnwindState
*unwind_state
);
625 } MonoRuntimeExceptionHandlingCallbacks
;
628 /* used to free a dynamic method */
629 typedef void (*MonoFreeMethodFunc
) (MonoDomain
*domain
, MonoMethod
*method
);
631 /* Used to initialize the method pointers inside vtables */
632 typedef gboolean (*MonoInitVTableFunc
) (MonoVTable
*vtable
);
634 MONO_COLD
void mono_set_pending_exception (MonoException
*exc
);
636 /* remoting and async support */
639 mono_async_result_new (MonoDomain
*domain
, HANDLE handle
,
640 MonoObject
*state
, gpointer data
, MonoObject
*object_data
);
643 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult
*ares
);
646 mono_wait_handle_new (MonoDomain
*domain
, HANDLE handle
);
649 mono_wait_handle_get_handle (MonoWaitHandle
*handle
);
652 mono_message_init (MonoDomain
*domain
, MonoMethodMessage
*this_obj
,
653 MonoReflectionMethod
*method
, MonoArray
*out_args
);
656 mono_message_invoke (MonoObject
*target
, MonoMethodMessage
*msg
,
657 MonoObject
**exc
, MonoArray
**out_args
);
660 mono_method_call_message_new (MonoMethod
*method
, gpointer
*params
, MonoMethod
*invoke
,
661 MonoDelegate
**cb
, MonoObject
**state
);
664 mono_method_return_message_restore (MonoMethod
*method
, gpointer
*params
, MonoArray
*out_args
);
667 mono_delegate_ctor_with_method (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
, MonoMethod
*method
);
670 mono_delegate_ctor (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
);
673 mono_class_get_allocation_ftn (MonoVTable
*vtable
, gboolean for_box
, gboolean
*pass_size_in_words
);
676 mono_runtime_free_method (MonoDomain
*domain
, MonoMethod
*method
);
679 mono_install_runtime_invoke (MonoInvokeFunc func
);
682 mono_install_compile_method (MonoCompileFunc func
);
685 mono_install_free_method (MonoFreeMethodFunc func
);
688 mono_install_callbacks (MonoRuntimeCallbacks
*cbs
);
690 MonoRuntimeCallbacks
*
691 mono_get_runtime_callbacks (void);
694 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks
*cbs
);
696 MonoRuntimeExceptionHandlingCallbacks
*
697 mono_get_eh_callbacks (void);
700 mono_raise_exception_with_context (MonoException
*ex
, MonoContext
*ctx
);
703 mono_type_initialization_init (void);
706 mono_type_initialization_cleanup (void);
709 mono_thread_kill (MonoInternalThread
*thread
, int signal
);
712 mono_thread_get_tls_key (void);
715 mono_thread_get_tls_offset (void);
718 mono_domain_get_tls_key (void);
721 mono_domain_get_tls_offset (void);
723 /* Reflection and Reflection.Emit support */
726 * Handling System.Type objects:
728 * Fields defined as System.Type in managed code should be defined as MonoObject*
729 * in unmanaged structures, and the monotype_cast () function should be used for
730 * casting them to MonoReflectionType* to avoid crashes/security issues when
731 * encountering instances of user defined subclasses of System.Type.
734 #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
737 * Make sure the argument, which should be a System.Type is a System.MonoType object
738 * or equivalent, and not an instance of
739 * a user defined subclass of System.Type. This should be used in places were throwing
740 * an exception is safe.
742 #define CHECK_MONOTYPE(obj) do { \
743 if (!IS_MONOTYPE (obj)) \
744 mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
747 /* This should be used for accessing members of Type[] arrays */
748 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index)))
751 * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
754 static inline MonoReflectionType
*
755 monotype_cast (MonoObject
*obj
)
757 g_assert (IS_MONOTYPE (obj
));
759 return (MonoReflectionType
*)obj
;
763 * The following structure must match the C# implementation in our corlib.
766 struct _MonoReflectionMethod
{
770 MonoReflectionType
*reftype
;
773 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod
;
774 struct _MonoReflectionGenericMethod
{
775 MonoReflectionMethod method
;
778 struct _MonoDelegate
{
780 /* The compiled code of the target method */
782 /* The invoke code */
783 gpointer invoke_impl
;
786 gpointer delegate_trampoline
;
789 * If non-NULL, this points to a memory location which stores the address of
790 * the compiled code of the method, or NULL if it is not yet compiled.
792 guint8
**method_code
;
793 MonoReflectionMethod
*method_info
;
794 MonoReflectionMethod
*original_method_info
;
796 MonoBoolean method_is_virtual
;
799 typedef struct _MonoMulticastDelegate MonoMulticastDelegate
;
800 struct _MonoMulticastDelegate
{
801 MonoDelegate delegate
;
802 MonoArray
*delegates
;
805 struct _MonoReflectionField
{
808 MonoClassField
*field
;
810 MonoReflectionType
*type
;
814 struct _MonoReflectionProperty
{
817 MonoProperty
*property
;
820 /*This is System.EventInfo*/
821 struct _MonoReflectionEvent
{
823 MonoObject
*cached_add_event
;
827 MonoReflectionEvent object
;
830 } MonoReflectionMonoEvent
;
834 MonoReflectionType
*ClassImpl
;
835 MonoObject
*DefaultValueImpl
;
836 MonoObject
*MemberImpl
;
837 MonoString
*NameImpl
;
840 MonoObject
*MarshalAsImpl
;
841 } MonoReflectionParameter
;
843 struct _MonoReflectionMethodBody
{
848 MonoBoolean init_locals
;
849 guint32 local_var_sig_token
;
853 struct _MonoReflectionAssembly
{
855 MonoAssembly
*assembly
;
856 MonoObject
*resolve_event_holder
;
858 MonoObject
*evidence
; /* Evidence */
859 MonoObject
*minimum
; /* PermissionSet - for SecurityAction.RequestMinimum */
860 MonoObject
*optional
; /* PermissionSet - for SecurityAction.RequestOptional */
861 MonoObject
*refuse
; /* PermissionSet - for SecurityAction.RequestRefuse */
862 MonoObject
*granted
; /* PermissionSet - for the resolved assembly granted permissions */
863 MonoObject
*denied
; /* PermissionSet - for the resolved assembly denied permissions */
865 MonoBoolean from_byte_array
;
870 MonoReflectionType
*utype
;
876 MonoReflectionType
*parent
;
877 MonoReflectionType
*ret
;
884 MonoReflectionType
*parent
;
885 MonoReflectionType
*declaring_type
;
887 MonoReflectionMethod
*get
;
888 MonoReflectionMethod
*set
;
893 MonoReflectionType
*declaring_type
;
894 MonoReflectionType
*reflected_type
;
896 MonoReflectionMethod
*add_method
;
897 MonoReflectionMethod
*remove_method
;
898 MonoReflectionMethod
*raise_method
;
900 MonoArray
*other_methods
;
905 MonoString
*name_space
;
906 MonoReflectionType
*etype
;
907 MonoReflectionType
*nested_in
;
908 MonoReflectionAssembly
*assembly
;
910 MonoBoolean isprimitive
;
916 } MonoReflectionILTokenInfo
;
925 MonoArray
*ex_handlers
;
926 gint32 num_token_fixups
;
927 MonoArray
*token_fixups
;
928 } MonoReflectionILGen
;
935 } MonoILExceptionInfo
;
942 gint32 filter_offset
;
943 } MonoILExceptionBlock
;
947 MonoObject
*catch_type
;
948 gint32 filter_offset
;
952 gint32 handler_offset
;
953 gint32 handler_length
;
954 } MonoReflectionExceptionHandlingClause
;
958 MonoReflectionType
*local_type
;
959 MonoBoolean is_pinned
;
961 } MonoReflectionLocalVariableInfo
;
965 * Must have the same layout as MonoReflectionLocalVariableInfo, since
966 * LocalBuilder inherits from it under net 2.0.
970 MonoBoolean is_pinned
;
973 } MonoReflectionLocalBuilder
;
982 MonoString
*marshaltype
;
983 MonoObject
*marshaltyperef
;
985 MonoBoolean has_size
;
986 } MonoReflectionMarshal
;
993 MonoReflectionMarshal
*marshal_info
;
997 MonoObject
*def_value
;
998 } MonoReflectionParamBuilder
;
1002 MonoMethod
*mhandle
;
1003 MonoReflectionILGen
*ilgen
;
1004 MonoArray
*parameters
;
1012 MonoBoolean init_locals
;
1013 MonoArray
*param_modreq
;
1014 MonoArray
*param_modopt
;
1015 MonoArray
*permissions
;
1016 } MonoReflectionCtorBuilder
;
1020 MonoMethod
*mhandle
;
1022 MonoArray
*parameters
;
1028 MonoReflectionILGen
*ilgen
;
1032 MonoArray
*override_methods
;
1034 MonoString
*dllentry
;
1036 guint32 extra_flags
;
1039 MonoBoolean init_locals
;
1040 MonoGenericContainer
*generic_container
;
1041 MonoArray
*generic_params
;
1042 MonoArray
*return_modreq
;
1043 MonoArray
*return_modopt
;
1044 MonoArray
*param_modreq
;
1045 MonoArray
*param_modopt
;
1046 MonoArray
*permissions
;
1047 } MonoReflectionMethodBuilder
;
1051 MonoMethod
*mhandle
;
1052 MonoReflectionType
*parent
;
1053 MonoReflectionType
*ret
;
1054 MonoArray
*parameters
;
1058 } MonoReflectionArrayMethod
;
1063 MonoString
*filename
;
1067 } MonoReflectionResource
;
1073 MonoArray
*res_data
;
1074 } MonoReflectionWin32Resource
;
1079 } MonoReflectionPermissionSet
;
1082 MonoReflectionAssembly assembly
;
1083 MonoDynamicAssembly
*dynamic_assembly
;
1084 MonoReflectionMethod
*entry_point
;
1089 MonoArray
*resources
;
1090 MonoArray
*public_key
;
1091 MonoString
*version
;
1092 MonoString
*culture
;
1096 MonoBoolean delay_sign
;
1098 MonoArray
*loaded_modules
;
1099 MonoArray
*win32_resources
;
1101 MonoArray
*permissions_minimum
;
1102 MonoArray
*permissions_optional
;
1103 MonoArray
*permissions_refused
;
1106 MonoBoolean corlib_internal
;
1107 MonoArray
*type_forwarders
;
1108 MonoArray
*pktoken
; /* as hexadecimal byte[] */
1109 } MonoReflectionAssemblyBuilder
;
1116 MonoObject
*def_value
;
1119 MonoReflectionType
*typeb
;
1120 MonoArray
*rva_data
;
1122 MonoReflectionMarshal
*marshal_info
;
1123 MonoClassField
*handle
;
1126 } MonoReflectionFieldBuilder
;
1133 MonoArray
*parameters
;
1135 MonoObject
*def_value
;
1136 MonoReflectionMethodBuilder
*set_method
;
1137 MonoReflectionMethodBuilder
*get_method
;
1139 MonoObject
*type_builder
;
1140 MonoArray
*returnModReq
;
1141 MonoArray
*returnModOpt
;
1142 MonoArray
*paramModReq
;
1143 MonoArray
*paramModOpt
;
1145 } MonoReflectionPropertyBuilder
;
1147 struct _MonoReflectionModule
{
1150 MonoReflectionAssembly
*assembly
;
1153 MonoString
*scopename
;
1154 MonoBoolean is_resource
;
1159 MonoReflectionModule module
;
1160 MonoDynamicImage
*dynamic_image
;
1166 MonoReflectionAssemblyBuilder
*assemblyb
;
1167 MonoArray
*global_methods
;
1168 MonoArray
*global_fields
;
1170 MonoArray
*resources
;
1171 } MonoReflectionModuleBuilder
;
1174 MonoReflectionType type
;
1178 MonoReflectionType
*nesting_type
;
1179 MonoArray
*interfaces
;
1183 MonoArray
*properties
;
1188 MonoArray
*subtypes
;
1191 MonoReflectionModuleBuilder
*module
;
1193 gint32 packing_size
;
1194 MonoGenericContainer
*generic_container
;
1195 MonoArray
*generic_params
;
1196 MonoArray
*permissions
;
1197 MonoReflectionType
*created
;
1198 } MonoReflectionTypeBuilder
;
1201 MonoReflectionType type
;
1202 MonoReflectionType
*element_type
;
1204 } MonoReflectionArrayType
;
1207 MonoReflectionType type
;
1208 MonoReflectionType
*element_type
;
1209 } MonoReflectionDerivedType
;
1212 MonoReflectionType type
;
1213 MonoReflectionTypeBuilder
*tbuilder
;
1214 MonoReflectionMethodBuilder
*mbuilder
;
1217 MonoReflectionType
*base_type
;
1218 MonoArray
*iface_constraints
;
1221 } MonoReflectionGenericParam
;
1223 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass
;
1224 struct _MonoReflectionGenericClass
{
1225 MonoReflectionType type
;
1226 MonoReflectionType
*generic_type
; /*Can be either a MonoType or a TypeBuilder*/
1227 MonoArray
*type_arguments
;
1228 guint32 initialized
;
1234 MonoString
*codebase
;
1235 gint32 major
, minor
, build
, revision
;
1236 MonoObject
*cultureInfo
;
1239 MonoObject
*keypair
;
1240 MonoArray
*publicKey
;
1241 MonoArray
*keyToken
;
1242 guint32 versioncompat
;
1243 MonoObject
*version
;
1244 guint32 processor_architecture
;
1245 } MonoReflectionAssemblyName
;
1250 MonoReflectionType
*type
;
1251 MonoReflectionTypeBuilder
*typeb
;
1253 MonoReflectionMethodBuilder
*add_method
;
1254 MonoReflectionMethodBuilder
*remove_method
;
1255 MonoReflectionMethodBuilder
*raise_method
;
1256 MonoArray
*other_methods
;
1259 } MonoReflectionEventBuilder
;
1263 MonoReflectionMethod
*ctor
;
1265 } MonoReflectionCustomAttr
;
1269 MonoString
*marshal_cookie
;
1270 MonoString
*marshal_type
;
1271 MonoReflectionType
*marshal_type_ref
;
1272 MonoReflectionType
*marshal_safe_array_user_defined_subtype
;
1274 guint32 array_subtype
;
1275 gint32 safe_array_subtype
;
1277 gint32 IidParameterIndex
;
1278 gint16 size_param_index
;
1279 } MonoReflectionMarshalAsAttribute
;
1285 MonoBoolean best_fit_mapping
;
1286 MonoBoolean throw_on_unmappable
;
1287 MonoBoolean set_last_error
;
1288 } MonoReflectionUnmanagedFunctionPointerAttribute
;
1293 } MonoReflectionGuidAttribute
;
1297 MonoMethod
*mhandle
;
1299 MonoReflectionType
*rtype
;
1300 MonoArray
*parameters
;
1303 MonoReflectionModule
*module
;
1304 MonoBoolean skip_visibility
;
1305 MonoBoolean init_locals
;
1306 MonoReflectionILGen
*ilgen
;
1309 GSList
*referenced_by
;
1310 MonoReflectionType
*owner
;
1311 } MonoReflectionDynamicMethod
;
1315 MonoReflectionModuleBuilder
*module
;
1316 MonoArray
*arguments
;
1318 MonoReflectionType
*return_type
;
1320 guint32 unmanaged_call_conv
;
1323 } MonoReflectionSigHelper
;
1327 MonoReflectionGenericClass
*inst
;
1328 MonoObject
*fb
; /*can be either a MonoField or a FieldBuilder*/
1329 } MonoReflectionFieldOnTypeBuilderInst
;
1333 MonoReflectionGenericClass
*inst
;
1334 MonoObject
*cb
; /*can be either a MonoCMethod or ConstructorBuilder*/
1335 } MonoReflectionCtorOnTypeBuilderInst
;
1339 MonoReflectionType
*inst
;
1340 MonoObject
*mb
; /*can be either a MonoMethod or MethodBuilder*/
1341 MonoArray
*method_args
;
1342 MonoReflectionMethodBuilder
*generic_method_definition
;
1343 } MonoReflectionMethodOnTypeBuilderInst
;
1347 MonoBoolean visible
;
1348 } MonoReflectionComVisibleAttribute
;
1351 RESOURCE_LOCATION_EMBEDDED
= 1,
1352 RESOURCE_LOCATION_ANOTHER_ASSEMBLY
= 2,
1353 RESOURCE_LOCATION_IN_MANIFEST
= 4
1358 MonoReflectionAssembly
*assembly
;
1359 MonoString
*filename
;
1361 } MonoManifestResourceInfo
;
1363 /* A boxed IntPtr */
1369 /* Keep in sync with System.GenericParameterAttributes */
1371 GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT
= 0,
1372 GENERIC_PARAMETER_ATTRIBUTE_COVARIANT
= 1,
1373 GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT
= 2,
1374 GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK
= 3,
1376 GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT
= 0,
1377 GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT
= 4,
1378 GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT
= 8,
1379 GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT
= 16,
1380 GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK
= 28
1381 } GenericParameterAttributes
;
1385 MonoClassField
*field
;
1389 void mono_image_create_pefile (MonoReflectionModuleBuilder
*module
, HANDLE file
);
1390 void mono_image_basic_init (MonoReflectionAssemblyBuilder
*assembly
);
1391 MonoReflectionModule
* mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder
*assembly
, MonoString
*file_name
);
1392 guint32
mono_image_insert_string (MonoReflectionModuleBuilder
*module
, MonoString
*str
);
1393 guint32
mono_image_create_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, gboolean create_methodspec
, gboolean register_token
);
1394 guint32
mono_image_create_method_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, MonoArray
*opt_param_types
);
1395 void mono_image_module_basic_init (MonoReflectionModuleBuilder
*module
);
1396 void mono_image_register_token (MonoDynamicImage
*assembly
, guint32 token
, MonoObject
*obj
);
1397 void mono_dynamic_image_free (MonoDynamicImage
*image
);
1398 void mono_dynamic_image_free_image (MonoDynamicImage
*image
);
1399 void mono_image_set_wrappers_type (MonoReflectionModuleBuilder
*mb
, MonoReflectionType
*type
);
1400 void mono_dynamic_image_release_gc_roots (MonoDynamicImage
*image
);
1402 void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder
*tb
);
1404 void mono_reflection_create_internal_class (MonoReflectionTypeBuilder
*tb
);
1406 void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder
*tb
);
1408 void mono_reflection_create_generic_class (MonoReflectionTypeBuilder
*tb
);
1410 MonoReflectionType
* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder
*tb
);
1412 void mono_reflection_get_dynamic_overrides (MonoClass
*klass
, MonoMethod
***overrides
, int *num_overrides
);
1414 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod
*m
);
1415 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod
*mb
);
1417 void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam
*gparam
);
1418 void mono_reflection_create_unmanaged_type (MonoReflectionType
*type
);
1419 void mono_reflection_register_with_runtime (MonoReflectionType
*type
);
1421 void mono_reflection_create_custom_attr_data_args (MonoImage
*image
, MonoMethod
*method
, const guchar
*data
, guint32 len
, MonoArray
**typed_args
, MonoArray
**named_args
, CattrNamedArg
**named_arg_info
, MonoError
*error
);
1422 MonoMethodSignature
* mono_reflection_lookup_signature (MonoImage
*image
, MonoMethod
*method
, guint32 token
, MonoError
*error
);
1424 MonoArray
* mono_param_get_objects_internal (MonoDomain
*domain
, MonoMethod
*method
, MonoClass
*refclass
);
1427 mono_class_bind_generic_parameters (MonoClass
*klass
, int type_argc
, MonoType
**types
, gboolean is_dynamic
);
1429 mono_reflection_bind_generic_parameters (MonoReflectionType
*type
, int type_argc
, MonoType
**types
);
1430 MonoReflectionMethod
*
1431 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod
*method
, MonoArray
*types
);
1433 mono_reflection_generic_class_initialize (MonoReflectionGenericClass
*type
, MonoArray
*fields
);
1434 MonoReflectionEvent
*
1435 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder
*tb
, MonoReflectionEventBuilder
*eb
);
1437 MonoArray
*mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper
*sig
);
1439 MonoArray
*mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper
*sig
);
1441 MonoReflectionMarshalAsAttribute
* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain
*domain
, MonoClass
*klass
, MonoMarshalSpec
*spec
);
1444 mono_reflection_lookup_dynamic_token (MonoImage
*image
, guint32 token
, gboolean valid_token
, MonoClass
**handle_class
, MonoGenericContext
*context
);
1447 mono_reflection_call_is_assignable_to (MonoClass
*klass
, MonoClass
*oklass
);
1450 mono_reflection_is_valid_dynamic_token (MonoDynamicImage
*image
, guint32 token
);
1453 mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod
*method
, MonoReflectionAssembly
*assembly
, gpointer data
, guint32 data_length
, MonoArray
**ctor_args
, MonoArray
** named_args
);
1456 mono_reflection_type_get_handle (MonoReflectionType
*ref
);
1459 mono_reflection_free_dynamic_generic_class (MonoGenericClass
*gclass
);
1462 mono_image_build_metadata (MonoReflectionModuleBuilder
*module
);
1465 mono_get_constant_value_from_blob (MonoDomain
* domain
, MonoTypeEnum type
, const char *blob
, void *value
);
1468 mono_release_type_locks (MonoInternalThread
*thread
);
1471 mono_string_to_utf8_mp (MonoMemPool
*mp
, MonoString
*s
, MonoError
*error
);
1474 mono_string_to_utf8_image (MonoImage
*image
, MonoString
*s
, MonoError
*error
);
1478 mono_array_clone_in_domain (MonoDomain
*domain
, MonoArray
*array
);
1481 mono_array_full_copy (MonoArray
*src
, MonoArray
*dest
);
1484 mono_array_calc_byte_len (MonoClass
*klass
, uintptr_t len
, uintptr_t *res
);
1486 #ifndef DISABLE_REMOTING
1488 mono_remoting_invoke (MonoObject
*real_proxy
, MonoMethodMessage
*msg
,
1489 MonoObject
**exc
, MonoArray
**out_args
);
1492 mono_remote_class_vtable (MonoDomain
*domain
, MonoRemoteClass
*remote_class
, MonoRealProxy
*real_proxy
);
1495 mono_upgrade_remote_class (MonoDomain
*domain
, MonoObject
*tproxy
, MonoClass
*klass
);
1499 mono_create_ftnptr (MonoDomain
*domain
, gpointer addr
);
1502 mono_get_addr_from_ftnptr (gpointer descr
);
1505 mono_nullable_init (guint8
*buf
, MonoObject
*value
, MonoClass
*klass
);
1508 mono_nullable_box (guint8
*buf
, MonoClass
*klass
);
1510 #ifdef MONO_SMALL_CONFIG
1511 #define MONO_IMT_SIZE 9
1513 #define MONO_IMT_SIZE 19
1518 gpointer target_code
;
1521 typedef struct _MonoImtBuilderEntry
{
1523 struct _MonoImtBuilderEntry
*next
;
1524 MonoImtItemValue value
;
1526 guint8 has_target_code
: 1;
1527 } MonoImtBuilderEntry
;
1529 typedef struct _MonoIMTCheckItem MonoIMTCheckItem
;
1531 struct _MonoIMTCheckItem
{
1533 int check_target_idx
;
1534 MonoImtItemValue value
;
1536 guint8
*code_target
;
1538 guint8 compare_done
;
1540 guint8 short_branch
;
1541 guint8 has_target_code
;
1544 typedef gpointer (*MonoImtThunkBuilder
) (MonoVTable
*vtable
, MonoDomain
*domain
,
1545 MonoIMTCheckItem
**imt_entries
, int count
, gpointer fail_trunk
);
1548 mono_install_imt_thunk_builder (MonoImtThunkBuilder func
);
1551 mono_vtable_build_imt_slot (MonoVTable
* vtable
, int imt_slot
);
1554 mono_method_get_imt_slot (MonoMethod
*method
);
1557 mono_method_add_generic_virtual_invocation (MonoDomain
*domain
, MonoVTable
*vtable
,
1558 gpointer
*vtable_slot
,
1559 MonoMethod
*method
, gpointer code
);
1562 mono_method_alloc_generic_virtual_thunk (MonoDomain
*domain
, int size
);
1565 MONO_UNHANDLED_POLICY_LEGACY
,
1566 MONO_UNHANDLED_POLICY_CURRENT
1567 } MonoRuntimeUnhandledExceptionPolicy
;
1569 MonoRuntimeUnhandledExceptionPolicy
1570 mono_runtime_unhandled_exception_policy_get (void);
1572 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy
);
1575 mono_class_try_get_vtable (MonoDomain
*domain
, MonoClass
*klass
);
1578 mono_runtime_class_init_full (MonoVTable
*vtable
, gboolean raise_exception
);
1581 mono_method_clear_object (MonoDomain
*domain
, MonoMethod
*method
);
1584 mono_class_compute_gc_descriptor (MonoClass
*klass
);
1587 mono_class_compute_bitmap (MonoClass
*klass
, gsize
*bitmap
, int size
, int offset
, int *max_set
, gboolean static_fields
);
1590 mono_object_xdomain_representation (MonoObject
*obj
, MonoDomain
*target_domain
, MonoObject
**exc
);
1593 mono_class_is_reflection_method_or_constructor (MonoClass
*klass
);
1596 mono_get_object_from_blob (MonoDomain
*domain
, MonoType
*type
, const char *blob
);
1599 mono_class_get_ref_info (MonoClass
*klass
);
1602 mono_class_set_ref_info (MonoClass
*klass
, gpointer obj
);
1605 mono_class_free_ref_info (MonoClass
*klass
);
1608 mono_object_new_pinned (MonoDomain
*domain
, MonoClass
*klass
);
1611 mono_field_static_get_value_for_thread (MonoInternalThread
*thread
, MonoVTable
*vt
, MonoClassField
*field
, void *value
);
1613 /* exported, used by the debugger */
1615 mono_vtable_get_static_field_data (MonoVTable
*vt
);
1618 mono_string_to_utf8_ignore (MonoString
*s
);
1621 mono_string_to_utf8_image_ignore (MonoImage
*image
, MonoString
*s
);
1624 mono_string_to_utf8_mp_ignore (MonoMemPool
*mp
, MonoString
*s
);
1627 mono_monitor_is_il_fastpath_wrapper (MonoMethod
*method
);
1630 mono_exception_get_native_backtrace (MonoException
*exc
);
1633 ves_icall_Mono_Runtime_GetNativeStackTrace (MonoException
*exc
);
1636 mono_exception_get_managed_backtrace (MonoException
*exc
);
1639 mono_copy_value (MonoType
*type
, void *dest
, void *value
, int deref_pointer
);
1642 mono_error_raise_exception (MonoError
*target_error
);
1645 mono_error_set_pending_exception (MonoError
*error
);
1648 mono_glist_to_array (GList
*list
, MonoClass
*eclass
);
1650 #endif /* __MONO_OBJECT_INTERNALS_H__ */