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
) (MonoVTable
*vtable
, int slot_index
);
608 gpointer (*get_imt_trampoline
) (MonoVTable
*vtable
, int imt_slot_index
);
609 gboolean (*imt_entry_inited
) (MonoVTable
*vtable
, int imt_slot_index
);
610 void (*set_cast_details
) (MonoClass
*from
, MonoClass
*to
);
611 void (*debug_log
) (int level
, MonoString
*category
, MonoString
*message
);
612 gboolean (*debug_log_is_enabled
) (void);
613 gboolean (*tls_key_supported
) (MonoTlsKey key
);
614 void (*init_delegate
) (MonoDelegate
*del
);
615 } MonoRuntimeCallbacks
;
617 typedef gboolean (*MonoInternalStackWalk
) (MonoStackFrameInfo
*frame
, MonoContext
*ctx
, gpointer data
);
618 typedef gboolean (*MonoInternalExceptionFrameWalk
) (MonoMethod
*method
, gpointer ip
, size_t native_offset
, gboolean managed
, gpointer user_data
);
621 void (*mono_walk_stack_with_ctx
) (MonoInternalStackWalk func
, MonoContext
*ctx
, MonoUnwindOptions options
, void *user_data
);
622 void (*mono_walk_stack_with_state
) (MonoInternalStackWalk func
, MonoThreadUnwindState
*state
, MonoUnwindOptions options
, void *user_data
);
623 void (*mono_raise_exception
) (MonoException
*ex
);
624 void (*mono_raise_exception_with_ctx
) (MonoException
*ex
, MonoContext
*ctx
);
625 gboolean (*mono_exception_walk_trace
) (MonoException
*ex
, MonoInternalExceptionFrameWalk func
, gpointer user_data
);
626 gboolean (*mono_install_handler_block_guard
) (MonoThreadUnwindState
*unwind_state
);
627 } MonoRuntimeExceptionHandlingCallbacks
;
630 /* used to free a dynamic method */
631 typedef void (*MonoFreeMethodFunc
) (MonoDomain
*domain
, MonoMethod
*method
);
633 /* Used to initialize the method pointers inside vtables */
634 typedef gboolean (*MonoInitVTableFunc
) (MonoVTable
*vtable
);
636 MONO_COLD
void mono_set_pending_exception (MonoException
*exc
);
638 /* remoting and async support */
641 mono_async_result_new (MonoDomain
*domain
, HANDLE handle
,
642 MonoObject
*state
, gpointer data
, MonoObject
*object_data
);
645 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult
*ares
);
648 mono_wait_handle_new (MonoDomain
*domain
, HANDLE handle
);
651 mono_wait_handle_get_handle (MonoWaitHandle
*handle
);
654 mono_message_init (MonoDomain
*domain
, MonoMethodMessage
*this_obj
,
655 MonoReflectionMethod
*method
, MonoArray
*out_args
);
658 mono_message_invoke (MonoObject
*target
, MonoMethodMessage
*msg
,
659 MonoObject
**exc
, MonoArray
**out_args
);
662 mono_method_call_message_new (MonoMethod
*method
, gpointer
*params
, MonoMethod
*invoke
,
663 MonoDelegate
**cb
, MonoObject
**state
);
666 mono_method_return_message_restore (MonoMethod
*method
, gpointer
*params
, MonoArray
*out_args
);
669 mono_delegate_ctor_with_method (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
, MonoMethod
*method
);
672 mono_delegate_ctor (MonoObject
*this_obj
, MonoObject
*target
, gpointer addr
);
675 mono_class_get_allocation_ftn (MonoVTable
*vtable
, gboolean for_box
, gboolean
*pass_size_in_words
);
678 mono_runtime_free_method (MonoDomain
*domain
, MonoMethod
*method
);
681 mono_install_runtime_invoke (MonoInvokeFunc func
);
684 mono_install_compile_method (MonoCompileFunc func
);
687 mono_install_free_method (MonoFreeMethodFunc func
);
690 mono_install_callbacks (MonoRuntimeCallbacks
*cbs
);
692 MonoRuntimeCallbacks
*
693 mono_get_runtime_callbacks (void);
696 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks
*cbs
);
698 MonoRuntimeExceptionHandlingCallbacks
*
699 mono_get_eh_callbacks (void);
702 mono_raise_exception_with_context (MonoException
*ex
, MonoContext
*ctx
);
705 mono_type_initialization_init (void);
708 mono_type_initialization_cleanup (void);
711 mono_thread_kill (MonoInternalThread
*thread
, int signal
);
714 mono_thread_get_tls_key (void);
717 mono_thread_get_tls_offset (void);
720 mono_domain_get_tls_key (void);
723 mono_domain_get_tls_offset (void);
725 /* Reflection and Reflection.Emit support */
728 * Handling System.Type objects:
730 * Fields defined as System.Type in managed code should be defined as MonoObject*
731 * in unmanaged structures, and the monotype_cast () function should be used for
732 * casting them to MonoReflectionType* to avoid crashes/security issues when
733 * encountering instances of user defined subclasses of System.Type.
736 #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
739 * Make sure the argument, which should be a System.Type is a System.MonoType object
740 * or equivalent, and not an instance of
741 * a user defined subclass of System.Type. This should be used in places were throwing
742 * an exception is safe.
744 #define CHECK_MONOTYPE(obj) do { \
745 if (!IS_MONOTYPE (obj)) \
746 mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
749 /* This should be used for accessing members of Type[] arrays */
750 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index)))
753 * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
756 static inline MonoReflectionType
*
757 monotype_cast (MonoObject
*obj
)
759 g_assert (IS_MONOTYPE (obj
));
761 return (MonoReflectionType
*)obj
;
765 * The following structure must match the C# implementation in our corlib.
768 struct _MonoReflectionMethod
{
772 MonoReflectionType
*reftype
;
775 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod
;
776 struct _MonoReflectionGenericMethod
{
777 MonoReflectionMethod method
;
780 struct _MonoDelegate
{
782 /* The compiled code of the target method */
784 /* The invoke code */
785 gpointer invoke_impl
;
788 gpointer delegate_trampoline
;
791 * If non-NULL, this points to a memory location which stores the address of
792 * the compiled code of the method, or NULL if it is not yet compiled.
794 guint8
**method_code
;
795 MonoReflectionMethod
*method_info
;
796 MonoReflectionMethod
*original_method_info
;
798 MonoBoolean method_is_virtual
;
801 typedef struct _MonoMulticastDelegate MonoMulticastDelegate
;
802 struct _MonoMulticastDelegate
{
803 MonoDelegate delegate
;
804 MonoArray
*delegates
;
807 struct _MonoReflectionField
{
810 MonoClassField
*field
;
812 MonoReflectionType
*type
;
816 struct _MonoReflectionProperty
{
819 MonoProperty
*property
;
822 /*This is System.EventInfo*/
823 struct _MonoReflectionEvent
{
825 MonoObject
*cached_add_event
;
829 MonoReflectionEvent object
;
832 } MonoReflectionMonoEvent
;
836 MonoReflectionType
*ClassImpl
;
837 MonoObject
*DefaultValueImpl
;
838 MonoObject
*MemberImpl
;
839 MonoString
*NameImpl
;
842 MonoObject
*MarshalAsImpl
;
843 } MonoReflectionParameter
;
845 struct _MonoReflectionMethodBody
{
850 MonoBoolean init_locals
;
851 guint32 local_var_sig_token
;
855 struct _MonoReflectionAssembly
{
857 MonoAssembly
*assembly
;
858 MonoObject
*resolve_event_holder
;
860 MonoObject
*evidence
; /* Evidence */
861 MonoObject
*minimum
; /* PermissionSet - for SecurityAction.RequestMinimum */
862 MonoObject
*optional
; /* PermissionSet - for SecurityAction.RequestOptional */
863 MonoObject
*refuse
; /* PermissionSet - for SecurityAction.RequestRefuse */
864 MonoObject
*granted
; /* PermissionSet - for the resolved assembly granted permissions */
865 MonoObject
*denied
; /* PermissionSet - for the resolved assembly denied permissions */
867 MonoBoolean from_byte_array
;
872 MonoReflectionType
*utype
;
878 MonoReflectionType
*parent
;
879 MonoReflectionType
*ret
;
886 MonoReflectionType
*parent
;
887 MonoReflectionType
*declaring_type
;
889 MonoReflectionMethod
*get
;
890 MonoReflectionMethod
*set
;
895 MonoReflectionType
*declaring_type
;
896 MonoReflectionType
*reflected_type
;
898 MonoReflectionMethod
*add_method
;
899 MonoReflectionMethod
*remove_method
;
900 MonoReflectionMethod
*raise_method
;
902 MonoArray
*other_methods
;
907 MonoString
*name_space
;
908 MonoReflectionType
*etype
;
909 MonoReflectionType
*nested_in
;
910 MonoReflectionAssembly
*assembly
;
912 MonoBoolean isprimitive
;
918 } MonoReflectionILTokenInfo
;
927 MonoArray
*ex_handlers
;
928 gint32 num_token_fixups
;
929 MonoArray
*token_fixups
;
930 } MonoReflectionILGen
;
937 } MonoILExceptionInfo
;
944 gint32 filter_offset
;
945 } MonoILExceptionBlock
;
949 MonoObject
*catch_type
;
950 gint32 filter_offset
;
954 gint32 handler_offset
;
955 gint32 handler_length
;
956 } MonoReflectionExceptionHandlingClause
;
960 MonoReflectionType
*local_type
;
961 MonoBoolean is_pinned
;
963 } MonoReflectionLocalVariableInfo
;
967 * Must have the same layout as MonoReflectionLocalVariableInfo, since
968 * LocalBuilder inherits from it under net 2.0.
972 MonoBoolean is_pinned
;
975 } MonoReflectionLocalBuilder
;
984 MonoString
*marshaltype
;
985 MonoObject
*marshaltyperef
;
987 MonoBoolean has_size
;
988 } MonoReflectionMarshal
;
995 MonoReflectionMarshal
*marshal_info
;
999 MonoObject
*def_value
;
1000 } MonoReflectionParamBuilder
;
1004 MonoMethod
*mhandle
;
1005 MonoReflectionILGen
*ilgen
;
1006 MonoArray
*parameters
;
1014 MonoBoolean init_locals
;
1015 MonoArray
*param_modreq
;
1016 MonoArray
*param_modopt
;
1017 MonoArray
*permissions
;
1018 } MonoReflectionCtorBuilder
;
1022 MonoMethod
*mhandle
;
1024 MonoArray
*parameters
;
1030 MonoReflectionILGen
*ilgen
;
1034 MonoArray
*override_methods
;
1036 MonoString
*dllentry
;
1038 guint32 extra_flags
;
1041 MonoBoolean init_locals
;
1042 MonoGenericContainer
*generic_container
;
1043 MonoArray
*generic_params
;
1044 MonoArray
*return_modreq
;
1045 MonoArray
*return_modopt
;
1046 MonoArray
*param_modreq
;
1047 MonoArray
*param_modopt
;
1048 MonoArray
*permissions
;
1049 } MonoReflectionMethodBuilder
;
1053 MonoMethod
*mhandle
;
1054 MonoReflectionType
*parent
;
1055 MonoReflectionType
*ret
;
1056 MonoArray
*parameters
;
1060 } MonoReflectionArrayMethod
;
1065 MonoString
*filename
;
1069 } MonoReflectionResource
;
1075 MonoArray
*res_data
;
1076 } MonoReflectionWin32Resource
;
1081 } MonoReflectionPermissionSet
;
1084 MonoReflectionAssembly assembly
;
1085 MonoDynamicAssembly
*dynamic_assembly
;
1086 MonoReflectionMethod
*entry_point
;
1091 MonoArray
*resources
;
1092 MonoArray
*public_key
;
1093 MonoString
*version
;
1094 MonoString
*culture
;
1098 MonoBoolean delay_sign
;
1100 MonoArray
*loaded_modules
;
1101 MonoArray
*win32_resources
;
1103 MonoArray
*permissions_minimum
;
1104 MonoArray
*permissions_optional
;
1105 MonoArray
*permissions_refused
;
1108 MonoBoolean corlib_internal
;
1109 MonoArray
*type_forwarders
;
1110 MonoArray
*pktoken
; /* as hexadecimal byte[] */
1111 } MonoReflectionAssemblyBuilder
;
1118 MonoObject
*def_value
;
1121 MonoReflectionType
*typeb
;
1122 MonoArray
*rva_data
;
1124 MonoReflectionMarshal
*marshal_info
;
1125 MonoClassField
*handle
;
1128 } 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
;
1161 MonoReflectionModule module
;
1162 MonoDynamicImage
*dynamic_image
;
1168 MonoReflectionAssemblyBuilder
*assemblyb
;
1169 MonoArray
*global_methods
;
1170 MonoArray
*global_fields
;
1172 MonoArray
*resources
;
1173 } MonoReflectionModuleBuilder
;
1176 MonoReflectionType type
;
1180 MonoReflectionType
*nesting_type
;
1181 MonoArray
*interfaces
;
1185 MonoArray
*properties
;
1190 MonoArray
*subtypes
;
1193 MonoReflectionModuleBuilder
*module
;
1195 gint32 packing_size
;
1196 MonoGenericContainer
*generic_container
;
1197 MonoArray
*generic_params
;
1198 MonoArray
*permissions
;
1199 MonoReflectionType
*created
;
1200 } MonoReflectionTypeBuilder
;
1203 MonoReflectionType type
;
1204 MonoReflectionType
*element_type
;
1206 } MonoReflectionArrayType
;
1209 MonoReflectionType type
;
1210 MonoReflectionType
*element_type
;
1211 } MonoReflectionDerivedType
;
1214 MonoReflectionType type
;
1215 MonoReflectionTypeBuilder
*tbuilder
;
1216 MonoReflectionMethodBuilder
*mbuilder
;
1219 MonoReflectionType
*base_type
;
1220 MonoArray
*iface_constraints
;
1223 } MonoReflectionGenericParam
;
1225 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass
;
1226 struct _MonoReflectionGenericClass
{
1227 MonoReflectionType type
;
1228 MonoReflectionType
*generic_type
; /*Can be either a MonoType or a TypeBuilder*/
1229 MonoArray
*type_arguments
;
1230 guint32 initialized
;
1236 MonoString
*codebase
;
1237 gint32 major
, minor
, build
, revision
;
1238 MonoObject
*cultureInfo
;
1241 MonoObject
*keypair
;
1242 MonoArray
*publicKey
;
1243 MonoArray
*keyToken
;
1244 guint32 versioncompat
;
1245 MonoObject
*version
;
1246 guint32 processor_architecture
;
1247 } MonoReflectionAssemblyName
;
1252 MonoReflectionType
*type
;
1253 MonoReflectionTypeBuilder
*typeb
;
1255 MonoReflectionMethodBuilder
*add_method
;
1256 MonoReflectionMethodBuilder
*remove_method
;
1257 MonoReflectionMethodBuilder
*raise_method
;
1258 MonoArray
*other_methods
;
1261 } MonoReflectionEventBuilder
;
1265 MonoReflectionMethod
*ctor
;
1267 } MonoReflectionCustomAttr
;
1271 MonoString
*marshal_cookie
;
1272 MonoString
*marshal_type
;
1273 MonoReflectionType
*marshal_type_ref
;
1274 MonoReflectionType
*marshal_safe_array_user_defined_subtype
;
1276 guint32 array_subtype
;
1277 gint32 safe_array_subtype
;
1279 gint32 IidParameterIndex
;
1280 gint16 size_param_index
;
1281 } MonoReflectionMarshalAsAttribute
;
1287 MonoBoolean best_fit_mapping
;
1288 MonoBoolean throw_on_unmappable
;
1289 MonoBoolean set_last_error
;
1290 } MonoReflectionUnmanagedFunctionPointerAttribute
;
1295 } MonoReflectionGuidAttribute
;
1299 MonoMethod
*mhandle
;
1301 MonoReflectionType
*rtype
;
1302 MonoArray
*parameters
;
1305 MonoReflectionModule
*module
;
1306 MonoBoolean skip_visibility
;
1307 MonoBoolean init_locals
;
1308 MonoReflectionILGen
*ilgen
;
1311 GSList
*referenced_by
;
1312 MonoReflectionType
*owner
;
1313 } MonoReflectionDynamicMethod
;
1317 MonoReflectionModuleBuilder
*module
;
1318 MonoArray
*arguments
;
1320 MonoReflectionType
*return_type
;
1322 guint32 unmanaged_call_conv
;
1325 } MonoReflectionSigHelper
;
1329 MonoReflectionGenericClass
*inst
;
1330 MonoObject
*fb
; /*can be either a MonoField or a FieldBuilder*/
1331 } MonoReflectionFieldOnTypeBuilderInst
;
1335 MonoReflectionGenericClass
*inst
;
1336 MonoObject
*cb
; /*can be either a MonoCMethod or ConstructorBuilder*/
1337 } MonoReflectionCtorOnTypeBuilderInst
;
1341 MonoReflectionType
*inst
;
1342 MonoObject
*mb
; /*can be either a MonoMethod or MethodBuilder*/
1343 MonoArray
*method_args
;
1344 MonoReflectionMethodBuilder
*generic_method_definition
;
1345 } MonoReflectionMethodOnTypeBuilderInst
;
1349 MonoBoolean visible
;
1350 } MonoReflectionComVisibleAttribute
;
1353 RESOURCE_LOCATION_EMBEDDED
= 1,
1354 RESOURCE_LOCATION_ANOTHER_ASSEMBLY
= 2,
1355 RESOURCE_LOCATION_IN_MANIFEST
= 4
1360 MonoReflectionAssembly
*assembly
;
1361 MonoString
*filename
;
1363 } MonoManifestResourceInfo
;
1365 /* A boxed IntPtr */
1371 /* Keep in sync with System.GenericParameterAttributes */
1373 GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT
= 0,
1374 GENERIC_PARAMETER_ATTRIBUTE_COVARIANT
= 1,
1375 GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT
= 2,
1376 GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK
= 3,
1378 GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT
= 0,
1379 GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT
= 4,
1380 GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT
= 8,
1381 GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT
= 16,
1382 GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK
= 28
1383 } GenericParameterAttributes
;
1387 MonoClassField
*field
;
1391 void mono_image_create_pefile (MonoReflectionModuleBuilder
*module
, HANDLE file
);
1392 void mono_image_basic_init (MonoReflectionAssemblyBuilder
*assembly
);
1393 MonoReflectionModule
* mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder
*assembly
, MonoString
*file_name
);
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
);
1396 guint32
mono_image_create_method_token (MonoDynamicImage
*assembly
, MonoObject
*obj
, MonoArray
*opt_param_types
);
1397 void mono_image_module_basic_init (MonoReflectionModuleBuilder
*module
);
1398 void mono_image_register_token (MonoDynamicImage
*assembly
, guint32 token
, MonoObject
*obj
);
1399 void mono_dynamic_image_free (MonoDynamicImage
*image
);
1400 void mono_dynamic_image_free_image (MonoDynamicImage
*image
);
1401 void mono_image_set_wrappers_type (MonoReflectionModuleBuilder
*mb
, MonoReflectionType
*type
);
1402 void mono_dynamic_image_release_gc_roots (MonoDynamicImage
*image
);
1404 void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder
*tb
);
1406 void mono_reflection_create_internal_class (MonoReflectionTypeBuilder
*tb
);
1408 void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder
*tb
);
1410 void mono_reflection_create_generic_class (MonoReflectionTypeBuilder
*tb
);
1412 MonoReflectionType
* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder
*tb
);
1414 void mono_reflection_get_dynamic_overrides (MonoClass
*klass
, MonoMethod
***overrides
, int *num_overrides
);
1416 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod
*m
);
1417 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod
*mb
);
1419 void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam
*gparam
);
1420 void mono_reflection_create_unmanaged_type (MonoReflectionType
*type
);
1421 void mono_reflection_register_with_runtime (MonoReflectionType
*type
);
1423 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
);
1424 MonoMethodSignature
* mono_reflection_lookup_signature (MonoImage
*image
, MonoMethod
*method
, guint32 token
, MonoError
*error
);
1426 MonoArray
* mono_param_get_objects_internal (MonoDomain
*domain
, MonoMethod
*method
, MonoClass
*refclass
);
1429 mono_class_bind_generic_parameters (MonoClass
*klass
, int type_argc
, MonoType
**types
, gboolean is_dynamic
);
1431 mono_reflection_bind_generic_parameters (MonoReflectionType
*type
, int type_argc
, MonoType
**types
);
1432 MonoReflectionMethod
*
1433 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod
*method
, MonoArray
*types
);
1435 mono_reflection_generic_class_initialize (MonoReflectionGenericClass
*type
, MonoArray
*fields
);
1436 MonoReflectionEvent
*
1437 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder
*tb
, MonoReflectionEventBuilder
*eb
);
1439 MonoArray
*mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper
*sig
);
1441 MonoArray
*mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper
*sig
);
1443 MonoReflectionMarshalAsAttribute
* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain
*domain
, MonoClass
*klass
, MonoMarshalSpec
*spec
);
1446 mono_reflection_lookup_dynamic_token (MonoImage
*image
, guint32 token
, gboolean valid_token
, MonoClass
**handle_class
, MonoGenericContext
*context
);
1449 mono_reflection_call_is_assignable_to (MonoClass
*klass
, MonoClass
*oklass
);
1452 mono_reflection_is_valid_dynamic_token (MonoDynamicImage
*image
, guint32 token
);
1455 mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod
*method
, MonoReflectionAssembly
*assembly
, gpointer data
, guint32 data_length
, MonoArray
**ctor_args
, MonoArray
** named_args
);
1458 mono_reflection_type_get_handle (MonoReflectionType
*ref
);
1461 mono_reflection_free_dynamic_generic_class (MonoGenericClass
*gclass
);
1464 mono_image_build_metadata (MonoReflectionModuleBuilder
*module
);
1467 mono_get_constant_value_from_blob (MonoDomain
* domain
, MonoTypeEnum type
, const char *blob
, void *value
);
1470 mono_release_type_locks (MonoInternalThread
*thread
);
1473 mono_string_to_utf8_mp (MonoMemPool
*mp
, MonoString
*s
, MonoError
*error
);
1476 mono_string_to_utf8_image (MonoImage
*image
, MonoString
*s
, MonoError
*error
);
1480 mono_array_clone_in_domain (MonoDomain
*domain
, MonoArray
*array
);
1483 mono_array_full_copy (MonoArray
*src
, MonoArray
*dest
);
1486 mono_array_calc_byte_len (MonoClass
*klass
, uintptr_t len
, uintptr_t *res
);
1488 #ifndef DISABLE_REMOTING
1490 mono_remoting_invoke (MonoObject
*real_proxy
, MonoMethodMessage
*msg
,
1491 MonoObject
**exc
, MonoArray
**out_args
);
1494 mono_remote_class_vtable (MonoDomain
*domain
, MonoRemoteClass
*remote_class
, MonoRealProxy
*real_proxy
);
1497 mono_upgrade_remote_class (MonoDomain
*domain
, MonoObject
*tproxy
, MonoClass
*klass
);
1501 mono_create_ftnptr (MonoDomain
*domain
, gpointer addr
);
1504 mono_get_addr_from_ftnptr (gpointer descr
);
1507 mono_nullable_init (guint8
*buf
, MonoObject
*value
, MonoClass
*klass
);
1510 mono_nullable_box (guint8
*buf
, MonoClass
*klass
);
1512 #ifdef MONO_SMALL_CONFIG
1513 #define MONO_IMT_SIZE 9
1515 #define MONO_IMT_SIZE 19
1520 gpointer target_code
;
1523 typedef struct _MonoImtBuilderEntry
{
1525 struct _MonoImtBuilderEntry
*next
;
1526 MonoImtItemValue value
;
1528 guint8 has_target_code
: 1;
1529 } MonoImtBuilderEntry
;
1531 typedef struct _MonoIMTCheckItem MonoIMTCheckItem
;
1533 struct _MonoIMTCheckItem
{
1535 int check_target_idx
;
1536 MonoImtItemValue value
;
1538 guint8
*code_target
;
1540 guint8 compare_done
;
1542 guint8 short_branch
;
1543 guint8 has_target_code
;
1546 typedef gpointer (*MonoImtThunkBuilder
) (MonoVTable
*vtable
, MonoDomain
*domain
,
1547 MonoIMTCheckItem
**imt_entries
, int count
, gpointer fail_trunk
);
1550 mono_install_imt_thunk_builder (MonoImtThunkBuilder func
);
1553 mono_set_always_build_imt_thunks (gboolean value
);
1556 mono_vtable_build_imt_slot (MonoVTable
* vtable
, int imt_slot
);
1559 mono_method_get_imt_slot (MonoMethod
*method
);
1562 mono_method_add_generic_virtual_invocation (MonoDomain
*domain
, MonoVTable
*vtable
,
1563 gpointer
*vtable_slot
,
1564 MonoMethod
*method
, gpointer code
);
1567 mono_method_alloc_generic_virtual_thunk (MonoDomain
*domain
, int size
);
1570 MONO_UNHANDLED_POLICY_LEGACY
,
1571 MONO_UNHANDLED_POLICY_CURRENT
1572 } MonoRuntimeUnhandledExceptionPolicy
;
1574 MonoRuntimeUnhandledExceptionPolicy
1575 mono_runtime_unhandled_exception_policy_get (void);
1577 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy
);
1580 mono_class_try_get_vtable (MonoDomain
*domain
, MonoClass
*klass
);
1583 mono_runtime_class_init_full (MonoVTable
*vtable
, gboolean raise_exception
);
1586 mono_method_clear_object (MonoDomain
*domain
, MonoMethod
*method
);
1589 mono_class_compute_gc_descriptor (MonoClass
*klass
);
1592 mono_class_compute_bitmap (MonoClass
*klass
, gsize
*bitmap
, int size
, int offset
, int *max_set
, gboolean static_fields
);
1595 mono_object_xdomain_representation (MonoObject
*obj
, MonoDomain
*target_domain
, MonoObject
**exc
);
1598 mono_class_is_reflection_method_or_constructor (MonoClass
*klass
);
1601 mono_get_object_from_blob (MonoDomain
*domain
, MonoType
*type
, const char *blob
);
1604 mono_class_get_ref_info (MonoClass
*klass
);
1607 mono_class_set_ref_info (MonoClass
*klass
, gpointer obj
);
1610 mono_class_free_ref_info (MonoClass
*klass
);
1613 mono_object_new_pinned (MonoDomain
*domain
, MonoClass
*klass
);
1616 mono_object_new_specific_checked (MonoVTable
*vtable
, MonoError
*error
);
1619 ves_icall_object_new_specific (MonoVTable
*vtable
);
1622 mono_field_static_get_value_for_thread (MonoInternalThread
*thread
, MonoVTable
*vt
, MonoClassField
*field
, void *value
);
1624 /* exported, used by the debugger */
1626 mono_vtable_get_static_field_data (MonoVTable
*vt
);
1629 mono_string_to_utf8_ignore (MonoString
*s
);
1632 mono_string_to_utf8_image_ignore (MonoImage
*image
, MonoString
*s
);
1635 mono_string_to_utf8_mp_ignore (MonoMemPool
*mp
, MonoString
*s
);
1638 mono_monitor_is_il_fastpath_wrapper (MonoMethod
*method
);
1641 mono_exception_get_native_backtrace (MonoException
*exc
);
1644 ves_icall_Mono_Runtime_GetNativeStackTrace (MonoException
*exc
);
1647 mono_exception_get_managed_backtrace (MonoException
*exc
);
1650 mono_copy_value (MonoType
*type
, void *dest
, void *value
, int deref_pointer
);
1653 mono_error_raise_exception (MonoError
*target_error
);
1656 mono_error_set_pending_exception (MonoError
*error
);
1659 mono_glist_to_array (GList
*list
, MonoClass
*eclass
);
1662 mono_object_new_mature (MonoVTable
*vtable
, MonoError
*error
);
1665 mono_object_new_fast_checked (MonoVTable
*vtable
, MonoError
*error
);
1668 ves_icall_object_new_fast (MonoVTable
*vtable
);
1671 mono_object_clone_checked (MonoObject
*obj
, MonoError
*error
);
1674 mono_string_new_size_checked (MonoDomain
*domain
, gint32 len
, MonoError
*error
);
1676 #endif /* __MONO_OBJECT_INTERNALS_H__ */