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/utils/mono-compiler.h"
12 #include "mono/utils/mono-error.h"
13 #include "mono/utils/mono-error-internals.h"
14 #include "mono/utils/mono-stack-unwinding.h"
15 #include "mono/utils/mono-tls.h"
16 #include "mono/utils/mono-coop-mutex.h"
18 /* Use this as MONO_CHECK_ARG_NULL (arg,expr,) in functions returning void */
19 #define MONO_CHECK_ARG(arg, expr, retval) G_STMT_START{ \
20 if (G_UNLIKELY (!(expr))) \
23 char *msg = g_strdup_printf ("assertion `%s' failed", \
25 if (arg) {} /* check if the name exists */ \
26 ex = mono_get_exception_argument (#arg, msg); \
28 mono_set_pending_exception (ex); \
32 /* Use this as MONO_CHECK_ARG_NULL (arg,) in functions returning void */
33 #define MONO_CHECK_ARG_NULL(arg, retval) G_STMT_START{ \
34 if (G_UNLIKELY (arg == NULL)) \
37 if (arg) {} /* check if the name exists */ \
38 ex = mono_get_exception_argument_null (#arg); \
39 mono_set_pending_exception (ex); \
43 /* Use this as MONO_ARG_NULL (arg,) in functions returning void */
44 #define MONO_CHECK_NULL(arg, retval) G_STMT_START{ \
45 if (G_UNLIKELY (arg == NULL)) \
48 if (arg) {} /* check if the name exists */ \
49 ex = mono_get_exception_null_reference (); \
50 mono_set_pending_exception (ex); \
54 #define mono_string_builder_capacity(sb) sb->chunkOffset + sb->chunkChars->max_length
55 #define mono_string_builder_string_length(sb) sb->chunkOffset + sb->chunkLength
58 * Macros which cache the results of lookups locally.
59 * These should be used instead of the original versions, if the __GNUC__
60 * restriction is acceptable.
65 /* name should be a compile-time constant */
66 #define mono_class_get_field_from_name_cached(klass,name) ({ \
67 static MonoClassField *tmp_field; \
69 tmp_field = mono_class_get_field_from_name ((klass), (name)); \
70 g_assert (tmp_field); \
73 /* eclass should be a run-time constant */
74 #define mono_array_class_get_cached(eclass,rank) ({ \
75 static MonoClass *tmp_klass; \
77 tmp_klass = mono_array_class_get ((eclass), (rank)); \
78 g_assert (tmp_klass); \
81 /* eclass should be a run-time constant */
82 #define mono_array_new_cached(domain, eclass, size, error) ({ \
83 MonoVTable *__vtable = mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)); \
84 MonoArray *__arr = mono_array_new_specific_checked (__vtable, (size), (error)); \
89 #define mono_class_get_field_from_name_cached(klass,name) mono_class_get_field_from_name ((klass), (name))
90 #define mono_array_class_get_cached(eclass,rank) mono_array_class_get ((eclass), (rank))
91 #define mono_array_new_cached(domain, eclass, size, error) mono_array_new_specific_checked (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size), (error))
95 #ifdef MONO_BIG_ARRAYS
96 typedef uint64_t mono_array_size_t
;
97 typedef int64_t mono_array_lower_bound_t
;
98 #define MONO_ARRAY_MAX_INDEX G_MAXINT64
99 #define MONO_ARRAY_MAX_SIZE G_MAXUINT64
101 typedef uint32_t mono_array_size_t
;
102 typedef int32_t mono_array_lower_bound_t
;
103 #define MONO_ARRAY_MAX_INDEX ((int32_t) 0x7fffffff)
104 #define MONO_ARRAY_MAX_SIZE ((uint32_t) 0xffffffff)
108 mono_array_size_t length
;
109 mono_array_lower_bound_t lower_bound
;
114 /* bounds is NULL for szarrays */
115 MonoArrayBounds
*bounds
;
116 /* total number of elements of the array */
117 mono_array_size_t max_length
;
118 /* we use double to ensure proper alignment on platforms that need it */
119 double vector
[MONO_ZERO_LEN_ARRAY
];
122 #define MONO_SIZEOF_MONO_ARRAY (sizeof (MonoArray) - MONO_ZERO_LEN_ARRAY * sizeof (double))
127 mono_unichar2 chars
[MONO_ZERO_LEN_ARRAY
];
130 #define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass)
131 #define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain)
133 #define mono_string_chars_fast(s) ((mono_unichar2*)(s)->chars)
134 #define mono_string_length_fast(s) ((s)->length)
136 #define mono_array_length_fast(array) ((array)->max_length)
137 #define mono_array_addr_with_size_fast(array,size,index) ( ((char*)(array)->vector) + (size) * (index) )
139 #define mono_array_addr_fast(array,type,index) ((type*)(void*) mono_array_addr_with_size_fast (array, sizeof (type), index))
140 #define mono_array_get_fast(array,type,index) ( *(type*)mono_array_addr_fast ((array), type, (index)) )
141 #define mono_array_set_fast(array,type,index,value) \
143 type *__p = (type *) mono_array_addr_fast ((array), type, (index)); \
146 #define mono_array_setref_fast(array,index,value) \
148 void **__p = (void **) mono_array_addr_fast ((array), void*, (index)); \
149 mono_gc_wbarrier_set_arrayref ((array), __p, (MonoObject*)(value)); \
150 /* *__p = (value);*/ \
152 #define mono_array_memcpy_refs_fast(dest,destidx,src,srcidx,count) \
154 void **__p = (void **) mono_array_addr_fast ((dest), void*, (destidx)); \
155 void **__s = mono_array_addr_fast ((src), void*, (srcidx)); \
156 mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \
162 MonoObject
*identity
;
163 } MonoMarshalByRefObject
;
165 /* This is a copy of System.AppDomain */
166 struct _MonoAppDomain
{
167 MonoMarshalByRefObject mbr
;
171 /* Safely access System.AppDomain from native code */
172 TYPED_HANDLE_DECL (MonoAppDomain
);
174 typedef struct _MonoStringBuilder MonoStringBuilder
;
176 struct _MonoStringBuilder
{
178 MonoArray
*chunkChars
;
179 MonoStringBuilder
* chunkPrevious
; // Link to the block logically before this block
180 int chunkLength
; // The index in ChunkChars that represent the end of the block
181 int chunkOffset
; // The logial offset (sum of all characters in previous blocks)
193 } MonoArgumentHandle
;
196 MonoMethodSignature
*sig
;
202 struct _MonoException
{
204 MonoString
*class_name
;
207 MonoObject
*inner_ex
;
208 MonoString
*help_link
;
209 /* Stores the IPs and the generic sharing infos
210 (vtable/MRGCTX) of the frames. */
211 MonoArray
*trace_ips
;
212 MonoString
*stack_trace
;
213 MonoString
*remote_stack_trace
;
214 gint32 remote_stack_index
;
215 /* Dynamic methods referenced by the stack trace */
216 MonoObject
*dynamic_methods
;
219 MonoObject
*serialization_manager
;
220 MonoObject
*captured_traces
;
221 MonoArray
*native_trace_ips
;
226 } MonoSystemException
;
229 MonoSystemException base
;
230 MonoString
*param_name
;
231 } MonoArgumentException
;
235 MonoObject
*async_state
;
237 MonoObject
*async_delegate
;
239 MonoObject
*object_data
;
240 MonoBoolean sync_completed
;
241 MonoBoolean completed
;
242 MonoBoolean endinvoke_called
;
243 MonoObject
*async_callback
;
244 MonoObject
*execution_context
;
245 MonoObject
*original_context
;
250 MonoMarshalByRefObject object
;
254 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
257 CallType_BeginInvoke
= 1,
258 CallType_EndInvoke
= 2,
262 /* This corresponds to System.Type */
263 struct _MonoReflectionType
{
268 /* Safely access System.Type from native code */
269 TYPED_HANDLE_DECL (MonoReflectionType
);
271 /* This corresponds to System.RuntimeType */
273 MonoReflectionType type
;
274 MonoObject
*type_info
;
275 } MonoReflectionMonoType
;
279 MonoReflectionType
*class_to_proxy
;
281 MonoObject
*unwrapped_server
;
282 gint32 target_domain_id
;
283 MonoString
*target_uri
;
284 MonoObject
*object_identity
;
286 MonoObject
*stub_data
;
289 /* Safely access System.Runtime.Remoting.Proxies.RealProxy from native code */
290 TYPED_HANDLE_DECL (MonoRealProxy
);
293 MonoMarshalByRefObject object
;
295 GHashTable
* itf_hash
;
296 MonoObject
*synchronization_context
;
300 MonoRealProxy real_proxy
;
301 MonoComObject
*com_object
;
303 } MonoComInteropProxy
;
308 MonoRemoteClass
*remote_class
;
309 MonoBoolean custom_type_info
;
310 } MonoTransparentProxy
;
312 /* Safely access System.Runtime.Remoting.Proxies.TransparentProxy from native code */
313 TYPED_HANDLE_DECL (MonoTransparentProxy
);
317 MonoReflectionMethod
*method
;
320 MonoArray
*arg_types
;
324 MonoAsyncResult
*async_result
;
328 /* Keep in sync with the System.MonoAsyncCall */
331 MonoMethodMessage
*msg
;
332 MonoMethod
*cb_method
;
333 MonoDelegate
*cb_target
;
342 gint32 native_offset
;
343 gint64 method_address
;
345 MonoReflectionMethod
*method
;
346 MonoString
*filename
;
349 MonoString
*internal_method_name
;
353 MONO_THREAD_FLAG_DONT_MANAGE
= 1, // Don't wait for or abort this thread
354 MONO_THREAD_FLAG_NAME_SET
= 2, // Thread name set from managed code
357 struct _MonoInternalThread
{
359 volatile int lock_thread_id
; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
360 MonoThreadHandle
*handle
;
361 gpointer native_handle
;
362 MonoArray
*cached_culture_info
;
366 MonoException
*abort_exc
;
367 int abort_state_handle
;
368 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 */
370 gpointer
*static_data
;
371 void *thread_info
; /*This is MonoThreadInfo*, but to simplify dependencies, let's make it a void* here. */
372 MonoAppContext
*current_appcontext
;
373 MonoThread
*root_domain_thread
;
374 MonoObject
*_serialized_principal
;
375 int _serialized_principal_version
;
376 gpointer appdomain_refs
;
377 /* This is modified using atomic ops, so keep it a gint32 */
378 gint32 interruption_requested
;
379 MonoCoopMutex
*synch_cs
;
380 MonoBoolean threadpool_thread
;
381 MonoBoolean thread_interrupt_requested
;
383 guint8 apartment_state
;
384 gint32 critical_region_level
;
387 MonoThreadManageCallback manage_callback
;
388 gpointer interrupt_on_stop
;
390 gpointer thread_pinning_ref
;
391 gsize abort_protected_block_count
;
393 GPtrArray
*owned_mutexes
;
394 MonoOSEvent
*suspended
;
395 gint32 self_suspended
; // TRUE | FALSE
397 * These fields are used to avoid having to increment corlib versions
398 * when a new field is added to this structure.
399 * Please synchronize any changes with InternalThread in Thread.cs, i.e. add the
405 /* This is used only to check that we are in sync between the representation
406 * of MonoInternalThread in native and InternalThread in managed
408 * DO NOT RENAME! DO NOT ADD FIELDS AFTER! */
414 struct _MonoInternalThread
*internal_thread
;
415 MonoObject
*start_obj
;
416 MonoException
*pending_exception
;
421 MonoObject
*additional
;
422 } MonoStreamingContext
;
426 MonoBoolean readOnly
;
427 MonoString
*AMDesignator
;
428 MonoString
*PMDesignator
;
429 MonoString
*DateSeparator
;
430 MonoString
*TimeSeparator
;
431 MonoString
*ShortDatePattern
;
432 MonoString
*LongDatePattern
;
433 MonoString
*ShortTimePattern
;
434 MonoString
*LongTimePattern
;
435 MonoString
*MonthDayPattern
;
436 MonoString
*YearMonthPattern
;
437 guint32 FirstDayOfWeek
;
438 guint32 CalendarWeekRule
;
439 MonoArray
*AbbreviatedDayNames
;
441 MonoArray
*MonthNames
;
442 MonoArray
*GenitiveMonthNames
;
443 MonoArray
*AbbreviatedMonthNames
;
444 MonoArray
*GenitiveAbbreviatedMonthNames
;
445 MonoArray
*ShortDatePatterns
;
446 MonoArray
*LongDatePatterns
;
447 MonoArray
*ShortTimePatterns
;
448 MonoArray
*LongTimePatterns
;
449 MonoArray
*MonthDayPatterns
;
450 MonoArray
*YearMonthPatterns
;
451 MonoArray
*ShortestDayNames
;
452 } MonoDateTimeFormatInfo
;
457 MonoArray
*numberGroupSizes
;
458 MonoArray
*currencyGroupSizes
;
459 MonoArray
*percentGroupSizes
;
460 MonoString
*positiveSign
;
461 MonoString
*negativeSign
;
462 MonoString
*numberDecimalSeparator
;
463 MonoString
*numberGroupSeparator
;
464 MonoString
*currencyGroupSeparator
;
465 MonoString
*currencyDecimalSeparator
;
466 MonoString
*currencySymbol
;
467 MonoString
*ansiCurrencySymbol
; /* unused */
468 MonoString
*naNSymbol
;
469 MonoString
*positiveInfinitySymbol
;
470 MonoString
*negativeInfinitySymbol
;
471 MonoString
*percentDecimalSeparator
;
472 MonoString
*percentGroupSeparator
;
473 MonoString
*percentSymbol
;
474 MonoString
*perMilleSymbol
;
475 MonoString
*nativeDigits
; /* unused */
476 gint32 dataItem
; /* unused */
477 guint32 numberDecimalDigits
;
478 gint32 currencyDecimalDigits
;
479 gint32 currencyPositivePattern
;
480 gint32 currencyNegativePattern
;
481 gint32 numberNegativePattern
;
482 gint32 percentPositivePattern
;
483 gint32 percentNegativePattern
;
484 gint32 percentDecimalDigits
;
485 } MonoNumberFormatInfo
;
490 MonoString
*icu_name
;
491 gpointer ICU_collator
;
496 MonoString
*NativeName
;
497 MonoArray
*ShortDatePatterns
;
498 MonoArray
*YearMonthPatterns
;
499 MonoArray
*LongDatePatterns
;
500 MonoString
*MonthDayPattern
;
503 MonoArray
*AbbreviatedEraNames
;
504 MonoArray
*AbbreviatedEnglishEraNames
;
506 MonoArray
*AbbreviatedDayNames
;
507 MonoArray
*SuperShortDayNames
;
508 MonoArray
*MonthNames
;
509 MonoArray
*AbbreviatedMonthNames
;
510 MonoArray
*GenitiveMonthNames
;
511 MonoArray
*GenitiveAbbreviatedMonthNames
;
516 MonoString
*AMDesignator
;
517 MonoString
*PMDesignator
;
518 MonoString
*TimeSeparator
;
519 MonoArray
*LongTimePatterns
;
520 MonoArray
*ShortTimePatterns
;
521 guint32 FirstDayOfWeek
;
522 guint32 CalendarWeekRule
;
527 MonoBoolean is_read_only
;
530 gint32 datetime_index
;
532 gint32 calendar_type
;
533 MonoBoolean use_user_override
;
534 MonoNumberFormatInfo
*number_format
;
535 MonoDateTimeFormatInfo
*datetime_format
;
536 MonoObject
*textinfo
;
538 MonoString
*englishname
;
539 MonoString
*nativename
;
540 MonoString
*iso3lang
;
541 MonoString
*iso2lang
;
542 MonoString
*win3lang
;
543 MonoString
*territory
;
544 MonoArray
*native_calendar_names
;
545 MonoCompareInfo
*compareinfo
;
546 const void* text_info_data
;
552 MonoString
*iso2name
;
553 MonoString
*iso3name
;
554 MonoString
*win3name
;
555 MonoString
*english_name
;
556 MonoString
*native_name
;
557 MonoString
*currency_symbol
;
558 MonoString
*iso_currency_symbol
;
559 MonoString
*currency_english_name
;
560 MonoString
*currency_native_name
;
574 } MonoInterfaceTypeAttribute
;
577 * Callbacks supplied by the runtime and called by the modules in metadata/
578 * This interface is easier to extend than adding a new function type +
579 * a new 'install' function for every callback.
582 gpointer (*create_ftnptr
) (MonoDomain
*domain
, gpointer addr
);
583 gpointer (*get_addr_from_ftnptr
) (gpointer descr
);
584 char* (*get_runtime_build_info
) (void);
585 gpointer (*get_vtable_trampoline
) (MonoVTable
*vtable
, int slot_index
);
586 gpointer (*get_imt_trampoline
) (MonoVTable
*vtable
, int imt_slot_index
);
587 gboolean (*imt_entry_inited
) (MonoVTable
*vtable
, int imt_slot_index
);
588 void (*set_cast_details
) (MonoClass
*from
, MonoClass
*to
);
589 void (*debug_log
) (int level
, MonoString
*category
, MonoString
*message
);
590 gboolean (*debug_log_is_enabled
) (void);
591 void (*init_delegate
) (MonoDelegate
*del
);
592 MonoObject
* (*runtime_invoke
) (MonoMethod
*method
, void *obj
, void **params
, MonoObject
**exc
, MonoError
*error
);
593 void* (*compile_method
) (MonoMethod
*method
, MonoError
*error
);
594 gpointer (*create_jump_trampoline
) (MonoDomain
*domain
, MonoMethod
*method
, gboolean add_sync_wrapper
, MonoError
*error
);
595 gpointer (*create_jit_trampoline
) (MonoDomain
*domain
, MonoMethod
*method
, MonoError
*error
);
596 /* used to free a dynamic method */
597 void (*free_method
) (MonoDomain
*domain
, MonoMethod
*method
);
598 gpointer (*create_remoting_trampoline
) (MonoDomain
*domain
, MonoMethod
*method
, MonoRemotingTarget target
, MonoError
*error
);
599 gpointer (*create_delegate_trampoline
) (MonoDomain
*domain
, MonoClass
*klass
);
600 } MonoRuntimeCallbacks
;
602 typedef gboolean (*MonoInternalStackWalk
) (MonoStackFrameInfo
*frame
, MonoContext
*ctx
, gpointer data
);
603 typedef gboolean (*MonoInternalExceptionFrameWalk
) (MonoMethod
*method
, gpointer ip
, size_t native_offset
, gboolean managed
, gpointer user_data
);
606 void (*mono_walk_stack_with_ctx
) (MonoInternalStackWalk func
, MonoContext
*ctx
, MonoUnwindOptions options
, void *user_data
);
607 void (*mono_walk_stack_with_state
) (MonoInternalStackWalk func
, MonoThreadUnwindState
*state
, MonoUnwindOptions options
, void *user_data
);
608 void (*mono_raise_exception
) (MonoException
*ex
);
609 void (*mono_raise_exception_with_ctx
) (MonoException
*ex
, MonoContext
*ctx
);
610 gboolean (*mono_exception_walk_trace
) (MonoException
*ex
, MonoInternalExceptionFrameWalk func
, gpointer user_data
);
611 gboolean (*mono_install_handler_block_guard
) (MonoThreadUnwindState
*unwind_state
);
612 gboolean (*mono_current_thread_has_handle_block_guard
) (void);
613 gboolean (*mono_above_abort_threshold
) (void);
614 void (*mono_clear_abort_threshold
) (void);
615 } MonoRuntimeExceptionHandlingCallbacks
;
617 MONO_COLD
void mono_set_pending_exception (MonoException
*exc
);
619 /* remoting and async support */
622 mono_async_result_new (MonoDomain
*domain
, gpointer handle
,
623 MonoObject
*state
, gpointer data
, MonoObject
*object_data
, MonoError
*error
);
626 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult
*ares
);
629 mono_wait_handle_new (MonoDomain
*domain
, gpointer handle
, MonoError
*error
);
632 mono_wait_handle_get_handle (MonoWaitHandle
*handle
);
635 mono_message_init (MonoDomain
*domain
, MonoMethodMessage
*this_obj
,
636 MonoReflectionMethod
*method
, MonoArray
*out_args
, MonoError
*error
);
639 mono_message_invoke (MonoObject
*target
, MonoMethodMessage
*msg
,
640 MonoObject
**exc
, MonoArray
**out_args
, MonoError
*error
);
643 mono_method_call_message_new (MonoMethod
*method
, gpointer
*params
, MonoMethod
*invoke
,
644 MonoDelegate
**cb
, MonoObject
**state
, MonoError
*error
);
647 mono_method_return_message_restore (MonoMethod
*method
, gpointer
*params
, MonoArray
*out_args
, MonoError
*error
);
650 mono_delegate_ctor_with_method (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
, MonoMethod
*method
, MonoError
*error
);
653 mono_delegate_ctor (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
, MonoError
*error
);
656 mono_class_get_allocation_ftn (MonoVTable
*vtable
, gboolean for_box
, gboolean
*pass_size_in_words
);
659 mono_runtime_free_method (MonoDomain
*domain
, MonoMethod
*method
);
662 mono_install_callbacks (MonoRuntimeCallbacks
*cbs
);
664 MonoRuntimeCallbacks
*
665 mono_get_runtime_callbacks (void);
668 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks
*cbs
);
670 MonoRuntimeExceptionHandlingCallbacks
*
671 mono_get_eh_callbacks (void);
674 mono_raise_exception_with_context (MonoException
*ex
, MonoContext
*ctx
);
677 mono_type_initialization_init (void);
680 mono_type_initialization_cleanup (void);
683 mono_thread_kill (MonoInternalThread
*thread
, int signal
);
686 mono_thread_get_tls_key (void);
689 mono_thread_get_tls_offset (void);
692 mono_domain_get_tls_key (void);
695 mono_domain_get_tls_offset (void);
697 /* Reflection and Reflection.Emit support */
700 * Handling System.Type objects:
702 * Fields defined as System.Type in managed code should be defined as MonoObject*
703 * in unmanaged structures, and the monotype_cast () function should be used for
704 * casting them to MonoReflectionType* to avoid crashes/security issues when
705 * encountering instances of user defined subclasses of System.Type.
708 #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
710 /* This should be used for accessing members of Type[] arrays */
711 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index)))
714 * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
717 static inline MonoReflectionType
*
718 monotype_cast (MonoObject
*obj
)
720 g_assert (IS_MONOTYPE (obj
));
722 return (MonoReflectionType
*)obj
;
726 * The following structure must match the C# implementation in our corlib.
729 struct _MonoReflectionMethod
{
733 MonoReflectionType
*reftype
;
736 /* Safely access System.Reflection.MonoMethod from native code */
737 TYPED_HANDLE_DECL (MonoReflectionMethod
);
739 struct _MonoDelegate
{
741 /* The compiled code of the target method */
743 /* The invoke code */
744 gpointer invoke_impl
;
747 gpointer delegate_trampoline
;
748 /* Extra argument passed to the target method in llvmonly mode */
751 * If non-NULL, this points to a memory location which stores the address of
752 * the compiled code of the method, or NULL if it is not yet compiled.
754 guint8
**method_code
;
755 MonoReflectionMethod
*method_info
;
756 MonoReflectionMethod
*original_method_info
;
758 MonoBoolean method_is_virtual
;
761 typedef struct _MonoMulticastDelegate MonoMulticastDelegate
;
762 struct _MonoMulticastDelegate
{
763 MonoDelegate delegate
;
764 MonoArray
*delegates
;
767 struct _MonoReflectionField
{
770 MonoClassField
*field
;
772 MonoReflectionType
*type
;
776 /* Safely access System.Reflection.MonoField from native code */
777 TYPED_HANDLE_DECL (MonoReflectionField
);
779 struct _MonoReflectionProperty
{
782 MonoProperty
*property
;
785 /* Safely access System.Reflection.MonoProperty from native code */
786 TYPED_HANDLE_DECL (MonoReflectionProperty
);
788 /*This is System.EventInfo*/
789 struct _MonoReflectionEvent
{
791 MonoObject
*cached_add_event
;
794 /* Safely access System.Reflection.EventInfo from native code */
795 TYPED_HANDLE_DECL (MonoReflectionEvent
);
798 MonoReflectionEvent object
;
801 } MonoReflectionMonoEvent
;
803 /* Safely access Systme.Reflection.MonoEvent from native code */
804 TYPED_HANDLE_DECL (MonoReflectionMonoEvent
);
808 MonoReflectionType
*ClassImpl
;
809 MonoObject
*DefaultValueImpl
;
810 MonoObject
*MemberImpl
;
811 MonoString
*NameImpl
;
814 MonoObject
*MarshalAsImpl
;
815 } MonoReflectionParameter
;
817 /* Safely access System.Reflection.ParameterInfo from native code */
818 TYPED_HANDLE_DECL (MonoReflectionParameter
);
820 struct _MonoReflectionMethodBody
{
825 MonoBoolean init_locals
;
826 guint32 local_var_sig_token
;
830 /* Safely access System.Reflection.MethodBody from native code */
831 TYPED_HANDLE_DECL (MonoReflectionMethodBody
);
833 struct _MonoReflectionAssembly
{
835 MonoAssembly
*assembly
;
836 MonoObject
*resolve_event_holder
;
838 MonoObject
*evidence
; /* Evidence */
839 MonoObject
*minimum
; /* PermissionSet - for SecurityAction.RequestMinimum */
840 MonoObject
*optional
; /* PermissionSet - for SecurityAction.RequestOptional */
841 MonoObject
*refuse
; /* PermissionSet - for SecurityAction.RequestRefuse */
842 MonoObject
*granted
; /* PermissionSet - for the resolved assembly granted permissions */
843 MonoObject
*denied
; /* PermissionSet - for the resolved assembly denied permissions */
845 MonoBoolean from_byte_array
;
849 /* Safely access System.Reflection.Assembly from native code */
850 TYPED_HANDLE_DECL (MonoReflectionAssembly
);
853 MonoReflectionType
*utype
;
859 MonoReflectionType
*parent
;
860 MonoReflectionType
*ret
;
867 MonoReflectionType
*parent
;
868 MonoReflectionType
*declaring_type
;
870 MonoReflectionMethod
*get
;
871 MonoReflectionMethod
*set
;
876 MonoReflectionType
*declaring_type
;
877 MonoReflectionType
*reflected_type
;
879 MonoReflectionMethod
*add_method
;
880 MonoReflectionMethod
*remove_method
;
881 MonoReflectionMethod
*raise_method
;
883 MonoArray
*other_methods
;
888 MonoString
*name_space
;
889 MonoReflectionType
*etype
;
890 MonoReflectionType
*nested_in
;
891 MonoReflectionAssembly
*assembly
;
893 MonoBoolean isprimitive
;
899 } MonoReflectionILTokenInfo
;
908 MonoArray
*ex_handlers
;
909 gint32 num_token_fixups
;
910 MonoArray
*token_fixups
;
911 } MonoReflectionILGen
;
918 } MonoILExceptionInfo
;
925 gint32 filter_offset
;
926 } MonoILExceptionBlock
;
930 MonoObject
*catch_type
;
931 gint32 filter_offset
;
935 gint32 handler_offset
;
936 gint32 handler_length
;
937 } MonoReflectionExceptionHandlingClause
;
940 /* Safely access System.Reflection.ExceptionHandlingClause from native code */
941 TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause
);
945 MonoReflectionType
*local_type
;
946 MonoBoolean is_pinned
;
948 } MonoReflectionLocalVariableInfo
;
950 /* Safely access System.Reflection.LocalVariableInfo from native code */
951 TYPED_HANDLE_DECL (MonoReflectionLocalVariableInfo
);
955 * Must have the same layout as MonoReflectionLocalVariableInfo, since
956 * LocalBuilder inherits from it under net 2.0.
960 MonoBoolean is_pinned
;
963 } MonoReflectionLocalBuilder
;
972 MonoString
*marshaltype
;
973 MonoObject
*marshaltyperef
;
975 MonoBoolean has_size
;
976 } MonoReflectionMarshal
;
983 MonoReflectionMarshal
*marshal_info
;
987 MonoObject
*def_value
;
988 } MonoReflectionParamBuilder
;
993 MonoReflectionILGen
*ilgen
;
994 MonoArray
*parameters
;
1002 MonoBoolean init_locals
;
1003 MonoArray
*param_modreq
;
1004 MonoArray
*param_modopt
;
1005 MonoArray
*permissions
;
1006 } MonoReflectionCtorBuilder
;
1008 /* Safely access System.Reflection.Emit.ConstructorBuilder from native code */
1009 TYPED_HANDLE_DECL (MonoReflectionCtorBuilder
);
1013 MonoMethod
*mhandle
;
1015 MonoArray
*parameters
;
1021 MonoReflectionILGen
*ilgen
;
1025 MonoArray
*override_methods
;
1027 MonoString
*dllentry
;
1029 guint32 extra_flags
;
1032 MonoBoolean init_locals
;
1033 MonoGenericContainer
*generic_container
;
1034 MonoArray
*generic_params
;
1035 MonoArray
*return_modreq
;
1036 MonoArray
*return_modopt
;
1037 MonoArray
*param_modreq
;
1038 MonoArray
*param_modopt
;
1039 MonoArray
*permissions
;
1040 } MonoReflectionMethodBuilder
;
1042 /* Safely access System.Reflection.Emit.MethodBuilder from native code */
1043 TYPED_HANDLE_DECL (MonoReflectionMethodBuilder
);
1047 MonoMethod
*mhandle
;
1048 MonoReflectionType
*parent
;
1049 MonoReflectionType
*ret
;
1050 MonoArray
*parameters
;
1054 } MonoReflectionArrayMethod
;
1059 MonoString
*filename
;
1063 } MonoReflectionResource
;
1069 MonoArray
*res_data
;
1070 } MonoReflectionWin32Resource
;
1075 } MonoReflectionPermissionSet
;
1078 MonoReflectionAssembly assembly
;
1079 MonoDynamicAssembly
*dynamic_assembly
;
1080 MonoReflectionMethod
*entry_point
;
1085 MonoArray
*resources
;
1086 MonoArray
*public_key
;
1087 MonoString
*version
;
1088 MonoString
*culture
;
1092 MonoBoolean delay_sign
;
1094 MonoArray
*loaded_modules
;
1095 MonoArray
*win32_resources
;
1097 MonoArray
*permissions_minimum
;
1098 MonoArray
*permissions_optional
;
1099 MonoArray
*permissions_refused
;
1102 MonoBoolean corlib_internal
;
1103 MonoArray
*type_forwarders
;
1104 MonoArray
*pktoken
; /* as hexadecimal byte[] */
1105 } MonoReflectionAssemblyBuilder
;
1107 /* Safely access System.Reflection.Emit.AssemblyBuilder from native code */
1108 TYPED_HANDLE_DECL (MonoReflectionAssemblyBuilder
);
1115 MonoObject
*def_value
;
1118 MonoReflectionType
*typeb
;
1119 MonoArray
*rva_data
;
1121 MonoReflectionMarshal
*marshal_info
;
1122 MonoClassField
*handle
;
1125 } MonoReflectionFieldBuilder
;
1127 /* Safely access System.Reflection.Emit.FieldBuilder from native code */
1128 TYPED_HANDLE_DECL (MonoReflectionFieldBuilder
);
1135 MonoArray
*parameters
;
1137 MonoObject
*def_value
;
1138 MonoReflectionMethodBuilder
*set_method
;
1139 MonoReflectionMethodBuilder
*get_method
;
1141 MonoObject
*type_builder
;
1142 MonoArray
*returnModReq
;
1143 MonoArray
*returnModOpt
;
1144 MonoArray
*paramModReq
;
1145 MonoArray
*paramModOpt
;
1147 } MonoReflectionPropertyBuilder
;
1149 struct _MonoReflectionModule
{
1152 MonoReflectionAssembly
*assembly
;
1155 MonoString
*scopename
;
1156 MonoBoolean is_resource
;
1160 /* Safely access System.Reflection.Module from native code */
1161 TYPED_HANDLE_DECL (MonoReflectionModule
);
1164 MonoReflectionModule module
;
1165 MonoDynamicImage
*dynamic_image
;
1171 MonoReflectionAssemblyBuilder
*assemblyb
;
1172 MonoArray
*global_methods
;
1173 MonoArray
*global_fields
;
1175 MonoArray
*resources
;
1176 } MonoReflectionModuleBuilder
;
1178 /* Safely acess System.Reflection.Emit.ModuleBuidler from native code */
1179 TYPED_HANDLE_DECL (MonoReflectionModuleBuilder
);
1182 MonoReflectionType type
;
1186 MonoReflectionType
*nesting_type
;
1187 MonoArray
*interfaces
;
1191 MonoArray
*properties
;
1196 MonoArray
*subtypes
;
1199 MonoReflectionModuleBuilder
*module
;
1201 gint32 packing_size
;
1202 MonoGenericContainer
*generic_container
;
1203 MonoArray
*generic_params
;
1204 MonoArray
*permissions
;
1205 MonoReflectionType
*created
;
1206 } MonoReflectionTypeBuilder
;
1208 /* Safely access System.Reflection.Emit.TypeBuilder from native code */
1209 TYPED_HANDLE_DECL (MonoReflectionTypeBuilder
);
1212 MonoReflectionType type
;
1213 MonoReflectionType
*element_type
;
1215 } MonoReflectionArrayType
;
1218 MonoReflectionType type
;
1219 MonoReflectionType
*element_type
;
1220 } MonoReflectionDerivedType
;
1223 MonoReflectionType type
;
1224 MonoReflectionTypeBuilder
*tbuilder
;
1225 MonoReflectionMethodBuilder
*mbuilder
;
1228 MonoReflectionType
*base_type
;
1229 MonoArray
*iface_constraints
;
1232 } MonoReflectionGenericParam
;
1235 MonoReflectionType type
;
1236 MonoReflectionTypeBuilder
*tb
;
1237 } MonoReflectionEnumBuilder
;
1239 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass
;
1240 struct _MonoReflectionGenericClass
{
1241 MonoReflectionType type
;
1242 MonoReflectionType
*generic_type
; /*Can be either a MonoType or a TypeBuilder*/
1243 MonoArray
*type_arguments
;
1249 MonoString
*codebase
;
1250 gint32 major
, minor
, build
, revision
;
1251 MonoObject
*cultureInfo
;
1254 MonoObject
*keypair
;
1255 MonoArray
*publicKey
;
1256 MonoArray
*keyToken
;
1257 guint32 versioncompat
;
1258 MonoObject
*version
;
1259 guint32 processor_architecture
;
1260 } MonoReflectionAssemblyName
;
1262 /* Safely access System.Reflection.AssemblyName from native code */
1263 TYPED_HANDLE_DECL (MonoReflectionAssemblyName
);
1268 MonoReflectionType
*type
;
1269 MonoReflectionTypeBuilder
*typeb
;
1271 MonoReflectionMethodBuilder
*add_method
;
1272 MonoReflectionMethodBuilder
*remove_method
;
1273 MonoReflectionMethodBuilder
*raise_method
;
1274 MonoArray
*other_methods
;
1277 } MonoReflectionEventBuilder
;
1281 MonoReflectionMethod
*ctor
;
1283 } MonoReflectionCustomAttr
;
1287 MonoString
*marshal_cookie
;
1288 MonoString
*marshal_type
;
1289 MonoReflectionType
*marshal_type_ref
;
1290 MonoReflectionType
*marshal_safe_array_user_defined_subtype
;
1292 guint32 array_subtype
;
1293 gint32 safe_array_subtype
;
1295 gint32 IidParameterIndex
;
1296 gint16 size_param_index
;
1297 } MonoReflectionMarshalAsAttribute
;
1299 /* Safely access System.Runtime.InteropServices.MarshalAsAttribute */
1300 TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute
);
1306 MonoBoolean best_fit_mapping
;
1307 MonoBoolean throw_on_unmappable
;
1308 MonoBoolean set_last_error
;
1309 } MonoReflectionUnmanagedFunctionPointerAttribute
;
1314 } MonoReflectionGuidAttribute
;
1318 MonoMethod
*mhandle
;
1320 MonoReflectionType
*rtype
;
1321 MonoArray
*parameters
;
1324 MonoReflectionModule
*module
;
1325 MonoBoolean skip_visibility
;
1326 MonoBoolean init_locals
;
1327 MonoReflectionILGen
*ilgen
;
1330 GSList
*referenced_by
;
1331 MonoReflectionType
*owner
;
1332 } MonoReflectionDynamicMethod
;
1336 MonoReflectionModuleBuilder
*module
;
1337 MonoArray
*arguments
;
1339 MonoReflectionType
*return_type
;
1341 guint32 unmanaged_call_conv
;
1344 } MonoReflectionSigHelper
;
1348 MonoBoolean visible
;
1349 } MonoReflectionComVisibleAttribute
;
1352 RESOURCE_LOCATION_EMBEDDED
= 1,
1353 RESOURCE_LOCATION_ANOTHER_ASSEMBLY
= 2,
1354 RESOURCE_LOCATION_IN_MANIFEST
= 4
1359 MonoReflectionAssembly
*assembly
;
1360 MonoString
*filename
;
1362 } MonoManifestResourceInfo
;
1364 /* Safely access System.Reflection.ManifestResourceInfo from native code */
1365 TYPED_HANDLE_DECL (MonoManifestResourceInfo
);
1367 /* A boxed IntPtr */
1373 /* Keep in sync with System.GenericParameterAttributes */
1375 GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT
= 0,
1376 GENERIC_PARAMETER_ATTRIBUTE_COVARIANT
= 1,
1377 GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT
= 2,
1378 GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK
= 3,
1380 GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT
= 0,
1381 GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT
= 4,
1382 GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT
= 8,
1383 GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT
= 16,
1384 GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK
= 28
1385 } GenericParameterAttributes
;
1389 MonoClassField
*field
;
1393 gboolean
mono_image_create_pefile (MonoReflectionModuleBuilder
*module
, gpointer file
, MonoError
*error
);
1394 guint32
mono_image_insert_string (MonoReflectionModuleBuilder
*module
, MonoString
*str
);
1395 guint32
mono_image_create_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, gboolean create_methodspec
, gboolean register_token
, MonoError
*error
);
1396 guint32
mono_image_create_method_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, MonoArray
*opt_param_types
, MonoError
*error
);
1397 void mono_image_register_token (MonoDynamicImage
*assembly
, guint32 token
, MonoObject
*obj
);
1398 void mono_dynamic_image_free (MonoDynamicImage
*image
);
1399 void mono_dynamic_image_free_image (MonoDynamicImage
*image
);
1400 void mono_dynamic_image_release_gc_roots (MonoDynamicImage
*image
);
1402 void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder
*tb
);
1404 void mono_reflection_get_dynamic_overrides (MonoClass
*klass
, MonoMethod
***overrides
, int *num_overrides
, MonoError
*error
);
1406 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod
*mb
);
1409 ves_icall_SymbolType_create_unmanaged_type (MonoReflectionType
*type
);
1411 void mono_reflection_register_with_runtime (MonoReflectionType
*type
);
1413 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
);
1414 MonoMethodSignature
* mono_reflection_lookup_signature (MonoImage
*image
, MonoMethod
*method
, guint32 token
, MonoError
*error
);
1416 MonoArrayHandle
mono_param_get_objects_internal (MonoDomain
*domain
, MonoMethod
*method
, MonoClass
*refclass
, MonoError
*error
);
1419 mono_class_bind_generic_parameters (MonoClass
*klass
, int type_argc
, MonoType
**types
, gboolean is_dynamic
);
1421 mono_reflection_bind_generic_parameters (MonoReflectionType
*type
, int type_argc
, MonoType
**types
, MonoError
*error
);
1423 mono_reflection_generic_class_initialize (MonoReflectionGenericClass
*type
, MonoArray
*fields
);
1425 MonoReflectionEvent
*
1426 ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder
*tb
, MonoReflectionEventBuilder
*eb
);
1429 ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper
*sig
);
1432 ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper
*sig
);
1434 MonoReflectionMarshalAsAttributeHandle
1435 mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain
*domain
, MonoClass
*klass
, MonoMarshalSpec
*spec
, MonoError
*error
);
1438 mono_reflection_lookup_dynamic_token (MonoImage
*image
, guint32 token
, gboolean valid_token
, MonoClass
**handle_class
, MonoGenericContext
*context
, MonoError
*error
);
1441 mono_reflection_call_is_assignable_to (MonoClass
*klass
, MonoClass
*oklass
, MonoError
*error
);
1444 ves_icall_System_Reflection_CustomAttributeData_ResolveArgumentsInternal (MonoReflectionMethod
*method
, MonoReflectionAssembly
*assembly
, gpointer data
, guint32 data_length
, MonoArray
**ctor_args
, MonoArray
** named_args
);
1447 mono_reflection_type_get_handle (MonoReflectionType
*ref
, MonoError
*error
);
1450 mono_image_build_metadata (MonoReflectionModuleBuilder
*module
, MonoError
*error
);
1453 mono_get_constant_value_from_blob (MonoDomain
* domain
, MonoTypeEnum type
, const char *blob
, void *value
, MonoError
*error
);
1456 mono_release_type_locks (MonoInternalThread
*thread
);
1459 mono_string_handle_to_utf8 (MonoStringHandle s
, MonoError
*error
);
1462 mono_string_to_utf8_mp (MonoMemPool
*mp
, MonoString
*s
, MonoError
*error
);
1465 mono_string_to_utf8_image (MonoImage
*image
, MonoString
*s
, MonoError
*error
);
1469 mono_array_clone_in_domain (MonoDomain
*domain
, MonoArray
*array
, MonoError
*error
);
1472 mono_array_clone_checked (MonoArray
*array
, MonoError
*error
);
1475 mono_array_full_copy (MonoArray
*src
, MonoArray
*dest
);
1478 mono_array_calc_byte_len (MonoClass
*klass
, uintptr_t len
, uintptr_t *res
);
1481 mono_array_new_checked (MonoDomain
*domain
, MonoClass
*eclass
, uintptr_t n
, MonoError
*error
);
1484 mono_array_new_full_checked (MonoDomain
*domain
, MonoClass
*array_class
, uintptr_t *lengths
, intptr_t *lower_bounds
, MonoError
*error
);
1487 mono_array_new_specific_checked (MonoVTable
*vtable
, uintptr_t n
, MonoError
*error
);
1490 ves_icall_array_new (MonoDomain
*domain
, MonoClass
*eclass
, uintptr_t n
);
1493 ves_icall_array_new_specific (MonoVTable
*vtable
, uintptr_t n
);
1495 #ifndef DISABLE_REMOTING
1497 mono_remote_class (MonoDomain
*domain
, MonoStringHandle class_name
, MonoClass
*proxy_class
, MonoError
*error
);
1500 mono_remoting_invoke (MonoObject
*real_proxy
, MonoMethodMessage
*msg
, MonoObject
**exc
, MonoArray
**out_args
, MonoError
*error
);
1503 mono_remote_class_vtable (MonoDomain
*domain
, MonoRemoteClass
*remote_class
, MonoRealProxyHandle real_proxy
, MonoError
*error
);
1506 mono_upgrade_remote_class (MonoDomain
*domain
, MonoObjectHandle tproxy
, MonoClass
*klass
, MonoError
*error
);
1509 mono_load_remote_field_checked (MonoObject
*this_obj
, MonoClass
*klass
, MonoClassField
*field
, void **res
, MonoError
*error
);
1512 mono_load_remote_field_new_checked (MonoObject
*this_obj
, MonoClass
*klass
, MonoClassField
*field
, MonoError
*error
);
1515 mono_store_remote_field_checked (MonoObject
*this_obj
, MonoClass
*klass
, MonoClassField
*field
, void* val
, MonoError
*error
);
1518 mono_store_remote_field_new_checked (MonoObject
*this_obj
, MonoClass
*klass
, MonoClassField
*field
, MonoObject
*arg
, MonoError
*error
);
1524 mono_create_ftnptr (MonoDomain
*domain
, gpointer addr
);
1527 mono_get_addr_from_ftnptr (gpointer descr
);
1530 mono_nullable_init (guint8
*buf
, MonoObject
*value
, MonoClass
*klass
);
1533 mono_value_box_checked (MonoDomain
*domain
, MonoClass
*klass
, void* val
, MonoError
*error
);
1536 mono_nullable_box (guint8
*buf
, MonoClass
*klass
, MonoError
*error
);
1538 #ifdef MONO_SMALL_CONFIG
1539 #define MONO_IMT_SIZE 9
1541 #define MONO_IMT_SIZE 19
1546 gpointer target_code
;
1549 typedef struct _MonoImtBuilderEntry
{
1551 struct _MonoImtBuilderEntry
*next
;
1552 MonoImtItemValue value
;
1554 guint8 has_target_code
: 1;
1555 } MonoImtBuilderEntry
;
1557 typedef struct _MonoIMTCheckItem MonoIMTCheckItem
;
1559 struct _MonoIMTCheckItem
{
1561 int check_target_idx
;
1562 MonoImtItemValue value
;
1564 guint8
*code_target
;
1566 guint8 compare_done
;
1568 guint8 short_branch
;
1569 guint8 has_target_code
;
1572 typedef gpointer (*MonoImtTrampolineBuilder
) (MonoVTable
*vtable
, MonoDomain
*domain
,
1573 MonoIMTCheckItem
**imt_entries
, int count
, gpointer fail_trunk
);
1576 mono_install_imt_trampoline_builder (MonoImtTrampolineBuilder func
);
1579 mono_set_always_build_imt_trampolines (gboolean value
);
1582 mono_vtable_build_imt_slot (MonoVTable
* vtable
, int imt_slot
);
1585 mono_method_get_imt_slot (MonoMethod
*method
);
1588 mono_method_add_generic_virtual_invocation (MonoDomain
*domain
, MonoVTable
*vtable
,
1589 gpointer
*vtable_slot
,
1590 MonoMethod
*method
, gpointer code
);
1593 mono_method_alloc_generic_virtual_trampoline (MonoDomain
*domain
, int size
);
1596 MONO_UNHANDLED_POLICY_LEGACY
,
1597 MONO_UNHANDLED_POLICY_CURRENT
1598 } MonoRuntimeUnhandledExceptionPolicy
;
1600 MonoRuntimeUnhandledExceptionPolicy
1601 mono_runtime_unhandled_exception_policy_get (void);
1603 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy
);
1606 mono_class_try_get_vtable (MonoDomain
*domain
, MonoClass
*klass
);
1609 mono_runtime_class_init_full (MonoVTable
*vtable
, MonoError
*error
);
1612 mono_method_clear_object (MonoDomain
*domain
, MonoMethod
*method
);
1615 mono_class_compute_gc_descriptor (MonoClass
*klass
);
1618 mono_class_compute_bitmap (MonoClass
*klass
, gsize
*bitmap
, int size
, int offset
, int *max_set
, gboolean static_fields
);
1621 mono_object_xdomain_representation (MonoObject
*obj
, MonoDomain
*target_domain
, MonoError
*error
);
1624 mono_class_is_reflection_method_or_constructor (MonoClass
*klass
);
1627 mono_get_object_from_blob (MonoDomain
*domain
, MonoType
*type
, const char *blob
, MonoError
*error
);
1630 mono_class_get_ref_info (MonoClass
*klass
);
1633 mono_class_set_ref_info (MonoClass
*klass
, gpointer obj
);
1636 mono_class_free_ref_info (MonoClass
*klass
);
1639 mono_object_new_pinned (MonoDomain
*domain
, MonoClass
*klass
, MonoError
*error
);
1642 mono_object_new_specific_checked (MonoVTable
*vtable
, MonoError
*error
);
1645 ves_icall_object_new (MonoDomain
*domain
, MonoClass
*klass
);
1648 ves_icall_object_new_specific (MonoVTable
*vtable
);
1651 mono_object_new_alloc_specific_checked (MonoVTable
*vtable
, MonoError
*error
);
1654 mono_field_static_get_value_checked (MonoVTable
*vt
, MonoClassField
*field
, void *value
, MonoError
*error
);
1657 mono_field_static_get_value_for_thread (MonoInternalThread
*thread
, MonoVTable
*vt
, MonoClassField
*field
, void *value
, MonoError
*error
);
1660 mono_object_handle_get_virtual_method (MonoObjectHandle obj
, MonoMethod
*method
, MonoError
*error
);
1662 /* exported, used by the debugger */
1664 mono_vtable_get_static_field_data (MonoVTable
*vt
);
1667 mono_field_get_value_object_checked (MonoDomain
*domain
, MonoClassField
*field
, MonoObject
*obj
, MonoError
*error
);
1670 mono_property_set_value_checked (MonoProperty
*prop
, void *obj
, void **params
, MonoError
*error
);
1673 mono_property_get_value_checked (MonoProperty
*prop
, void *obj
, void **params
, MonoError
*error
);
1676 mono_object_to_string_checked (MonoObject
*obj
, MonoError
*error
);
1679 mono_object_try_to_string (MonoObject
*obj
, MonoObject
**exc
, MonoError
*error
);
1682 mono_string_to_utf8_ignore (MonoString
*s
);
1685 mono_string_to_utf8_image_ignore (MonoImage
*image
, MonoString
*s
);
1688 mono_string_to_utf8_mp_ignore (MonoMemPool
*mp
, MonoString
*s
);
1691 mono_monitor_is_il_fastpath_wrapper (MonoMethod
*method
);
1694 mono_string_intern_checked (MonoString
*str
, MonoError
*error
);
1697 mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc
);
1700 ves_icall_Mono_Runtime_GetNativeStackTrace (MonoExceptionHandle exc
, MonoError
*erro
);
1703 mono_exception_get_managed_backtrace (MonoException
*exc
);
1706 mono_copy_value (MonoType
*type
, void *dest
, void *value
, int deref_pointer
);
1709 mono_error_raise_exception (MonoError
*target_error
);
1712 mono_error_set_pending_exception (MonoError
*error
);
1715 mono_glist_to_array (GList
*list
, MonoClass
*eclass
, MonoError
*error
);
1718 mono_object_new_checked (MonoDomain
*domain
, MonoClass
*klass
, MonoError
*error
);
1721 mono_object_new_mature (MonoVTable
*vtable
, MonoError
*error
);
1724 mono_object_new_fast_checked (MonoVTable
*vtable
, MonoError
*error
);
1727 ves_icall_object_new_fast (MonoVTable
*vtable
);
1730 mono_object_clone_checked (MonoObject
*obj
, MonoError
*error
);
1733 mono_object_isinst_checked (MonoObject
*obj
, MonoClass
*klass
, MonoError
*error
);
1736 mono_object_handle_isinst (MonoObjectHandle obj
, MonoClass
*klass
, MonoError
*error
);
1739 mono_object_handle_isinst_mbyref (MonoObjectHandle obj
, MonoClass
*klass
, MonoError
*error
);
1742 mono_string_new_size_checked (MonoDomain
*domain
, gint32 len
, MonoError
*error
);
1745 mono_ldstr_checked (MonoDomain
*domain
, MonoImage
*image
, uint32_t str_index
, MonoError
*error
);
1748 mono_string_new_len_checked (MonoDomain
*domain
, const char *text
, guint length
, MonoError
*error
);
1751 mono_string_new_checked (MonoDomain
*domain
, const char *text
, MonoError
*merror
);
1754 mono_string_new_utf16_checked (MonoDomain
*domain
, const guint16
*text
, gint32 len
, MonoError
*error
);
1757 mono_string_from_utf16_checked (mono_unichar2
*data
, MonoError
*error
);
1760 mono_string_from_utf32_checked (mono_unichar4
*data
, MonoError
*error
);
1763 mono_ldstr_utf8 (MonoImage
*image
, guint32 idx
, MonoError
*error
);
1766 mono_runtime_object_init_checked (MonoObject
*this_obj
, MonoError
*error
);
1769 mono_runtime_try_invoke (MonoMethod
*method
, void *obj
, void **params
, MonoObject
**exc
, MonoError
*error
);
1772 mono_runtime_invoke_checked (MonoMethod
*method
, void *obj
, void **params
, MonoError
*error
);
1775 mono_runtime_try_invoke_array (MonoMethod
*method
, void *obj
, MonoArray
*params
,
1776 MonoObject
**exc
, MonoError
*error
);
1779 mono_runtime_invoke_array_checked (MonoMethod
*method
, void *obj
, MonoArray
*params
,
1783 mono_compile_method_checked (MonoMethod
*method
, MonoError
*error
);
1786 mono_runtime_delegate_try_invoke (MonoObject
*delegate
, void **params
,
1787 MonoObject
**exc
, MonoError
*error
);
1790 mono_runtime_delegate_invoke_checked (MonoObject
*delegate
, void **params
,
1794 mono_runtime_get_main_args_checked (MonoError
*error
);
1797 mono_runtime_run_main_checked (MonoMethod
*method
, int argc
, char* argv
[],
1801 mono_runtime_try_run_main (MonoMethod
*method
, int argc
, char* argv
[],
1805 mono_runtime_exec_main_checked (MonoMethod
*method
, MonoArray
*args
, MonoError
*error
);
1808 mono_runtime_try_exec_main (MonoMethod
*method
, MonoArray
*args
, MonoObject
**exc
);
1810 MonoReflectionMethod
*
1811 ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethod
*rmethod
, MonoArray
*types
);
1814 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder
*mb
, MonoObject
*obj
, gboolean create_open_instance
);
1817 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder
*mb
,
1818 MonoReflectionMethod
*method
,
1819 MonoArray
*opt_param_types
);
1822 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder
*mb
, gpointer file
);
1825 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder
*mb
);
1828 ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder
*mb
, MonoObject
*obj
, guint32 token
);
1831 ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder
*mb
, guint32 token
);
1834 ves_icall_AssemblyBuilder_basic_init (MonoReflectionAssemblyBuilder
*assemblyb
);
1836 MonoReflectionModule
*
1837 ves_icall_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder
*ab
, MonoString
*fileName
);
1840 ves_icall_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly
*assembly
, MonoObject
*ctor
, MonoArray
*ctorArgs
, MonoArray
*properties
, MonoArray
*propValues
, MonoArray
*fields
, MonoArray
* fieldValues
);
1843 ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethod
*mb
);
1846 ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilder
*tb
);
1849 ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType
*enumtype
,
1850 MonoReflectionType
*t
);
1853 ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilder
*moduleb
);
1856 ves_icall_ModuleBuilder_getUSIndex (MonoReflectionModuleBuilder
*module
, MonoString
*str
);
1859 ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilder
*moduleb
, MonoReflectionType
*type
);
1862 mono_try_assembly_resolve_handle (MonoDomain
*domain
, MonoStringHandle fname
, MonoAssembly
*requesting
, gboolean refonly
, MonoError
*error
);
1864 #endif /* __MONO_OBJECT_INTERNALS_H__ */