5 #ifndef __MONO_METADATA_INTERNALS_H__
6 #define __MONO_METADATA_INTERNALS_H__
8 #include "mono/utils/mono-forward-internal.h"
9 #include "mono/metadata/image.h"
10 #include "mono/metadata/blob.h"
11 #include "mono/metadata/cil-coff.h"
12 #include "mono/metadata/mempool.h"
13 #include "mono/metadata/domain-internals.h"
14 #include "mono/metadata/mono-hash.h"
15 #include "mono/utils/mono-compiler.h"
16 #include "mono/utils/mono-dl.h"
17 #include "mono/utils/monobitset.h"
18 #include "mono/utils/mono-property-hash.h"
19 #include "mono/utils/mono-value-hash.h"
20 #include <mono/utils/mono-error.h>
21 #include "mono/utils/mono-conc-hashtable.h"
22 #include "mono/utils/refcount.h"
26 MonoClass
*klass
; /* for VALUETYPE and CLASS */
27 MonoType
*type
; /* for PTR */
28 MonoArrayType
*array
; /* for ARRAY */
29 MonoMethodSignature
*method
;
30 MonoGenericParam
*generic_param
; /* for VAR and MVAR */
31 MonoGenericClass
*generic_class
; /* for GENERICINST */
33 unsigned int attrs
: 16; /* param attributes or field flags */
34 MonoTypeEnum type
: 8;
35 unsigned int has_cmods
: 1;
36 unsigned int byref
: 1;
37 unsigned int pinned
: 1; /* valid when included in a local var signature */
41 unsigned int required
: 1;
43 } MonoSingleCustomMod
;
45 /* Aggregate custom modifiers can happen if a generic VAR or MVAR is inflated,
46 * and both the VAR and the type that will be used to inflated it have custom
47 * modifiers, but they come from different images. (e.g. inflating 'class G<T>
48 * {void Test (T modopt(IsConst) t);}' with 'int32 modopt(IsLong)' where G is
49 * in image1 and the int32 is in image2.)
51 * Moreover, we can't just store an image and a type token per modifier, because
52 * Roslyn and C++/CLI sometimes create modifiers that mention generic parameters that must be inflated, like:
53 * void .CL1`1.Test(!0 modopt(System.Nullable`1<!0>))
54 * So we have to store a resolved MonoType*.
56 * Because the types come from different images, we allocate the aggregate
57 * custom modifiers container object in the mempool of a MonoImageSet to ensure
58 * that it doesn't have dangling image pointers.
62 MonoSingleCustomMod modifiers
[1]; /* Actual length is count */
63 } MonoAggregateModContainer
;
65 /* ECMA says upto 64 custom modifiers. It's possible we could see more at
66 * runtime due to modifiers being appended together when we inflate type. In
67 * that case we should revisit the places where this define is used to make
68 * sure that we don't blow up the stack (or switch to heap allocation for
71 #define MONO_MAX_EXPECTED_CMODS 64
75 gboolean is_aggregate
;
77 MonoCustomModContainer cmods
;
78 /* the actual aggregate modifiers are in a MonoImageSet mempool
79 * that includes all the images of all the modifier types and
80 * also the type that this aggregate container is a part of.*/
81 MonoAggregateModContainer
*amods
;
83 } MonoTypeWithModifiers
;
86 mono_type_is_aggregate_mods (const MonoType
*t
);
89 mono_type_with_mods_init (MonoType
*dest
, uint8_t num_mods
, gboolean is_aggregate
)
96 MonoTypeWithModifiers
*dest_full
= (MonoTypeWithModifiers
*)dest
;
97 dest_full
->is_aggregate
= !!is_aggregate
;
99 dest_full
->mods
.amods
= NULL
;
101 dest_full
->mods
.cmods
.count
= num_mods
;
104 MonoCustomModContainer
*
105 mono_type_get_cmods (const MonoType
*t
);
107 MonoAggregateModContainer
*
108 mono_type_get_amods (const MonoType
*t
);
111 mono_type_set_amods (MonoType
*t
, MonoAggregateModContainer
*amods
);
113 static inline uint8_t
114 mono_type_custom_modifier_count (const MonoType
*t
)
118 MonoTypeWithModifiers
*full
= (MonoTypeWithModifiers
*)t
;
119 if (full
->is_aggregate
)
120 return full
->mods
.amods
->count
;
122 return full
->mods
.cmods
.count
;
126 mono_type_get_custom_modifier (const MonoType
*ty
, uint8_t idx
, gboolean
*required
, MonoError
*error
);
128 // Note: sizeof (MonoType) is dangerous. It can copy the num_mods
129 // field without copying the variably sized array. This leads to
130 // memory unsafety on the stack and/or heap, when we try to traverse
133 // Use mono_sizeof_monotype
134 // to get the size of the memory to copy.
135 #define MONO_SIZEOF_TYPE sizeof (MonoType)
138 mono_sizeof_type_with_mods (uint8_t num_mods
, gboolean aggregate
);
141 mono_sizeof_type (const MonoType
*ty
);
144 mono_sizeof_aggregate_modifiers (uint8_t num_mods
);
146 MonoAggregateModContainer
*
147 mono_metadata_get_canonical_aggregate_modifiers (MonoAggregateModContainer
*candidate
);
149 #define MONO_SECMAN_FLAG_INIT(x) (x & 0x2)
150 #define MONO_SECMAN_FLAG_GET_VALUE(x) (x & 0x1)
151 #define MONO_SECMAN_FLAG_SET_VALUE(x,y) do { x = ((y) ? 0x3 : 0x2); } while (0)
153 #define MONO_PUBLIC_KEY_TOKEN_LENGTH 17
155 #define MONO_PROCESSOR_ARCHITECTURE_NONE 0
156 #define MONO_PROCESSOR_ARCHITECTURE_MSIL 1
157 #define MONO_PROCESSOR_ARCHITECTURE_X86 2
158 #define MONO_PROCESSOR_ARCHITECTURE_IA64 3
159 #define MONO_PROCESSOR_ARCHITECTURE_AMD64 4
160 #define MONO_PROCESSOR_ARCHITECTURE_ARM 5
162 struct _MonoAssemblyName
{
165 const char *hash_value
;
166 const mono_byte
* public_key
;
167 // string of 16 hex chars + 1 NULL
168 mono_byte public_key_token
[MONO_PUBLIC_KEY_TOKEN_LENGTH
];
172 #ifdef ENABLE_NETCORE
173 int major
, minor
, build
, revision
, arch
;
175 uint16_t major
, minor
, build
, revision
, arch
;
179 struct MonoTypeNameParse
{
182 MonoAssemblyName assembly
;
183 GList
*modifiers
; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
184 GPtrArray
*type_arguments
;
189 typedef enum MonoAssemblyContextKind
{
190 /* Default assembly context: Load(String) and assembly references */
191 MONO_ASMCTX_DEFAULT
= 0,
192 /* Reflection-only only context: ReflectionOnlyLoad and ReeflectionOnlyLoadFrom */
193 MONO_ASMCTX_REFONLY
= 1,
194 /* LoadFrom context: LoadFrom() and references */
195 MONO_ASMCTX_LOADFROM
= 2,
196 /* Individual assembly context (.NET Framework docs call this "not in
197 * any context"): LoadFile(String) and Load(byte[]) are here.
199 MONO_ASMCTX_INDIVIDUAL
= 3,
202 } MonoAssemblyContextKind
;
204 typedef struct _MonoAssemblyContext
{
205 MonoAssemblyContextKind kind
;
206 } MonoAssemblyContext
;
208 struct _MonoAssembly
{
210 * The number of appdomains which have this assembly loaded plus the number of
211 * assemblies referencing this assembly through an entry in their image->references
212 * arrays. The latter is needed because entries in the image->references array
213 * might point to assemblies which are only loaded in some appdomains, and without
214 * the additional reference, they can be freed at any time.
215 * The ref_count is initially 0.
217 int ref_count
; /* use atomic operations only */
219 MonoAssemblyName aname
;
221 GSList
*friend_assembly_names
; /* Computed by mono_assembly_load_friends () */
222 guint8 friend_assembly_names_inited
;
225 guint8 corlib_internal
;
226 MonoAssemblyContext context
;
227 guint8 wrap_non_exception_throws
;
228 guint8 wrap_non_exception_throws_inited
;
229 guint8 jit_optimizer_disabled
;
230 guint8 jit_optimizer_disabled_inited
;
231 /* security manager flags (one bit is for lazy initialization) */
232 guint32 ecma
:2; /* Has the ECMA key */
233 guint32 aptc
:2; /* Has the [AllowPartiallyTrustedCallers] attributes */
234 guint32 fulltrust
:2; /* Has FullTrust permission */
235 guint32 unmanaged
:2; /* Has SecurityPermissionFlag.UnmanagedCode permission */
236 guint32 skipverification
:2; /* Has SecurityPermissionFlag.SkipVerification permission */
241 * indexed by MonoMethodSignature
242 * Protected by the marshal lock
244 GHashTable
*delegate_invoke_cache
;
245 GHashTable
*delegate_begin_invoke_cache
;
246 GHashTable
*delegate_end_invoke_cache
;
247 GHashTable
*runtime_invoke_signature_cache
;
248 GHashTable
*runtime_invoke_sig_cache
;
251 * indexed by SignaturePointerPair
253 GHashTable
*delegate_abstract_invoke_cache
;
254 GHashTable
*delegate_bound_static_invoke_cache
;
257 * indexed by MonoMethod pointers
258 * Protected by the marshal lock
260 GHashTable
*runtime_invoke_method_cache
;
261 GHashTable
*managed_wrapper_cache
;
263 GHashTable
*native_wrapper_cache
;
264 GHashTable
*native_wrapper_aot_cache
;
265 GHashTable
*native_wrapper_check_cache
;
266 GHashTable
*native_wrapper_aot_check_cache
;
268 GHashTable
*native_func_wrapper_aot_cache
;
269 GHashTable
*remoting_invoke_cache
;
270 GHashTable
*synchronized_cache
;
271 GHashTable
*unbox_wrapper_cache
;
272 GHashTable
*cominterop_invoke_cache
;
273 GHashTable
*cominterop_wrapper_cache
; /* LOCKING: marshal lock */
274 GHashTable
*thunk_invoke_cache
;
282 struct _MonoTableInfo
{
288 * Tables contain up to 9 columns and the possible sizes of the
289 * fields in the documentation are 1, 2 and 4 bytes. So we
290 * can encode in 2 bits the size.
292 * A 32 bit value can encode the resulting size
294 * The top eight bits encode the number of columns in the table.
295 * we only need 4, but 8 is aligned no shift required.
297 guint32 size_bitfield
;
300 #define REFERENCE_MISSING ((gpointer) -1)
303 gboolean (*match
) (MonoImage
*);
304 gboolean (*load_pe_data
) (MonoImage
*);
305 gboolean (*load_cli_data
) (MonoImage
*);
306 gboolean (*load_tables
) (MonoImage
*);
309 /* Represents the physical bytes for an image (usually in the file system, but
310 * could be in memory).
312 * The MonoImageStorage owns the raw data for an image and is responsible for
315 * May be shared by multiple MonoImage objects if they opened the same
316 * underlying file or byte blob in memory.
318 * There is an abstract string key (usually a file path, but could be formed in
319 * other ways) that is used to share MonoImageStorage objects among images.
325 /* key used for lookups. owned by this image storage. */
328 /* If the raw data was allocated from a source such as mmap, the allocator may store resource tracking information here. */
329 void *raw_data_handle
;
331 guint32 raw_data_len
;
332 /* data was allocated with mono_file_map and must be unmapped */
333 guint8 raw_buffer_used
: 1;
334 /* data was allocated with malloc and must be freed */
335 guint8 raw_data_allocated
: 1;
336 /* data was allocated with mono_file_map_fileio */
337 guint8 fileio_used
: 1;
340 /* Module was loaded using LoadLibrary. */
341 guint8 is_module_handle
: 1;
343 /* Module entry point is _CorDllMain. */
344 guint8 has_entry_point
: 1;
350 * This count is incremented during these situations:
351 * - An assembly references this MonoImage through its 'image' field
352 * - This MonoImage is present in the 'files' field of an image
353 * - This MonoImage is present in the 'modules' field of an image
354 * - A thread is holding a temporary reference to this MonoImage between
355 * calls to mono_image_open and mono_image_close ()
359 MonoImageStorage
*storage
;
361 /* Aliases storage->raw_data when storage is non-NULL. Otherwise NULL. */
363 guint32 raw_data_len
;
365 /* Whenever this is a dynamically emitted module */
368 /* Whenever this is a reflection only image */
371 /* Whenever this image contains uncompressed metadata */
372 guint8 uncompressed_metadata
: 1;
374 /* Whenever this image contains metadata only without PE data */
375 guint8 metadata_only
: 1;
377 /* Whether this image belongs to load-from context */
378 guint8 load_from_context
: 1;
380 guint8 checked_module_cctor
: 1;
381 guint8 has_module_cctor
: 1;
383 guint8 idx_string_wide
: 1;
384 guint8 idx_guid_wide
: 1;
385 guint8 idx_blob_wide
: 1;
387 /* Whenever this image is considered as platform code for the CoreCLR security model */
388 guint8 core_clr_platform_code
: 1;
390 /* The path to the file for this image or an arbitrary name for images loaded from data. */
393 /* The path to the file for this image or NULL */
396 /* The assembly name reported in the file for this image (expected to be NULL for a netmodule) */
397 const char *assembly_name
;
399 /* The module name reported in the file for this image (could be NULL for a malformed file) */
400 const char *module_name
;
401 guint32 time_date_stamp
;
404 gint16 md_version_major
, md_version_minor
;
406 MonoCLIImageInfo
*image_info
;
407 MonoMemPool
*mempool
; /*protected by the image lock*/
411 MonoStreamHeader heap_strings
;
412 MonoStreamHeader heap_us
;
413 MonoStreamHeader heap_blob
;
414 MonoStreamHeader heap_guid
;
415 MonoStreamHeader heap_tables
;
416 MonoStreamHeader heap_pdb
;
418 const char *tables_base
;
421 guint64 referenced_tables
;
422 int *referenced_table_rows
;
425 MonoTableInfo tables
[MONO_TABLE_NUM
];
428 * references is initialized only by using the mono_assembly_open
429 * function, and not by using the lowlevel mono_image_open.
431 * Protected by the image lock.
433 * It is NULL terminated.
435 MonoAssembly
**references
;
438 /* Code files in the assembly. The main assembly has a "file" table and also a "module"
439 * table, where the module table is a subset of the file table. We track both lists,
440 * and because we can lazy-load them at different times we reference-increment both.
442 /* No netmodules in netcore, but for System.Reflection.Emit support we still use modules */
444 guint32 module_count
;
445 gboolean
*modules_loaded
;
450 MonoAotModule
*aot_module
;
455 * The Assembly this image was loaded from.
457 MonoAssembly
*assembly
;
459 #ifdef ENABLE_NETCORE
461 * The AssemblyLoadContext that this image was loaded into.
463 MonoAssemblyLoadContext
*alc
;
467 * Indexed by method tokens and typedef tokens.
469 GHashTable
*method_cache
; /*protected by the image lock*/
470 MonoInternalHashTable class_cache
;
472 /* Indexed by memberref + methodspec tokens */
473 GHashTable
*methodref_cache
; /*protected by the image lock*/
476 * Indexed by fielddef and memberref tokens
478 MonoConcurrentHashTable
*field_cache
; /*protected by the image lock*/
480 /* indexed by typespec tokens. */
481 MonoConcurrentHashTable
*typespec_cache
; /* protected by the image lock */
482 /* indexed by token */
483 GHashTable
*memberref_signatures
;
485 /* Indexed by blob heap indexes */
486 GHashTable
*method_signatures
;
489 * Indexes namespaces to hash tables that map class name to typedef token.
491 GHashTable
*name_cache
; /*protected by the image lock*/
494 * Indexed by MonoClass
496 GHashTable
*array_cache
;
497 GHashTable
*ptr_cache
;
499 GHashTable
*szarray_cache
;
500 /* This has a separate lock to improve scalability */
501 mono_mutex_t szarray_cache_lock
;
504 * indexed by SignaturePointerPair
506 GHashTable
*native_func_wrapper_cache
;
509 * indexed by MonoMethod pointers
511 GHashTable
*wrapper_param_names
;
512 GHashTable
*array_accessor_cache
;
515 * indexed by MonoClass pointers
517 GHashTable
*ldfld_wrapper_cache
;
518 GHashTable
*ldflda_wrapper_cache
;
519 GHashTable
*stfld_wrapper_cache
;
520 GHashTable
*isinst_cache
;
522 GHashTable
*icall_wrapper_cache
;
523 GHashTable
*castclass_cache
;
524 GHashTable
*proxy_isinst_cache
;
525 GHashTable
*rgctx_template_hash
; /* LOCKING: templates lock */
527 /* Contains rarely used fields of runtime structures belonging to this image */
528 MonoPropertyHash
*property_hash
;
530 void *reflection_info
;
533 * user_info is a public field and is not touched by the
538 #ifndef DISABLE_DLLMAP
539 /* dll map entries */
543 /* interfaces IDs from this image */
544 /* protected by the classes lock */
545 MonoBitSet
*interface_bitset
;
547 /* when the image is being closed, this is abused as a list of
548 malloc'ed regions to be freed. */
549 GSList
*reflection_info_unregister_classes
;
551 /* List of dependent image sets containing this image */
552 /* Protected by image_sets_lock */
555 /* Caches for wrappers that DO NOT reference generic */
557 MonoWrapperCaches wrapper_caches
;
559 /* Pre-allocated anon generic params for the first N generic
560 * parameters, for a small N */
561 MonoGenericParam
*var_gparam_cache_fast
;
562 MonoGenericParam
*mvar_gparam_cache_fast
;
563 /* Anon generic parameters past N, if needed */
564 MonoConcurrentHashTable
*var_gparam_cache
;
565 MonoConcurrentHashTable
*mvar_gparam_cache
;
567 #ifndef ENABLE_NETCORE
568 /* Maps malloc-ed char* pinvoke scope -> MonoDl* */
569 GHashTable
*pinvoke_scopes
;
572 /* The loader used to load this image */
573 MonoImageLoader
*loader
;
575 // Containers for MonoGenericParams associated with this image but not with any specific class or method. Created on demand.
576 // This could happen, for example, for MonoTypes associated with TypeSpec table entries.
577 MonoGenericContainer
*anonymous_generic_class_container
;
578 MonoGenericContainer
*anonymous_generic_method_container
;
580 gboolean weak_fields_inited
;
581 /* Contains 1 based indexes */
582 GHashTable
*weak_field_indexes
;
585 * No other runtime locks must be taken while holding this lock.
586 * It's meant to be used only to mutate and query structures part of this image.
592 * Generic instances and aggregated custom modifiers depend on many images, and they need to be deleted if one
593 * of the images they depend on is unloaded. For example,
594 * List<Foo> depends on both List's image and Foo's image.
595 * A MonoImageSet is the owner of all generic instances depending on the same set of
602 // Generic-specific caches
603 GHashTable
*ginst_cache
, *gmethod_cache
, *gsignature_cache
;
604 MonoConcurrentHashTable
*gclass_cache
;
606 /* mirror caches of ones already on MonoImage. These ones contain generics */
607 GHashTable
*szarray_cache
, *array_cache
, *ptr_cache
;
609 MonoWrapperCaches wrapper_caches
;
611 GHashTable
*aggregate_modifiers_cache
;
613 /* Indexed by MonoGenericParam pointers */
614 GHashTable
**gshared_types
;
615 /* The length of the above array */
616 int gshared_types_len
;
621 * Memory for generic instances owned by this image set should be allocated from
622 * this mempool, using the mono_image_set_alloc family of functions.
624 MonoMemPool
*mempool
;
637 guint32 alloc_size
; /* malloced bytes */
639 guint32 offset
; /* from start of metadata */
645 guint8 row_size
; /* calculated later with column_sizes */
648 guint32
*values
; /* rows * columns */
651 /* "Dynamic" assemblies and images arise from System.Reflection.Emit */
652 struct _MonoDynamicAssembly
{
653 MonoAssembly assembly
;
655 guint32 strong_name_size
;
661 struct _MonoDynamicImage
{
665 guint32 metadata_rva
;
667 guint32 cli_header_offset
;
671 guint32 imp_names_offset
;
677 } sections
[MONO_SECTION_MAX
];
678 GHashTable
*typespec
;
680 GHashTable
*handleref
;
681 MonoGHashTable
*tokens
;
682 GHashTable
*blob_cache
;
683 GHashTable
*standalonesig_cache
;
684 GList
*array_methods
;
685 GPtrArray
*gen_params
;
686 MonoGHashTable
*token_fixups
;
687 GHashTable
*method_to_table_idx
;
688 GHashTable
*field_to_table_idx
;
689 GHashTable
*method_aux_hash
;
690 GHashTable
*vararg_aux_hash
;
691 MonoGHashTable
*generic_def_objects
;
693 * Maps final token values to the object they describe.
695 MonoGHashTable
*remapped_tokens
;
698 gboolean initial_image
;
699 guint32 pe_kind
, machine
;
701 guint32 strong_name_size
;
703 guint32 win32_res_size
;
706 MonoDynamicStream sheap
;
707 MonoDynamicStream code
; /* used to store method headers and bytecode */
708 MonoDynamicStream resources
; /* managed embedded resources */
709 MonoDynamicStream us
;
710 MonoDynamicStream blob
;
711 MonoDynamicStream tstream
;
712 MonoDynamicStream guid
;
713 MonoDynamicTable tables
[MONO_TABLE_NUM
];
714 MonoClass
*wrappers_type
; /*wrappers are bound to this type instead of <Module>*/
717 /* Contains information about assembly binding */
718 typedef struct _MonoAssemblyBindingInfo
{
721 guchar public_key_token
[MONO_PUBLIC_KEY_TOKEN_LENGTH
];
724 AssemblyVersionSet old_version_bottom
;
725 AssemblyVersionSet old_version_top
;
726 AssemblyVersionSet new_version
;
727 guint has_old_version_bottom
: 1;
728 guint has_old_version_top
: 1;
729 guint has_new_version
: 1;
731 gint32 domain_id
; /*Needed to unload per-domain binding*/
732 } MonoAssemblyBindingInfo
;
734 struct _MonoMethodHeader
{
735 const unsigned char *code
;
736 #ifdef MONO_SMALL_CONFIG
741 guint16 max_stack
: 15;
742 unsigned int is_transient
: 1; /* mono_metadata_free_mh () will actually free this header */
743 unsigned int num_clauses
: 15;
744 /* if num_locals != 0, then the following apply: */
745 unsigned int init_locals
: 1;
747 MonoExceptionClause
*clauses
;
748 MonoBitSet
*volatile_args
;
749 MonoBitSet
*volatile_locals
;
750 MonoType
*locals
[MONO_ZERO_LEN_ARRAY
];
754 const unsigned char *code
;
757 gboolean has_clauses
;
759 } MonoMethodHeaderSummary
;
761 // FIXME? offsetof (MonoMethodHeader, locals)?
762 #define MONO_SIZEOF_METHOD_HEADER (sizeof (struct _MonoMethodHeader) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
764 struct _MonoMethodSignature
{
766 #ifdef MONO_SMALL_CONFIG
769 unsigned int generic_param_count
: 5;
773 unsigned int generic_param_count
: 16;
775 unsigned int call_convention
: 6;
776 unsigned int hasthis
: 1;
777 unsigned int explicit_this
: 1;
778 unsigned int pinvoke
: 1;
779 unsigned int is_inflated
: 1;
780 unsigned int has_type_parameters
: 1;
781 MonoType
*params
[MONO_ZERO_LEN_ARRAY
];
785 * AOT cache configuration loaded from config files.
786 * Doesn't really belong here.
790 * Enable aot caching for applications whose main assemblies are in
796 } MonoAotCacheConfig
;
798 #define MONO_SIZEOF_METHOD_SIGNATURE (sizeof (struct _MonoMethodSignature) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
800 static inline gboolean
801 image_is_dynamic (MonoImage
*image
)
803 #ifdef DISABLE_REFLECTION_EMIT
806 return image
->dynamic
;
810 static inline gboolean
811 assembly_is_dynamic (MonoAssembly
*assembly
)
813 #ifdef DISABLE_REFLECTION_EMIT
816 return assembly
->dynamic
;
820 /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */
821 guint
mono_aligned_addr_hash (gconstpointer ptr
);
824 mono_image_check_for_module_cctor (MonoImage
*image
);
827 mono_image_alloc (MonoImage
*image
, guint size
);
830 mono_image_alloc0 (MonoImage
*image
, guint size
);
832 #define mono_image_new0(image,type,size) ((type *) mono_image_alloc0 (image, sizeof (type)* (size)))
835 mono_image_strdup (MonoImage
*image
, const char *s
);
838 mono_image_strdup_vprintf (MonoImage
*image
, const char *format
, va_list args
);
841 mono_image_strdup_printf (MonoImage
*image
, const char *format
, ...) MONO_ATTR_FORMAT_PRINTF(2,3);
844 mono_g_list_prepend_image (MonoImage
*image
, GList
*list
, gpointer data
);
847 mono_g_slist_append_image (MonoImage
*image
, GSList
*list
, gpointer data
);
850 mono_image_lock (MonoImage
*image
);
853 mono_image_unlock (MonoImage
*image
);
856 mono_image_property_lookup (MonoImage
*image
, gpointer subject
, guint32 property
);
859 mono_image_property_insert (MonoImage
*image
, gpointer subject
, guint32 property
, gpointer value
);
862 mono_image_property_remove (MonoImage
*image
, gpointer subject
);
865 mono_image_close_except_pools (MonoImage
*image
);
868 mono_image_close_finish (MonoImage
*image
);
870 typedef void (*MonoImageUnloadFunc
) (MonoImage
*image
, gpointer user_data
);
873 mono_install_image_unload_hook (MonoImageUnloadFunc func
, gpointer user_data
);
876 mono_remove_image_unload_hook (MonoImageUnloadFunc func
, gpointer user_data
);
879 mono_install_image_loader (const MonoImageLoader
*loader
);
882 mono_image_append_class_to_reflection_info_set (MonoClass
*klass
);
885 mono_image_set_alloc (MonoImageSet
*set
, guint size
);
888 mono_image_set_alloc0 (MonoImageSet
*set
, guint size
);
891 mono_image_set_lock (MonoImageSet
*set
);
894 mono_image_set_unlock (MonoImageSet
*set
);
897 mono_image_set_strdup (MonoImageSet
*set
, const char *s
);
900 mono_metadata_get_image_set_for_aggregate_modifiers (MonoAggregateModContainer
*amods
);
903 mono_metadata_get_image_set_for_type (MonoType
*type
);
906 mono_metadata_merge_image_sets (MonoImageSet
*set1
, MonoImageSet
*set2
);
908 #define mono_image_set_new0(image,type,size) ((type *) mono_image_set_alloc0 (image, sizeof (type)* (size)))
911 mono_image_load_cli_header (MonoImage
*image
, MonoCLIImageInfo
*iinfo
);
914 mono_image_load_metadata (MonoImage
*image
, MonoCLIImageInfo
*iinfo
);
917 mono_metadata_string_heap_checked (MonoImage
*meta
, uint32_t table_index
, MonoError
*error
);
919 mono_metadata_blob_heap_null_ok (MonoImage
*meta
, guint32 index
);
921 mono_metadata_blob_heap_checked (MonoImage
*meta
, uint32_t table_index
, MonoError
*error
);
923 mono_metadata_decode_row_checked (const MonoImage
*image
, const MonoTableInfo
*t
, int idx
, uint32_t *res
, int res_size
, MonoError
*error
);
926 mono_metadata_get_shared_type (MonoType
*type
);
929 mono_metadata_clean_for_image (MonoImage
*image
);
932 mono_metadata_clean_generic_classes_for_image (MonoImage
*image
);
935 mono_metadata_cleanup (void);
937 const char * mono_meta_table_name (int table
);
938 void mono_metadata_compute_table_bases (MonoImage
*meta
);
941 mono_metadata_interfaces_from_typedef_full (MonoImage
*image
,
943 MonoClass
***interfaces
,
945 gboolean heap_alloc_result
,
946 MonoGenericContext
*context
,
949 MONO_API MonoMethodSignature
*
950 mono_metadata_parse_method_signature_full (MonoImage
*image
,
951 MonoGenericContainer
*generic_container
,
957 MONO_API MonoMethodHeader
*
958 mono_metadata_parse_mh_full (MonoImage
*image
,
959 MonoGenericContainer
*container
,
963 MonoMethodSignature
*mono_metadata_parse_signature_checked (MonoImage
*image
,
968 mono_method_get_header_summary (MonoMethod
*method
, MonoMethodHeaderSummary
*summary
);
970 int* mono_metadata_get_param_attrs (MonoImage
*m
, int def
, int param_count
);
971 gboolean
mono_metadata_method_has_param_attrs (MonoImage
*m
, int def
);
974 mono_metadata_generic_context_hash (const MonoGenericContext
*context
);
977 mono_metadata_generic_context_equal (const MonoGenericContext
*g1
,
978 const MonoGenericContext
*g2
);
981 mono_metadata_parse_generic_inst (MonoImage
*image
,
982 MonoGenericContainer
*container
,
989 mono_metadata_get_generic_inst (int type_argc
,
990 MonoType
**type_argv
);
993 mono_metadata_get_canonical_generic_inst (MonoGenericInst
*candidate
);
996 mono_metadata_lookup_generic_class (MonoClass
*gclass
,
997 MonoGenericInst
*inst
,
998 gboolean is_dynamic
);
1000 MonoGenericInst
* mono_metadata_inflate_generic_inst (MonoGenericInst
*ginst
, MonoGenericContext
*context
, MonoError
*error
);
1003 mono_metadata_generic_param_hash (MonoGenericParam
*p
);
1006 mono_metadata_generic_param_equal (MonoGenericParam
*p1
, MonoGenericParam
*p2
);
1008 void mono_dynamic_stream_reset (MonoDynamicStream
* stream
);
1009 MONO_API
void mono_assembly_addref (MonoAssembly
*assembly
);
1010 void mono_assembly_load_friends (MonoAssembly
* ass
);
1011 gboolean
mono_assembly_has_skip_verification (MonoAssembly
* ass
);
1013 void mono_assembly_release_gc_roots (MonoAssembly
*assembly
);
1014 gboolean
mono_assembly_close_except_image_pools (MonoAssembly
*assembly
);
1015 void mono_assembly_close_finish (MonoAssembly
*assembly
);
1018 gboolean
mono_public_tokens_are_equal (const unsigned char *pubt1
, const unsigned char *pubt2
);
1020 void mono_config_parse_publisher_policy (const char *filename
, MonoAssemblyBindingInfo
*binding_info
);
1021 void mono_config_parse_assembly_bindings (const char *filename
, int major
, int minor
, void *user_data
,
1022 void (*infocb
)(MonoAssemblyBindingInfo
*info
, void *user_data
));
1025 mono_assembly_name_parse_full (const char *name
,
1026 MonoAssemblyName
*aname
,
1027 gboolean save_public_key
,
1028 gboolean
*is_version_defined
,
1029 gboolean
*is_token_defined
);
1032 mono_assembly_fill_assembly_name_full (MonoImage
*image
, MonoAssemblyName
*aname
, gboolean copyBlobs
);
1035 MONO_API guint32
mono_metadata_get_generic_param_row (MonoImage
*image
, guint32 token
, guint32
*owner
);
1038 mono_metadata_create_anon_gparam (MonoImage
*image
, gint32 param_num
, gboolean is_mvar
);
1040 void mono_unload_interface_ids (MonoBitSet
*bitset
);
1043 MonoType
*mono_metadata_type_dup (MonoImage
*image
, const MonoType
*original
);
1044 MonoType
*mono_metadata_type_dup_with_cmods (MonoImage
*image
, const MonoType
*original
, const MonoType
*cmods_source
);
1046 MonoMethodSignature
*mono_metadata_signature_dup_full (MonoImage
*image
,MonoMethodSignature
*sig
);
1047 MonoMethodSignature
*mono_metadata_signature_dup_mempool (MonoMemPool
*mp
, MonoMethodSignature
*sig
);
1048 MonoMethodSignature
*mono_metadata_signature_dup_add_this (MonoImage
*image
, MonoMethodSignature
*sig
, MonoClass
*klass
);
1051 mono_get_shared_generic_inst (MonoGenericContainer
*container
);
1054 mono_type_stack_size_internal (MonoType
*t
, int *align
, gboolean allow_open
);
1056 MONO_API
void mono_type_get_desc (GString
*res
, MonoType
*type
, mono_bool include_namespace
);
1059 mono_metadata_type_equal_full (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
);
1062 mono_metadata_parse_marshal_spec_full (MonoImage
*image
, MonoImage
*parent_image
, const char *ptr
);
1064 guint
mono_metadata_generic_inst_hash (gconstpointer data
);
1065 gboolean
mono_metadata_generic_inst_equal (gconstpointer ka
, gconstpointer kb
);
1068 mono_metadata_field_info_with_mempool (
1070 guint32 table_index
,
1073 MonoMarshalSpec
**marshal_spec
);
1076 mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField
*field
);
1079 mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent
*event
);
1082 mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty
*property
);
1085 mono_metadata_signature_size (MonoMethodSignature
*sig
);
1087 guint
mono_metadata_str_hash (gconstpointer v1
);
1089 gboolean
mono_image_load_pe_data (MonoImage
*image
);
1091 gboolean
mono_image_load_cli_data (MonoImage
*image
);
1093 void mono_image_load_names (MonoImage
*image
);
1095 MonoImage
*mono_image_open_raw (MonoAssemblyLoadContext
*alc
, const char *fname
, MonoImageOpenStatus
*status
);
1097 MonoImage
*mono_image_open_metadata_only (MonoAssemblyLoadContext
*alc
, const char *fname
, MonoImageOpenStatus
*status
);
1099 MonoImage
*mono_image_open_from_data_internal (MonoAssemblyLoadContext
*alc
, char *data
, guint32 data_len
, gboolean need_copy
, MonoImageOpenStatus
*status
, gboolean refonly
, gboolean metadata_only
, const char *name
);
1101 MonoException
*mono_get_exception_field_access_msg (const char *msg
);
1103 MonoException
*mono_get_exception_method_access_msg (const char *msg
);
1105 MonoMethod
* mono_method_from_method_def_or_ref (MonoImage
*m
, guint32 tok
, MonoGenericContext
*context
, MonoError
*error
);
1107 MonoMethod
*mono_get_method_constrained_with_method (MonoImage
*image
, MonoMethod
*method
, MonoClass
*constrained_class
, MonoGenericContext
*context
, MonoError
*error
);
1108 MonoMethod
*mono_get_method_constrained_checked (MonoImage
*image
, guint32 token
, MonoClass
*constrained_class
, MonoGenericContext
*context
, MonoMethod
**cil_method
, MonoError
*error
);
1110 void mono_type_set_alignment (MonoTypeEnum type
, int align
);
1112 MonoAotCacheConfig
*mono_get_aot_cache_config (void);
1114 mono_type_create_from_typespec_checked (MonoImage
*image
, guint32 type_spec
, MonoError
*error
);
1116 MonoMethodSignature
*
1117 mono_method_get_signature_checked (MonoMethod
*method
, MonoImage
*image
, guint32 token
, MonoGenericContext
*context
, MonoError
*error
);
1120 mono_get_method_checked (MonoImage
*image
, guint32 token
, MonoClass
*klass
, MonoGenericContext
*context
, MonoError
*error
);
1123 mono_metadata_localscope_from_methoddef (MonoImage
*meta
, guint32 index
);
1126 mono_wrapper_caches_free (MonoWrapperCaches
*cache
);
1129 mono_method_get_wrapper_cache (MonoMethod
*method
);
1132 mono_method_get_wrapper_cache (MonoMethod
*method
);
1135 mono_metadata_parse_type_checked (MonoImage
*m
, MonoGenericContainer
*container
, short opt_attrs
, gboolean transient
, const char *ptr
, const char **rptr
, MonoError
*error
);
1137 MonoGenericContainer
*
1138 mono_get_anonymous_container_for_image (MonoImage
*image
, gboolean is_mvar
);
1141 mono_image_set_description (MonoImageSet
*);
1144 mono_find_image_set_owner (void *ptr
);
1147 mono_loader_register_module (const char *name
, MonoDl
*module
);
1150 mono_assembly_is_problematic_version (const char *name
, guint16 major
, guint16 minor
, guint16 build
, guint16 revision
);
1153 mono_ginst_get_desc (GString
*str
, MonoGenericInst
*ginst
);
1156 mono_loader_set_strict_assembly_name_check (gboolean enabled
);
1159 mono_loader_get_strict_assembly_name_check (void);
1162 mono_type_in_image (MonoType
*type
, MonoImage
*image
);
1165 mono_type_is_valid_generic_argument (MonoType
*type
);
1167 MonoAssemblyContextKind
1168 mono_asmctx_get_kind (const MonoAssemblyContext
*ctx
);
1170 #define MONO_CLASS_IS_INTERFACE_INTERNAL(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_INTERFACE) || mono_type_is_generic_parameter (m_class_get_byval_arg (c)))
1172 static inline gboolean
1173 m_image_is_raw_data_allocated (MonoImage
*image
)
1175 return image
->storage
? image
->storage
->raw_data_allocated
: FALSE
;
1178 static inline gboolean
1179 m_image_is_fileio_used (MonoImage
*image
)
1181 return image
->storage
? image
->storage
->fileio_used
: FALSE
;
1185 static inline gboolean
1186 m_image_is_module_handle (MonoImage
*image
)
1188 return image
->storage
? image
->storage
->is_module_handle
: FALSE
;
1191 static inline gboolean
1192 m_image_has_entry_point (MonoImage
*image
)
1194 return image
->storage
? image
->storage
->has_entry_point
: FALSE
;
1198 static inline const char *
1199 m_image_get_name (MonoImage
*image
)
1204 static inline const char *
1205 m_image_get_filename (MonoImage
*image
)
1207 return image
->filename
;
1210 static inline const char *
1211 m_image_get_assembly_name (MonoImage
*image
)
1213 return image
->assembly_name
;
1217 MonoAssemblyLoadContext
*
1218 mono_image_get_alc (MonoImage
*image
)
1220 #ifndef ENABLE_NETCORE
1228 MonoAssemblyLoadContext
*
1229 mono_assembly_get_alc (MonoAssembly
*assm
)
1231 return mono_image_get_alc (assm
->image
);
1234 static inline MonoType
*
1235 mono_signature_get_return_type_internal (MonoMethodSignature
*sig
)
1241 * mono_type_get_type_internal:
1242 * \param type the \c MonoType operated on
1243 * \returns the IL type value for \p type. This is one of the \c MonoTypeEnum
1244 * enum members like \c MONO_TYPE_I4 or \c MONO_TYPE_STRING.
1247 mono_type_get_type_internal (MonoType
*type
)
1253 * mono_type_get_signature:
1254 * \param type the \c MonoType operated on
1255 * It is only valid to call this function if \p type is a \c MONO_TYPE_FNPTR .
1256 * \returns the \c MonoMethodSignature pointer that describes the signature
1257 * of the function pointer \p type represents.
1259 static inline MonoMethodSignature
*
1260 mono_type_get_signature_internal (MonoType
*type
)
1262 g_assert (type
->type
== MONO_TYPE_FNPTR
);
1263 return type
->data
.method
;
1267 * mono_type_is_byref_internal:
1268 * \param type the \c MonoType operated on
1269 * \returns TRUE if \p type represents a type passed by reference,
1272 static inline mono_bool
1273 mono_type_is_byref_internal (MonoType
*type
)
1279 * mono_type_get_class_internal:
1280 * \param type the \c MonoType operated on
1281 * It is only valid to call this function if \p type is a \c MONO_TYPE_CLASS or a
1282 * \c MONO_TYPE_VALUETYPE . For more general functionality, use \c mono_class_from_mono_type_internal,
1284 * \returns the \c MonoClass pointer that describes the class that \p type represents.
1286 static inline MonoClass
*
1287 mono_type_get_class_internal (MonoType
*type
)
1289 /* FIXME: review the runtime users before adding the assert here */
1290 return type
->data
.klass
;
1294 * mono_type_get_array_type_internal:
1295 * \param type the \c MonoType operated on
1296 * It is only valid to call this function if \p type is a \c MONO_TYPE_ARRAY .
1297 * \returns a \c MonoArrayType struct describing the array type that \p type
1298 * represents. The info includes details such as rank, array element type
1299 * and the sizes and bounds of multidimensional arrays.
1301 static inline MonoArrayType
*
1302 mono_type_get_array_type_internal (MonoType
*type
)
1304 return type
->data
.array
;
1307 #endif /* __MONO_METADATA_INTERNALS_H__ */