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/io-layer/io-layer.h>
11 #include "mono/utils/mono-compiler.h"
12 #include "mono/utils/mono-error.h"
15 * We should find a better place for this stuff. We can't put it in mono-compiler.h,
16 * since that is included by libgc.
19 #define G_LIKELY(a) (a)
20 #define G_UNLIKELY(a) (a)
24 * glib defines this macro and uses it in the definition of G_LIKELY, and thus,
25 * g_assert (). The macro expands to a complex piece of code, preventing some
26 * gcc versions like 4.3.0 from handling the __builtin_expect construct properly,
27 * causing the generation of the unlikely branch into the middle of the code.
29 #ifdef _G_BOOLEAN_EXPR
30 #undef _G_BOOLEAN_EXPR
31 #define _G_BOOLEAN_EXPR(expr) ((gsize)(expr) != 0)
36 #define mono_assert(expr) G_STMT_START{ \
40 char *msg = g_strdup_printf ("file %s: line %d (%s): " \
41 "assertion failed: (%s)", __FILE__, __LINE__, \
42 __PRETTY_FUNCTION__, #expr); \
43 ex = mono_get_exception_execution_engine (msg); \
45 mono_raise_exception (ex); \
48 #define mono_assert_not_reached() G_STMT_START{ \
50 char *msg = g_strdup_printf ("file %s: line %d (%s): " \
51 "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__); \
52 ex = mono_get_exception_execution_engine (msg); \
54 mono_raise_exception (ex); \
57 #define mono_assert(expr) G_STMT_START{ \
61 char *msg = g_strdup_printf ("file %s: line %d: " \
62 "assertion failed: (%s)", __FILE__, __LINE__, \
64 ex = mono_get_exception_execution_engine (msg); \
66 mono_raise_exception (ex); \
69 #define mono_assert_not_reached() G_STMT_START{ \
71 char *msg = g_strdup_printf ("file %s: line %d): " \
72 "should not be reached", __FILE__, __LINE__); \
73 ex = mono_get_exception_execution_engine (msg); \
75 mono_raise_exception (ex); \
79 #define mono_assert(expr) g_assert(expr)
80 #define mono_assert_not_reached() g_assert_not_reached()
83 #define MONO_CHECK_ARG(arg, expr) G_STMT_START{ \
87 char *msg = g_strdup_printf ("assertion `%s' failed", \
89 if (arg) {} /* check if the name exists */ \
90 ex = mono_get_exception_argument (#arg, msg); \
92 mono_raise_exception (ex); \
95 #define MONO_CHECK_ARG_NULL(arg) G_STMT_START{ \
99 if (arg) {} /* check if the name exists */ \
100 ex = mono_get_exception_argument_null (#arg); \
101 mono_raise_exception (ex); \
104 /* 16 == default capacity */
105 #define mono_stringbuilder_capacity(sb) ((sb)->str ? ((sb)->str->length) : 16)
108 * Macros which cache the results of lookups locally.
109 * These should be used instead of the original versions, if the __GNUC__
110 * restriction is acceptable.
115 /* namespace and name should be a constant */
116 #define mono_class_from_name_cached(image,namespace,name) ({ \
117 static MonoClass *tmp_klass; \
119 tmp_klass = mono_class_from_name ((image), (namespace), (name)); \
120 g_assert (tmp_klass); \
123 /* name should be a compile-time constant */
124 #define mono_class_get_field_from_name_cached(klass,name) ({ \
125 static MonoClassField *tmp_field; \
127 tmp_field = mono_class_get_field_from_name ((klass), (name)); \
128 g_assert (tmp_field); \
131 /* eclass should be a run-time constant */
132 #define mono_array_class_get_cached(eclass,rank) ({ \
133 static MonoClass *tmp_klass; \
135 tmp_klass = mono_array_class_get ((eclass), (rank)); \
136 g_assert (tmp_klass); \
139 /* eclass should be a run-time constant */
140 #define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size))
144 #define mono_class_from_name_cached(image,namespace,name) mono_class_from_name ((image), (namespace), (name))
145 #define mono_class_get_field_from_name_cached(klass,name) mono_class_get_field_from_name ((klass), (name))
146 #define mono_array_class_get_cached(eclass,rank) mono_array_class_get ((eclass), (rank))
147 #define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size))
151 #ifdef MONO_BIG_ARRAYS
152 typedef uint64_t mono_array_size_t
;
153 typedef int64_t mono_array_lower_bound_t
;
154 #define MONO_ARRAY_MAX_INDEX G_MAXINT64
155 #define MONO_ARRAY_MAX_SIZE G_MAXUINT64
157 typedef uint32_t mono_array_size_t
;
158 typedef int32_t mono_array_lower_bound_t
;
159 #define MONO_ARRAY_MAX_INDEX ((int32_t) 0x7fffffff)
160 #define MONO_ARRAY_MAX_SIZE ((uint32_t) 0xffffffff)
164 mono_array_size_t length
;
165 mono_array_lower_bound_t lower_bound
;
170 /* bounds is NULL for szarrays */
171 MonoArrayBounds
*bounds
;
172 /* total number of elements of the array */
173 mono_array_size_t max_length
;
174 /* we use double to ensure proper alignment on platforms that need it */
175 double vector
[MONO_ZERO_LEN_ARRAY
];
181 mono_unichar2 chars
[MONO_ZERO_LEN_ARRAY
];
184 #define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass)
185 #define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain)
187 #define mono_string_chars_fast(s) ((mono_unichar2*)(s)->chars)
188 #define mono_string_length_fast(s) ((s)->length)
190 #define mono_array_length_fast(array) ((array)->max_length)
191 #define mono_array_addr_with_size_fast(array,size,index) ( ((char*)(array)->vector) + (size) * (index) )
195 MonoObject
*identity
;
196 } MonoMarshalByRefObject
;
198 /* This is a copy of System.AppDomain */
199 struct _MonoAppDomain
{
200 MonoMarshalByRefObject mbr
;
208 MonoString
*cached_str
;
220 } MonoArgumentHandle
;
223 MonoMethodSignature
*sig
;
229 struct _MonoException
{
231 /* Stores the IPs and the generic sharing infos
232 (vtable/MRGCTX) of the frames. */
233 MonoArray
*trace_ips
;
234 MonoObject
*inner_ex
;
236 MonoString
*help_link
;
237 MonoString
*class_name
;
238 MonoString
*stack_trace
;
239 MonoString
*remote_stack_trace
;
240 gint32 remote_stack_index
;
248 } MonoSystemException
;
251 MonoSystemException base
;
252 MonoString
*param_name
;
253 } MonoArgumentException
;
256 MonoSystemException base
;
258 MonoString
*type_name
;
259 } MonoTypeLoadException
;
263 MonoObject
*async_state
;
265 MonoObject
*async_delegate
;
267 MonoObject
*object_data
;
268 MonoBoolean sync_completed
;
269 MonoBoolean completed
;
270 MonoBoolean endinvoke_called
;
271 MonoObject
*async_callback
;
272 MonoObject
*execution_context
;
273 MonoObject
*original_context
;
278 MonoMarshalByRefObject object
;
280 MonoBoolean disposed
;
283 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
286 CallType_BeginInvoke
= 1,
287 CallType_EndInvoke
= 2,
291 /* This corresponds to System.Type */
292 struct _MonoReflectionType
{
298 MonoReflectionType type
;
299 MonoObject
*type_info
;
300 } MonoReflectionMonoType
;
304 MonoReflectionType
*class_to_proxy
;
306 MonoObject
*unwrapped_server
;
307 gint32 target_domain_id
;
308 MonoString
*target_uri
;
309 MonoObject
*object_identity
;
311 MonoObject
*stub_data
;
315 MonoMarshalByRefObject object
;
317 GHashTable
* itf_hash
;
321 MonoRealProxy real_proxy
;
322 MonoComObject
*com_object
;
324 } MonoComInteropProxy
;
329 MonoRemoteClass
*remote_class
;
330 MonoBoolean custom_type_info
;
331 } MonoTransparentProxy
;
335 MonoReflectionMethod
*method
;
338 MonoArray
*arg_types
;
342 MonoAsyncResult
*async_result
;
349 gint32 native_offset
;
350 MonoReflectionMethod
*method
;
351 MonoString
*filename
;
354 MonoString
*internal_method_name
;
358 MONO_THREAD_FLAG_DONT_MANAGE
= 1, // Don't wait for or abort this thread
361 struct _MonoInternalThread
{
363 volatile int lock_thread_id
; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
365 MonoArray
*cached_culture_info
;
367 MonoBoolean threadpool_thread
;
371 MonoException
*abort_exc
;
372 int abort_state_handle
;
373 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 */
376 gpointer
*static_data
;
379 MonoAppContext
*current_appcontext
;
381 GSList
*appdomain_refs
;
382 /* This is modified using atomic ops, so keep it a gint32 */
383 gint32 interruption_requested
;
384 gpointer suspend_event
;
385 gpointer suspended_event
;
386 gpointer resume_event
;
387 CRITICAL_SECTION
*synch_cs
;
388 MonoBoolean thread_dump_requested
;
389 gpointer end_stack
; /* This is only used when running in the debugger. */
390 MonoBoolean thread_interrupt_requested
;
391 guint8 apartment_state
;
392 gint32 critical_region_level
;
393 guint32 small_id
; /* A small, unique id, used for the hazard pointer table. */
394 MonoThreadManageCallback manage_callback
;
395 MonoException
*pending_exception
;
396 MonoThread
*root_domain_thread
;
397 gpointer interrupt_on_stop
;
400 * These fields are used to avoid having to increment corlib versions
401 * when a new field is added to the unmanaged MonoThread structure.
410 struct _MonoInternalThread
*internal_thread
;
411 MonoObject
*start_obj
;
412 MonoObject
*ec_to_set
;
417 MonoReflectionType
*type
;
419 } MonoSerializationEntry
;
423 MonoObject
*additional
;
424 } MonoStreamingContext
;
428 MonoBoolean readOnly
;
429 MonoString
*AMDesignator
;
430 MonoString
*PMDesignator
;
431 MonoString
*DateSeparator
;
432 MonoString
*TimeSeparator
;
433 MonoString
*ShortDatePattern
;
434 MonoString
*LongDatePattern
;
435 MonoString
*ShortTimePattern
;
436 MonoString
*LongTimePattern
;
437 MonoString
*MonthDayPattern
;
438 MonoString
*YearMonthPattern
;
439 MonoString
*FullDateTimePattern
;
440 MonoString
*RFC1123Pattern
;
441 MonoString
*SortableDateTimePattern
;
442 MonoString
*UniversalSortableDateTimePattern
;
443 guint32 FirstDayOfWeek
;
444 MonoObject
*Calendar
;
445 guint32 CalendarWeekRule
;
446 MonoArray
*AbbreviatedDayNames
;
448 MonoArray
*MonthNames
;
449 MonoArray
*AbbreviatedMonthNames
;
450 MonoArray
*ShortDatePatterns
;
451 MonoArray
*LongDatePatterns
;
452 MonoArray
*ShortTimePatterns
;
453 MonoArray
*LongTimePatterns
;
454 MonoArray
*MonthDayPatterns
;
455 MonoArray
*YearMonthPatterns
;
456 MonoArray
*shortDayNames
;
457 } MonoDateTimeFormatInfo
;
462 MonoBoolean readOnly
;
463 MonoString
*decimalFormats
;
464 MonoString
*currencyFormats
;
465 MonoString
*percentFormats
;
466 MonoString
*digitPattern
;
467 MonoString
*zeroPattern
;
468 gint32 currencyDecimalDigits
;
469 MonoString
*currencyDecimalSeparator
;
470 MonoString
*currencyGroupSeparator
;
471 MonoArray
*currencyGroupSizes
;
472 gint32 currencyNegativePattern
;
473 gint32 currencyPositivePattern
;
474 MonoString
*currencySymbol
;
475 MonoString
*naNSymbol
;
476 MonoString
*negativeInfinitySymbol
;
477 MonoString
*negativeSign
;
478 guint32 numberDecimalDigits
;
479 MonoString
*numberDecimalSeparator
;
480 MonoString
*numberGroupSeparator
;
481 MonoArray
*numberGroupSizes
;
482 gint32 numberNegativePattern
;
483 gint32 percentDecimalDigits
;
484 MonoString
*percentDecimalSeparator
;
485 MonoString
*percentGroupSeparator
;
486 MonoArray
*percentGroupSizes
;
487 gint32 percentNegativePattern
;
488 gint32 percentPositivePattern
;
489 MonoString
*percentSymbol
;
490 MonoString
*perMilleSymbol
;
491 MonoString
*positiveInfinitySymbol
;
492 MonoString
*positiveSign
;
493 } MonoNumberFormatInfo
;
498 MonoString
*icu_name
;
499 gpointer ICU_collator
;
504 MonoBoolean is_read_only
;
507 gint32 specific_lcid
;
508 gint32 datetime_index
;
510 MonoBoolean use_user_override
;
511 MonoNumberFormatInfo
*number_format
;
512 MonoDateTimeFormatInfo
*datetime_format
;
513 MonoObject
*textinfo
;
515 MonoString
*displayname
;
516 MonoString
*englishname
;
517 MonoString
*nativename
;
518 MonoString
*iso3lang
;
519 MonoString
*iso2lang
;
520 MonoString
*icu_name
;
521 MonoString
*win3lang
;
522 MonoString
*territory
;
523 MonoCompareInfo
*compareinfo
;
524 const gint32
*calendar_data
;
525 const void* text_info_data
;
531 MonoString
*iso2name
;
532 MonoString
*iso3name
;
533 MonoString
*win3name
;
534 MonoString
*english_name
;
535 MonoString
*currency_symbol
;
536 MonoString
*iso_currency_symbol
;
537 MonoString
*currency_english_name
;
551 } MonoInterfaceTypeAttribute
;
554 * Callbacks supplied by the runtime and called by the modules in metadata/
555 * This interface is easier to extend than adding a new function type +
556 * a new 'install' function for every callback.
559 gpointer (*create_ftnptr
) (MonoDomain
*domain
, gpointer addr
);
560 gpointer (*get_addr_from_ftnptr
) (gpointer descr
);
561 char* (*get_runtime_build_info
) (void);
562 gpointer (*get_vtable_trampoline
) (int slot_index
);
563 gpointer (*get_imt_trampoline
) (int imt_slot_index
);
564 } MonoRuntimeCallbacks
;
566 /* used to free a dynamic method */
567 typedef void (*MonoFreeMethodFunc
) (MonoDomain
*domain
, MonoMethod
*method
);
569 /* Used to initialize the method pointers inside vtables */
570 typedef gboolean (*MonoInitVTableFunc
) (MonoVTable
*vtable
);
572 void mono_set_pending_exception (MonoException
*exc
) MONO_INTERNAL
;
574 /* remoting and async support */
577 mono_async_result_new (MonoDomain
*domain
, HANDLE handle
,
578 MonoObject
*state
, gpointer data
, MonoObject
*object_data
) MONO_INTERNAL
;
581 mono_wait_handle_new (MonoDomain
*domain
, HANDLE handle
) MONO_INTERNAL
;
584 mono_wait_handle_get_handle (MonoWaitHandle
*handle
) MONO_INTERNAL
;
587 mono_message_init (MonoDomain
*domain
, MonoMethodMessage
*this_obj
,
588 MonoReflectionMethod
*method
, MonoArray
*out_args
) MONO_INTERNAL
;
591 mono_remoting_invoke (MonoObject
*real_proxy
, MonoMethodMessage
*msg
,
592 MonoObject
**exc
, MonoArray
**out_args
) MONO_INTERNAL
;
595 mono_message_invoke (MonoObject
*target
, MonoMethodMessage
*msg
,
596 MonoObject
**exc
, MonoArray
**out_args
) MONO_INTERNAL
;
599 mono_method_call_message_new (MonoMethod
*method
, gpointer
*params
, MonoMethod
*invoke
,
600 MonoDelegate
**cb
, MonoObject
**state
) MONO_INTERNAL
;
603 mono_method_return_message_restore (MonoMethod
*method
, gpointer
*params
, MonoArray
*out_args
) MONO_INTERNAL
;
606 mono_delegate_ctor_with_method (MonoObject
*this, MonoObject
*target
, gpointer addr
, MonoMethod
*method
) MONO_INTERNAL
;
609 mono_delegate_ctor (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
) MONO_INTERNAL
;
612 mono_class_get_allocation_ftn (MonoVTable
*vtable
, gboolean for_box
, gboolean
*pass_size_in_words
) MONO_INTERNAL
;
615 mono_runtime_free_method (MonoDomain
*domain
, MonoMethod
*method
) MONO_INTERNAL
;
617 /* runtime initialization functions */
618 typedef void (*MonoExceptionFunc
) (MonoException
*ex
);
621 mono_install_handler (MonoExceptionFunc func
) MONO_INTERNAL
;
624 mono_install_runtime_invoke (MonoInvokeFunc func
) MONO_INTERNAL
;
627 mono_install_compile_method (MonoCompileFunc func
) MONO_INTERNAL
;
630 mono_install_free_method (MonoFreeMethodFunc func
) MONO_INTERNAL
;
633 mono_install_callbacks (MonoRuntimeCallbacks
*cbs
) MONO_INTERNAL
;
635 MonoRuntimeCallbacks
*
636 mono_get_runtime_callbacks (void) MONO_INTERNAL
;
639 mono_type_initialization_init (void) MONO_INTERNAL
;
642 mono_type_initialization_cleanup (void) MONO_INTERNAL
;
645 mono_thread_get_tls_key (void) MONO_INTERNAL
;
648 mono_thread_get_tls_offset (void) MONO_INTERNAL
;
651 mono_domain_get_tls_key (void) MONO_INTERNAL
;
654 mono_domain_get_tls_offset (void) MONO_INTERNAL
;
656 /* Reflection and Reflection.Emit support */
659 * Handling System.Type objects:
661 * Fields defined as System.Type in managed code should be defined as MonoObject*
662 * in unmanaged structures, and the monotype_cast () function should be used for
663 * casting them to MonoReflectionType* to avoid crashes/security issues when
664 * encountering instances of user defined subclasses of System.Type.
667 #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
670 * Make sure the argument, which should be a System.Type is a System.MonoType object
671 * or equivalent, and not an instance of
672 * a user defined subclass of System.Type. This should be used in places were throwing
673 * an exception is safe.
675 #define CHECK_MONOTYPE(obj) do { \
676 if (!IS_MONOTYPE (obj)) \
677 mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
680 /* This should be used for accessing members of Type[] arrays */
681 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index)))
684 * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
687 static inline MonoReflectionType
*
688 monotype_cast (MonoObject
*obj
)
690 g_assert (IS_MONOTYPE (obj
));
692 return (MonoReflectionType
*)obj
;
696 * The following structure must match the C# implementation in our corlib.
699 struct _MonoReflectionMethod
{
703 MonoReflectionType
*reftype
;
706 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod
;
707 struct _MonoReflectionGenericMethod
{
708 MonoReflectionMethod method
;
711 struct _MonoDelegate
{
713 /* The compiled code of the target method */
715 /* The invoke code */
716 gpointer invoke_impl
;
719 gpointer delegate_trampoline
;
721 * If non-NULL, this points to a memory location which stores the address of
722 * the compiled code of the method, or NULL if it is not yet compiled.
724 guint8
**method_code
;
725 MonoReflectionMethod
*method_info
;
726 MonoReflectionMethod
*original_method_info
;
730 typedef struct _MonoMulticastDelegate MonoMulticastDelegate
;
731 struct _MonoMulticastDelegate
{
732 MonoDelegate delegate
;
733 MonoMulticastDelegate
*prev
;
736 struct _MonoReflectionField
{
739 MonoClassField
*field
;
741 MonoReflectionType
*type
;
745 struct _MonoReflectionProperty
{
748 MonoProperty
*property
;
751 /*This is System.EventInfo*/
752 struct _MonoReflectionEvent
{
754 MonoObject
*cached_add_event
;
758 MonoReflectionEvent object
;
761 } MonoReflectionMonoEvent
;
765 MonoReflectionType
*ClassImpl
;
766 MonoObject
*DefaultValueImpl
;
767 MonoObject
*MemberImpl
;
768 MonoString
*NameImpl
;
771 MonoObject
*MarshalAsImpl
;
772 } MonoReflectionParameter
;
774 struct _MonoReflectionMethodBody
{
779 MonoBoolean init_locals
;
780 guint32 local_var_sig_token
;
784 struct _MonoReflectionAssembly
{
786 MonoAssembly
*assembly
;
787 MonoObject
*resolve_event_holder
;
789 MonoObject
*evidence
; /* Evidence */
790 MonoObject
*minimum
; /* PermissionSet - for SecurityAction.RequestMinimum */
791 MonoObject
*optional
; /* PermissionSet - for SecurityAction.RequestOptional */
792 MonoObject
*refuse
; /* PermissionSet - for SecurityAction.RequestRefuse */
793 MonoObject
*granted
; /* PermissionSet - for the resolved assembly granted permissions */
794 MonoObject
*denied
; /* PermissionSet - for the resolved assembly denied permissions */
796 MonoBoolean from_byte_array
;
801 MonoReflectionType
*utype
;
807 MonoReflectionType
*parent
;
808 MonoReflectionType
*ret
;
815 MonoReflectionType
*parent
;
817 MonoReflectionMethod
*get
;
818 MonoReflectionMethod
*set
;
823 MonoReflectionType
*declaring_type
;
824 MonoReflectionType
*reflected_type
;
826 MonoReflectionMethod
*add_method
;
827 MonoReflectionMethod
*remove_method
;
828 MonoReflectionMethod
*raise_method
;
830 MonoArray
*other_methods
;
835 MonoString
*name_space
;
836 MonoReflectionType
*etype
;
837 MonoReflectionType
*nested_in
;
838 MonoReflectionAssembly
*assembly
;
840 MonoBoolean isprimitive
;
846 } MonoReflectionILTokenInfo
;
855 MonoArray
*ex_handlers
;
856 gint32 num_token_fixups
;
857 MonoArray
*token_fixups
;
858 } MonoReflectionILGen
;
865 } MonoILExceptionInfo
;
872 gint32 filter_offset
;
873 } MonoILExceptionBlock
;
877 MonoObject
*catch_type
;
878 gint32 filter_offset
;
882 gint32 handler_offset
;
883 gint32 handler_length
;
884 } MonoReflectionExceptionHandlingClause
;
888 MonoReflectionType
*local_type
;
889 MonoBoolean is_pinned
;
891 } MonoReflectionLocalVariableInfo
;
895 * Must have the same layout as MonoReflectionLocalVariableInfo, since
896 * LocalBuilder inherits from it under net 2.0.
900 MonoBoolean is_pinned
;
903 } MonoReflectionLocalBuilder
;
912 MonoString
*marshaltype
;
913 MonoObject
*marshaltyperef
;
915 MonoBoolean has_size
;
916 } MonoReflectionMarshal
;
923 MonoReflectionMarshal
*marshal_info
;
927 MonoObject
*def_value
;
928 } MonoReflectionParamBuilder
;
933 MonoReflectionILGen
*ilgen
;
934 MonoArray
*parameters
;
942 MonoBoolean init_locals
;
943 MonoArray
*param_modreq
;
944 MonoArray
*param_modopt
;
945 MonoArray
*permissions
;
946 } MonoReflectionCtorBuilder
;
952 MonoArray
*parameters
;
958 MonoReflectionILGen
*ilgen
;
962 MonoReflectionMethod
*override_method
;
964 MonoString
*dllentry
;
969 MonoBoolean init_locals
;
970 MonoGenericContainer
*generic_container
;
971 MonoArray
*generic_params
;
972 MonoArray
*return_modreq
;
973 MonoArray
*return_modopt
;
974 MonoArray
*param_modreq
;
975 MonoArray
*param_modopt
;
976 MonoArray
*permissions
;
977 } MonoReflectionMethodBuilder
;
982 MonoReflectionType
*parent
;
983 MonoReflectionType
*ret
;
984 MonoArray
*parameters
;
988 } MonoReflectionArrayMethod
;
993 MonoString
*filename
;
997 } MonoReflectionResource
;
1003 MonoArray
*res_data
;
1004 } MonoReflectionWin32Resource
;
1009 } MonoReflectionPermissionSet
;
1012 MonoReflectionAssembly assembly
;
1013 MonoDynamicAssembly
*dynamic_assembly
;
1014 MonoReflectionMethod
*entry_point
;
1019 MonoArray
*resources
;
1020 MonoArray
*public_key
;
1021 MonoString
*version
;
1022 MonoString
*culture
;
1026 MonoBoolean delay_sign
;
1028 MonoArray
*loaded_modules
;
1029 MonoArray
*win32_resources
;
1031 MonoArray
*permissions_minimum
;
1032 MonoArray
*permissions_optional
;
1033 MonoArray
*permissions_refused
;
1036 MonoBoolean corlib_internal
;
1037 MonoArray
*type_forwarders
;
1038 MonoArray
*pktoken
; /* as hexadecimal byte[] */
1039 } MonoReflectionAssemblyBuilder
;
1046 MonoObject
*def_value
;
1049 MonoReflectionType
*typeb
;
1050 MonoArray
*rva_data
;
1052 MonoReflectionMarshal
*marshal_info
;
1053 MonoClassField
*handle
;
1056 } MonoReflectionFieldBuilder
;
1063 MonoArray
*parameters
;
1065 MonoObject
*def_value
;
1066 MonoReflectionMethodBuilder
*set_method
;
1067 MonoReflectionMethodBuilder
*get_method
;
1069 MonoObject
*type_builder
;
1070 MonoArray
*returnModReq
;
1071 MonoArray
*returnModOpt
;
1072 MonoArray
*paramModReq
;
1073 MonoArray
*paramModOpt
;
1075 } MonoReflectionPropertyBuilder
;
1077 struct _MonoReflectionModule
{
1080 MonoReflectionAssembly
*assembly
;
1083 MonoString
*scopename
;
1084 MonoBoolean is_resource
;
1089 MonoReflectionModule module
;
1090 MonoDynamicImage
*dynamic_image
;
1096 MonoReflectionAssemblyBuilder
*assemblyb
;
1097 MonoArray
*global_methods
;
1098 MonoArray
*global_fields
;
1100 MonoArray
*resources
;
1101 } MonoReflectionModuleBuilder
;
1104 MonoReflectionType type
;
1108 MonoReflectionType
*nesting_type
;
1109 MonoArray
*interfaces
;
1113 MonoArray
*properties
;
1118 MonoArray
*subtypes
;
1121 MonoReflectionModuleBuilder
*module
;
1123 gint32 packing_size
;
1124 MonoGenericContainer
*generic_container
;
1125 MonoArray
*generic_params
;
1126 MonoArray
*permissions
;
1127 MonoReflectionType
*created
;
1128 } MonoReflectionTypeBuilder
;
1131 MonoReflectionType type
;
1132 MonoReflectionType
*element_type
;
1134 } MonoReflectionArrayType
;
1137 MonoReflectionType type
;
1138 MonoReflectionType
*element_type
;
1139 } MonoReflectionDerivedType
;
1142 MonoReflectionType type
;
1143 MonoReflectionTypeBuilder
*tbuilder
;
1144 MonoReflectionMethodBuilder
*mbuilder
;
1147 MonoReflectionType
*base_type
;
1148 MonoArray
*iface_constraints
;
1151 } MonoReflectionGenericParam
;
1153 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass
;
1154 struct _MonoReflectionGenericClass
{
1155 MonoReflectionType type
;
1156 MonoReflectionType
*generic_type
; /*Can be either a MonoType or a TypeBuilder*/
1157 MonoArray
*type_arguments
;
1158 guint32 initialized
;
1164 MonoString
*codebase
;
1165 gint32 major
, minor
, build
, revision
;
1166 MonoObject
*cultureInfo
;
1169 MonoObject
*keypair
;
1170 MonoArray
*publicKey
;
1171 MonoArray
*keyToken
;
1172 guint32 versioncompat
;
1173 MonoObject
*version
;
1174 guint32 processor_architecture
;
1175 } MonoReflectionAssemblyName
;
1180 MonoReflectionType
*type
;
1181 MonoReflectionTypeBuilder
*typeb
;
1183 MonoReflectionMethodBuilder
*add_method
;
1184 MonoReflectionMethodBuilder
*remove_method
;
1185 MonoReflectionMethodBuilder
*raise_method
;
1186 MonoArray
*other_methods
;
1189 } MonoReflectionEventBuilder
;
1193 MonoReflectionMethod
*ctor
;
1195 } MonoReflectionCustomAttr
;
1202 MonoString
*entry_point
;
1203 MonoBoolean exact_spelling
;
1204 MonoBoolean preserve_sig
;
1205 MonoBoolean set_last_error
;
1206 MonoBoolean best_fit_mapping
;
1207 MonoBoolean throw_on_unmappable
;
1208 } MonoReflectionDllImportAttribute
;
1214 MonoBoolean set_last_error
;
1215 MonoBoolean best_fit_mapping
;
1216 MonoBoolean throw_on_unmappable
;
1217 } MonoReflectionUnmanagedFunctionPointerAttribute
;
1222 } MonoReflectionGuidAttribute
;
1226 MonoMethod
*mhandle
;
1228 MonoReflectionType
*rtype
;
1229 MonoArray
*parameters
;
1232 MonoReflectionModule
*module
;
1233 MonoBoolean skip_visibility
;
1234 MonoBoolean init_locals
;
1235 MonoReflectionILGen
*ilgen
;
1238 GSList
*referenced_by
;
1239 MonoReflectionType
*owner
;
1240 } MonoReflectionDynamicMethod
;
1244 MonoReflectionModuleBuilder
*module
;
1245 MonoArray
*arguments
;
1247 MonoReflectionType
*return_type
;
1249 guint32 unmanaged_call_conv
;
1252 } MonoReflectionSigHelper
;
1256 MonoReflectionGenericClass
*inst
;
1257 MonoObject
*fb
; /*can be either a MonoField or a FieldBuilder*/
1258 } MonoReflectionFieldOnTypeBuilderInst
;
1262 MonoReflectionGenericClass
*inst
;
1263 MonoObject
*cb
; /*can be either a MonoCMethod or ConstructorBuilder*/
1264 } MonoReflectionCtorOnTypeBuilderInst
;
1268 MonoReflectionType
*inst
;
1269 MonoObject
*mb
; /*can be either a MonoMethod or MethodBuilder*/
1270 MonoArray
*method_args
;
1271 MonoReflectionMethodBuilder
*generic_method_definition
;
1272 } MonoReflectionMethodOnTypeBuilderInst
;
1276 MonoBoolean visible
;
1277 } MonoReflectionComVisibleAttribute
;
1280 RESOURCE_LOCATION_EMBEDDED
= 1,
1281 RESOURCE_LOCATION_ANOTHER_ASSEMBLY
= 2,
1282 RESOURCE_LOCATION_IN_MANIFEST
= 4
1287 MonoReflectionAssembly
*assembly
;
1288 MonoString
*filename
;
1290 } MonoManifestResourceInfo
;
1292 /* A boxed IntPtr */
1298 /* Keep in sync with System.GenericParameterAttributes */
1300 GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT
= 0,
1301 GENERIC_PARAMETER_ATTRIBUTE_COVARIANT
= 1,
1302 GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT
= 2,
1303 GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK
= 3,
1305 GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT
= 0,
1306 GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT
= 4,
1307 GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT
= 8,
1308 GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT
= 16,
1309 GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK
= 28
1310 } GenericParameterAttributes
;
1314 MonoClassField
*field
;
1318 void mono_image_create_pefile (MonoReflectionModuleBuilder
*module
, HANDLE file
) MONO_INTERNAL
;
1319 void mono_image_basic_init (MonoReflectionAssemblyBuilder
*assembly
) MONO_INTERNAL
;
1320 MonoReflectionModule
* mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder
*assembly
, MonoString
*file_name
) MONO_INTERNAL
;
1321 guint32
mono_image_insert_string (MonoReflectionModuleBuilder
*module
, MonoString
*str
) MONO_INTERNAL
;
1322 guint32
mono_image_create_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, gboolean create_methodspec
, gboolean register_token
) MONO_INTERNAL
;
1323 guint32
mono_image_create_method_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, MonoArray
*opt_param_types
) MONO_INTERNAL
;
1324 void mono_image_module_basic_init (MonoReflectionModuleBuilder
*module
) MONO_INTERNAL
;
1325 void mono_image_register_token (MonoDynamicImage
*assembly
, guint32 token
, MonoObject
*obj
) MONO_INTERNAL
;
1326 void mono_dynamic_image_free (MonoDynamicImage
*image
) MONO_INTERNAL
;
1327 void mono_image_set_wrappers_type (MonoReflectionModuleBuilder
*mb
, MonoReflectionType
*type
) MONO_INTERNAL
;
1329 void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder
*tb
) MONO_INTERNAL
;
1331 void mono_reflection_create_internal_class (MonoReflectionTypeBuilder
*tb
) MONO_INTERNAL
;
1333 void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder
*tb
) MONO_INTERNAL
;
1335 void mono_reflection_create_generic_class (MonoReflectionTypeBuilder
*tb
) MONO_INTERNAL
;
1337 MonoReflectionType
* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder
*tb
) MONO_INTERNAL
;
1339 void mono_reflection_get_dynamic_overrides (MonoClass
*klass
, MonoMethod
***overrides
, int *num_overrides
) MONO_INTERNAL
;
1341 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod
*m
) MONO_INTERNAL
;
1342 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod
*mb
) MONO_INTERNAL
;
1344 void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam
*gparam
) MONO_INTERNAL
;
1345 void mono_reflection_create_unmanaged_type (MonoReflectionType
*type
) MONO_INTERNAL
;
1346 void mono_reflection_register_with_runtime (MonoReflectionType
*type
) MONO_INTERNAL
;
1348 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
) MONO_INTERNAL
;
1350 MonoArray
* mono_param_get_objects_internal (MonoDomain
*domain
, MonoMethod
*method
, MonoClass
*refclass
) MONO_INTERNAL
;
1353 mono_class_bind_generic_parameters (MonoClass
*klass
, int type_argc
, MonoType
**types
, gboolean is_dynamic
) MONO_INTERNAL
;
1355 mono_reflection_bind_generic_parameters (MonoReflectionType
*type
, int type_argc
, MonoType
**types
) MONO_INTERNAL
;
1356 MonoReflectionMethod
*
1357 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod
*method
, MonoArray
*types
) MONO_INTERNAL
;
1359 mono_reflection_generic_class_initialize (MonoReflectionGenericClass
*type
, MonoArray
*methods
, MonoArray
*ctors
, MonoArray
*fields
, MonoArray
*properties
, MonoArray
*events
) MONO_INTERNAL
;
1360 MonoReflectionEvent
*
1361 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder
*tb
, MonoReflectionEventBuilder
*eb
) MONO_INTERNAL
;
1363 MonoArray
*mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper
*sig
) MONO_INTERNAL
;
1365 MonoArray
*mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper
*sig
) MONO_INTERNAL
;
1367 MonoReflectionMarshal
* mono_reflection_marshal_from_marshal_spec (MonoDomain
*domain
, MonoClass
*klass
, MonoMarshalSpec
*spec
) MONO_INTERNAL
;
1370 mono_reflection_lookup_dynamic_token (MonoImage
*image
, guint32 token
, gboolean valid_token
, MonoClass
**handle_class
, MonoGenericContext
*context
) MONO_INTERNAL
;
1373 mono_reflection_call_is_assignable_to (MonoClass
*klass
, MonoClass
*oklass
) MONO_INTERNAL
;
1376 mono_reflection_is_valid_dynamic_token (MonoDynamicImage
*image
, guint32 token
) MONO_INTERNAL
;
1379 mono_reflection_type_get_handle (MonoReflectionType
*ref
) MONO_INTERNAL
;
1382 mono_image_build_metadata (MonoReflectionModuleBuilder
*module
) MONO_INTERNAL
;
1385 mono_get_constant_value_from_blob (MonoDomain
* domain
, MonoTypeEnum type
, const char *blob
, void *value
) MONO_INTERNAL
;
1388 mono_release_type_locks (MonoInternalThread
*thread
) MONO_INTERNAL
;
1391 mono_string_to_utf8_mp (MonoMemPool
*mp
, MonoString
*s
, MonoError
*error
) MONO_INTERNAL
;
1394 mono_string_to_utf8_image (MonoImage
*image
, MonoString
*s
, MonoError
*error
) MONO_INTERNAL
;
1398 mono_array_clone_in_domain (MonoDomain
*domain
, MonoArray
*array
) MONO_INTERNAL
;
1401 mono_array_full_copy (MonoArray
*src
, MonoArray
*dest
) MONO_INTERNAL
;
1404 mono_array_calc_byte_len (MonoClass
*class, uintptr_t len
, uintptr_t *res
) MONO_INTERNAL
;
1407 mono_remote_class_vtable (MonoDomain
*domain
, MonoRemoteClass
*remote_class
, MonoRealProxy
*real_proxy
) MONO_INTERNAL
;
1410 mono_upgrade_remote_class (MonoDomain
*domain
, MonoObject
*tproxy
, MonoClass
*klass
) MONO_INTERNAL
;
1413 mono_create_ftnptr (MonoDomain
*domain
, gpointer addr
) MONO_INTERNAL
;
1416 mono_get_addr_from_ftnptr (gpointer descr
) MONO_INTERNAL
;
1419 mono_nullable_init (guint8
*buf
, MonoObject
*value
, MonoClass
*klass
) MONO_INTERNAL
;
1422 mono_nullable_box (guint8
*buf
, MonoClass
*klass
) MONO_INTERNAL
;
1424 #ifdef MONO_SMALL_CONFIG
1425 #define MONO_IMT_SIZE 9
1427 #define MONO_IMT_SIZE 19
1432 gpointer target_code
;
1435 typedef struct _MonoImtBuilderEntry
{
1437 struct _MonoImtBuilderEntry
*next
;
1438 MonoImtItemValue value
;
1440 guint8 has_target_code
: 1;
1441 } MonoImtBuilderEntry
;
1443 typedef struct _MonoIMTCheckItem MonoIMTCheckItem
;
1445 struct _MonoIMTCheckItem
{
1447 int check_target_idx
;
1448 MonoImtItemValue value
;
1450 guint8
*code_target
;
1452 guint8 compare_done
;
1454 guint8 short_branch
;
1455 guint8 has_target_code
;
1458 typedef gpointer (*MonoImtThunkBuilder
) (MonoVTable
*vtable
, MonoDomain
*domain
,
1459 MonoIMTCheckItem
**imt_entries
, int count
, gpointer fail_trunk
);
1462 mono_install_imt_thunk_builder (MonoImtThunkBuilder func
) MONO_INTERNAL
;
1465 mono_vtable_build_imt_slot (MonoVTable
* vtable
, int imt_slot
) MONO_INTERNAL
;
1468 mono_method_get_imt_slot (MonoMethod
*method
) MONO_INTERNAL
;
1471 mono_method_add_generic_virtual_invocation (MonoDomain
*domain
, MonoVTable
*vtable
,
1472 gpointer
*vtable_slot
,
1473 MonoMethod
*method
, gpointer code
) MONO_INTERNAL
;
1476 mono_method_alloc_generic_virtual_thunk (MonoDomain
*domain
, int size
) MONO_INTERNAL
;
1479 MONO_UNHANDLED_POLICY_LEGACY
,
1480 MONO_UNHANDLED_POLICY_CURRENT
1481 } MonoRuntimeUnhandledExceptionPolicy
;
1483 MonoRuntimeUnhandledExceptionPolicy
1484 mono_runtime_unhandled_exception_policy_get (void) MONO_INTERNAL
;
1486 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy
) MONO_INTERNAL
;
1489 mono_class_try_get_vtable (MonoDomain
*domain
, MonoClass
*class) MONO_INTERNAL
;
1492 mono_runtime_class_init_full (MonoVTable
*vtable
, gboolean raise_exception
) MONO_INTERNAL
;
1495 mono_method_clear_object (MonoDomain
*domain
, MonoMethod
*method
) MONO_INTERNAL
;
1498 mono_class_compute_gc_descriptor (MonoClass
*class) MONO_INTERNAL
;
1501 mono_object_xdomain_representation (MonoObject
*obj
, MonoDomain
*target_domain
, MonoObject
**exc
) MONO_INTERNAL
;
1504 mono_string_to_utf8_checked (MonoString
*s
, MonoError
*error
) MONO_INTERNAL
;
1507 mono_class_is_reflection_method_or_constructor (MonoClass
*class) MONO_INTERNAL
;
1510 mono_get_object_from_blob (MonoDomain
*domain
, MonoType
*type
, const char *blob
) MONO_INTERNAL
;
1513 mono_class_get_ref_info (MonoClass
*klass
) MONO_INTERNAL
;
1516 mono_class_set_ref_info (MonoClass
*klass
, gpointer obj
) MONO_INTERNAL
;
1519 mono_class_free_ref_info (MonoClass
*klass
) MONO_INTERNAL
;
1521 #endif /* __MONO_OBJECT_INTERNALS_H__ */