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
;
256 * indexed by MonoMethod pointers
257 * Protected by the marshal lock
259 GHashTable
*runtime_invoke_method_cache
;
260 GHashTable
*managed_wrapper_cache
;
262 GHashTable
*native_wrapper_cache
;
263 GHashTable
*native_wrapper_aot_cache
;
264 GHashTable
*native_wrapper_check_cache
;
265 GHashTable
*native_wrapper_aot_check_cache
;
267 GHashTable
*native_func_wrapper_aot_cache
;
268 GHashTable
*remoting_invoke_cache
;
269 GHashTable
*synchronized_cache
;
270 GHashTable
*unbox_wrapper_cache
;
271 GHashTable
*cominterop_invoke_cache
;
272 GHashTable
*cominterop_wrapper_cache
; /* LOCKING: marshal lock */
273 GHashTable
*thunk_invoke_cache
;
281 struct _MonoTableInfo
{
287 * Tables contain up to 9 columns and the possible sizes of the
288 * fields in the documentation are 1, 2 and 4 bytes. So we
289 * can encode in 2 bits the size.
291 * A 32 bit value can encode the resulting size
293 * The top eight bits encode the number of columns in the table.
294 * we only need 4, but 8 is aligned no shift required.
296 guint32 size_bitfield
;
299 #define REFERENCE_MISSING ((gpointer) -1)
301 typedef struct _MonoDllMap MonoDllMap
;
304 gboolean (*match
) (MonoImage
*);
305 gboolean (*load_pe_data
) (MonoImage
*);
306 gboolean (*load_cli_data
) (MonoImage
*);
307 gboolean (*load_tables
) (MonoImage
*);
310 /* Represents the physical bytes for an image (usually in the file system, but
311 * could be in memory).
313 * The MonoImageStorage owns the raw data for an image and is responsible for
316 * May be shared by multiple MonoImage objects if they opened the same
317 * underlying file or byte blob in memory.
319 * There is an abstract string key (usually a file path, but could be formed in
320 * other ways) that is used to share MonoImageStorage objects among images.
326 /* key used for lookups. owned by this image storage. */
329 /* If the raw data was allocated from a source such as mmap, the allocator may store resource tracking information here. */
330 void *raw_data_handle
;
332 guint32 raw_data_len
;
333 guint8 raw_buffer_used
: 1;
334 guint8 raw_data_allocated
: 1;
335 guint8 fileio_used
: 1;
338 /* Module was loaded using LoadLibrary. */
339 guint8 is_module_handle
: 1;
341 /* Module entry point is _CorDllMain. */
342 guint8 has_entry_point
: 1;
348 * This count is incremented during these situations:
349 * - An assembly references this MonoImage through its 'image' field
350 * - This MonoImage is present in the 'files' field of an image
351 * - This MonoImage is present in the 'modules' field of an image
352 * - A thread is holding a temporary reference to this MonoImage between
353 * calls to mono_image_open and mono_image_close ()
357 MonoImageStorage
*storage
;
359 /* Aliases storage->raw_data when storage is non-NULL. Otherwise NULL. */
361 guint32 raw_data_len
;
363 /* Whenever this is a dynamically emitted module */
366 /* Whenever this is a reflection only image */
369 /* Whenever this image contains uncompressed metadata */
370 guint8 uncompressed_metadata
: 1;
372 /* Whenever this image contains metadata only without PE data */
373 guint8 metadata_only
: 1;
375 /* Whether this image belongs to load-from context */
376 guint8 load_from_context
: 1;
378 guint8 checked_module_cctor
: 1;
379 guint8 has_module_cctor
: 1;
381 guint8 idx_string_wide
: 1;
382 guint8 idx_guid_wide
: 1;
383 guint8 idx_blob_wide
: 1;
385 /* Whenever this image is considered as platform code for the CoreCLR security model */
386 guint8 core_clr_platform_code
: 1;
388 /* The path to the file for this image or an arbitrary name for images loaded from data. */
391 /* The path to the file for this image or NULL */
394 /* The assembly name reported in the file for this image (expected to be NULL for a netmodule) */
395 const char *assembly_name
;
397 /* The module name reported in the file for this image (could be NULL for a malformed file) */
398 const char *module_name
;
399 guint32 time_date_stamp
;
402 gint16 md_version_major
, md_version_minor
;
404 MonoCLIImageInfo
*image_info
;
405 MonoMemPool
*mempool
; /*protected by the image lock*/
409 MonoStreamHeader heap_strings
;
410 MonoStreamHeader heap_us
;
411 MonoStreamHeader heap_blob
;
412 MonoStreamHeader heap_guid
;
413 MonoStreamHeader heap_tables
;
414 MonoStreamHeader heap_pdb
;
416 const char *tables_base
;
419 guint64 referenced_tables
;
420 int *referenced_table_rows
;
423 MonoTableInfo tables
[MONO_TABLE_NUM
];
426 * references is initialized only by using the mono_assembly_open
427 * function, and not by using the lowlevel mono_image_open.
429 * It is NULL terminated.
431 MonoAssembly
**references
;
434 /* Code files in the assembly. The main assembly has a "file" table and also a "module"
435 * table, where the module table is a subset of the file table. We track both lists,
436 * and because we can lazy-load them at different times we reference-increment both.
439 guint32 module_count
;
440 gboolean
*modules_loaded
;
445 MonoAotModule
*aot_module
;
450 * The Assembly this image was loaded from.
452 MonoAssembly
*assembly
;
455 * Indexed by method tokens and typedef tokens.
457 GHashTable
*method_cache
; /*protected by the image lock*/
458 MonoInternalHashTable class_cache
;
460 /* Indexed by memberref + methodspec tokens */
461 GHashTable
*methodref_cache
; /*protected by the image lock*/
464 * Indexed by fielddef and memberref tokens
466 MonoConcurrentHashTable
*field_cache
; /*protected by the image lock*/
468 /* indexed by typespec tokens. */
469 MonoConcurrentHashTable
*typespec_cache
; /* protected by the image lock */
470 /* indexed by token */
471 GHashTable
*memberref_signatures
;
473 /* Indexed by blob heap indexes */
474 GHashTable
*method_signatures
;
477 * Indexes namespaces to hash tables that map class name to typedef token.
479 GHashTable
*name_cache
; /*protected by the image lock*/
482 * Indexed by MonoClass
484 GHashTable
*array_cache
;
485 GHashTable
*ptr_cache
;
487 GHashTable
*szarray_cache
;
488 /* This has a separate lock to improve scalability */
489 mono_mutex_t szarray_cache_lock
;
492 * indexed by SignaturePointerPair
494 GHashTable
*delegate_bound_static_invoke_cache
;
495 GHashTable
*native_func_wrapper_cache
;
498 * indexed by MonoMethod pointers
500 GHashTable
*wrapper_param_names
;
501 GHashTable
*array_accessor_cache
;
504 * indexed by MonoClass pointers
506 GHashTable
*ldfld_wrapper_cache
;
507 GHashTable
*ldflda_wrapper_cache
;
508 GHashTable
*stfld_wrapper_cache
;
509 GHashTable
*isinst_cache
;
511 GHashTable
*icall_wrapper_cache
;
512 GHashTable
*castclass_cache
;
513 GHashTable
*proxy_isinst_cache
;
514 GHashTable
*rgctx_template_hash
; /* LOCKING: templates lock */
516 /* Contains rarely used fields of runtime structures belonging to this image */
517 MonoPropertyHash
*property_hash
;
519 void *reflection_info
;
522 * user_info is a public field and is not touched by the
527 /* dll map entries */
530 /* interfaces IDs from this image */
531 /* protected by the classes lock */
532 MonoBitSet
*interface_bitset
;
534 /* when the image is being closed, this is abused as a list of
535 malloc'ed regions to be freed. */
536 GSList
*reflection_info_unregister_classes
;
538 /* List of dependent image sets containing this image */
539 /* Protected by image_sets_lock */
542 /* Caches for wrappers that DO NOT reference generic */
544 MonoWrapperCaches wrapper_caches
;
546 /* Pre-allocated anon generic params for the first N generic
547 * parameters, for a small N */
548 MonoGenericParam
*var_gparam_cache_fast
;
549 MonoGenericParam
*mvar_gparam_cache_fast
;
550 /* Anon generic parameters past N, if needed */
551 MonoConcurrentHashTable
*var_gparam_cache
;
552 MonoConcurrentHashTable
*mvar_gparam_cache
;
554 /* Maps malloc-ed char* pinvoke scope -> MonoDl* */
555 GHashTable
*pinvoke_scopes
;
557 /* Maps malloc-ed char* pinvoke scope -> malloced-ed char* filename */
558 GHashTable
*pinvoke_scope_filenames
;
560 /* Indexed by MonoGenericParam pointers */
561 GHashTable
**gshared_types
;
562 /* The length of the above array */
563 int gshared_types_len
;
565 /* The loader used to load this image */
566 MonoImageLoader
*loader
;
568 // Containers for MonoGenericParams associated with this image but not with any specific class or method. Created on demand.
569 // This could happen, for example, for MonoTypes associated with TypeSpec table entries.
570 MonoGenericContainer
*anonymous_generic_class_container
;
571 MonoGenericContainer
*anonymous_generic_method_container
;
573 gboolean weak_fields_inited
;
574 /* Contains 1 based indexes */
575 GHashTable
*weak_field_indexes
;
578 * No other runtime locks must be taken while holding this lock.
579 * It's meant to be used only to mutate and query structures part of this image.
585 * Generic instances and aggregated custom modifiers depend on many images, and they need to be deleted if one
586 * of the images they depend on is unloaded. For example,
587 * List<Foo> depends on both List's image and Foo's image.
588 * A MonoImageSet is the owner of all generic instances depending on the same set of
595 // Generic-specific caches
596 GHashTable
*ginst_cache
, *gmethod_cache
, *gsignature_cache
;
597 MonoConcurrentHashTable
*gclass_cache
;
599 /* mirror caches of ones already on MonoImage. These ones contain generics */
600 GHashTable
*szarray_cache
, *array_cache
, *ptr_cache
;
602 MonoWrapperCaches wrapper_caches
;
604 GHashTable
*aggregate_modifiers_cache
;
609 * Memory for generic instances owned by this image set should be allocated from
610 * this mempool, using the mono_image_set_alloc family of functions.
612 MonoMemPool
*mempool
;
625 guint32 alloc_size
; /* malloced bytes */
627 guint32 offset
; /* from start of metadata */
633 guint8 row_size
; /* calculated later with column_sizes */
636 guint32
*values
; /* rows * columns */
639 /* "Dynamic" assemblies and images arise from System.Reflection.Emit */
640 struct _MonoDynamicAssembly
{
641 MonoAssembly assembly
;
643 guint32 strong_name_size
;
649 struct _MonoDynamicImage
{
653 guint32 metadata_rva
;
655 guint32 cli_header_offset
;
659 guint32 imp_names_offset
;
665 } sections
[MONO_SECTION_MAX
];
666 GHashTable
*typespec
;
668 GHashTable
*handleref
;
669 MonoGHashTable
*tokens
;
670 GHashTable
*blob_cache
;
671 GHashTable
*standalonesig_cache
;
672 GList
*array_methods
;
673 GPtrArray
*gen_params
;
674 MonoGHashTable
*token_fixups
;
675 GHashTable
*method_to_table_idx
;
676 GHashTable
*field_to_table_idx
;
677 GHashTable
*method_aux_hash
;
678 GHashTable
*vararg_aux_hash
;
679 MonoGHashTable
*generic_def_objects
;
681 * Maps final token values to the object they describe.
683 MonoGHashTable
*remapped_tokens
;
686 gboolean initial_image
;
687 guint32 pe_kind
, machine
;
689 guint32 strong_name_size
;
691 guint32 win32_res_size
;
694 MonoDynamicStream sheap
;
695 MonoDynamicStream code
; /* used to store method headers and bytecode */
696 MonoDynamicStream resources
; /* managed embedded resources */
697 MonoDynamicStream us
;
698 MonoDynamicStream blob
;
699 MonoDynamicStream tstream
;
700 MonoDynamicStream guid
;
701 MonoDynamicTable tables
[MONO_TABLE_NUM
];
702 MonoClass
*wrappers_type
; /*wrappers are bound to this type instead of <Module>*/
705 /* Contains information about assembly binding */
706 typedef struct _MonoAssemblyBindingInfo
{
709 guchar public_key_token
[MONO_PUBLIC_KEY_TOKEN_LENGTH
];
712 AssemblyVersionSet old_version_bottom
;
713 AssemblyVersionSet old_version_top
;
714 AssemblyVersionSet new_version
;
715 guint has_old_version_bottom
: 1;
716 guint has_old_version_top
: 1;
717 guint has_new_version
: 1;
719 gint32 domain_id
; /*Needed to unload per-domain binding*/
720 } MonoAssemblyBindingInfo
;
722 struct _MonoMethodHeader
{
723 const unsigned char *code
;
724 #ifdef MONO_SMALL_CONFIG
729 guint16 max_stack
: 15;
730 unsigned int is_transient
: 1; /* mono_metadata_free_mh () will actually free this header */
731 unsigned int num_clauses
: 15;
732 /* if num_locals != 0, then the following apply: */
733 unsigned int init_locals
: 1;
735 MonoExceptionClause
*clauses
;
736 MonoBitSet
*volatile_args
;
737 MonoBitSet
*volatile_locals
;
738 MonoType
*locals
[MONO_ZERO_LEN_ARRAY
];
742 const unsigned char *code
;
745 gboolean has_clauses
;
747 } MonoMethodHeaderSummary
;
749 // FIXME? offsetof (MonoMethodHeader, locals)?
750 #define MONO_SIZEOF_METHOD_HEADER (sizeof (struct _MonoMethodHeader) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
752 struct _MonoMethodSignature
{
754 #ifdef MONO_SMALL_CONFIG
757 unsigned int generic_param_count
: 5;
761 unsigned int generic_param_count
: 16;
763 unsigned int call_convention
: 6;
764 unsigned int hasthis
: 1;
765 unsigned int explicit_this
: 1;
766 unsigned int pinvoke
: 1;
767 unsigned int is_inflated
: 1;
768 unsigned int has_type_parameters
: 1;
769 MonoType
*params
[MONO_ZERO_LEN_ARRAY
];
773 * AOT cache configuration loaded from config files.
774 * Doesn't really belong here.
778 * Enable aot caching for applications whose main assemblies are in
784 } MonoAotCacheConfig
;
786 #define MONO_SIZEOF_METHOD_SIGNATURE (sizeof (struct _MonoMethodSignature) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
788 static inline gboolean
789 image_is_dynamic (MonoImage
*image
)
791 #ifdef DISABLE_REFLECTION_EMIT
794 return image
->dynamic
;
798 static inline gboolean
799 assembly_is_dynamic (MonoAssembly
*assembly
)
801 #ifdef DISABLE_REFLECTION_EMIT
804 return assembly
->dynamic
;
808 /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */
809 guint
mono_aligned_addr_hash (gconstpointer ptr
);
812 mono_image_check_for_module_cctor (MonoImage
*image
);
815 mono_image_alloc (MonoImage
*image
, guint size
);
818 mono_image_alloc0 (MonoImage
*image
, guint size
);
820 #define mono_image_new0(image,type,size) ((type *) mono_image_alloc0 (image, sizeof (type)* (size)))
823 mono_image_strdup (MonoImage
*image
, const char *s
);
826 mono_image_strdup_vprintf (MonoImage
*image
, const char *format
, va_list args
);
829 mono_image_strdup_printf (MonoImage
*image
, const char *format
, ...) MONO_ATTR_FORMAT_PRINTF(2,3);
832 mono_g_list_prepend_image (MonoImage
*image
, GList
*list
, gpointer data
);
835 mono_g_slist_append_image (MonoImage
*image
, GSList
*list
, gpointer data
);
838 mono_image_lock (MonoImage
*image
);
841 mono_image_unlock (MonoImage
*image
);
844 mono_image_property_lookup (MonoImage
*image
, gpointer subject
, guint32 property
);
847 mono_image_property_insert (MonoImage
*image
, gpointer subject
, guint32 property
, gpointer value
);
850 mono_image_property_remove (MonoImage
*image
, gpointer subject
);
853 mono_image_close_except_pools (MonoImage
*image
);
856 mono_image_close_finish (MonoImage
*image
);
858 typedef void (*MonoImageUnloadFunc
) (MonoImage
*image
, gpointer user_data
);
861 mono_install_image_unload_hook (MonoImageUnloadFunc func
, gpointer user_data
);
864 mono_remove_image_unload_hook (MonoImageUnloadFunc func
, gpointer user_data
);
867 mono_install_image_loader (const MonoImageLoader
*loader
);
870 mono_image_append_class_to_reflection_info_set (MonoClass
*klass
);
873 mono_image_set_alloc (MonoImageSet
*set
, guint size
);
876 mono_image_set_alloc0 (MonoImageSet
*set
, guint size
);
879 mono_image_set_lock (MonoImageSet
*set
);
882 mono_image_set_unlock (MonoImageSet
*set
);
885 mono_image_set_strdup (MonoImageSet
*set
, const char *s
);
888 mono_metadata_get_image_set_for_aggregate_modifiers (MonoAggregateModContainer
*amods
);
890 #define mono_image_set_new0(image,type,size) ((type *) mono_image_set_alloc0 (image, sizeof (type)* (size)))
893 mono_image_load_cli_header (MonoImage
*image
, MonoCLIImageInfo
*iinfo
);
896 mono_image_load_metadata (MonoImage
*image
, MonoCLIImageInfo
*iinfo
);
899 mono_metadata_string_heap_checked (MonoImage
*meta
, uint32_t table_index
, MonoError
*error
);
901 mono_metadata_blob_heap_checked (MonoImage
*meta
, uint32_t table_index
, MonoError
*error
);
903 mono_metadata_decode_row_checked (const MonoImage
*image
, const MonoTableInfo
*t
, int idx
, uint32_t *res
, int res_size
, MonoError
*error
);
906 mono_metadata_get_shared_type (MonoType
*type
);
909 mono_metadata_clean_for_image (MonoImage
*image
);
912 mono_metadata_clean_generic_classes_for_image (MonoImage
*image
);
915 mono_metadata_cleanup (void);
917 const char * mono_meta_table_name (int table
);
918 void mono_metadata_compute_table_bases (MonoImage
*meta
);
921 mono_metadata_interfaces_from_typedef_full (MonoImage
*image
,
923 MonoClass
***interfaces
,
925 gboolean heap_alloc_result
,
926 MonoGenericContext
*context
,
929 MONO_API MonoMethodSignature
*
930 mono_metadata_parse_method_signature_full (MonoImage
*image
,
931 MonoGenericContainer
*generic_container
,
937 MONO_API MonoMethodHeader
*
938 mono_metadata_parse_mh_full (MonoImage
*image
,
939 MonoGenericContainer
*container
,
943 MonoMethodSignature
*mono_metadata_parse_signature_checked (MonoImage
*image
,
948 mono_method_get_header_summary (MonoMethod
*method
, MonoMethodHeaderSummary
*summary
);
950 int* mono_metadata_get_param_attrs (MonoImage
*m
, int def
, int param_count
);
951 gboolean
mono_metadata_method_has_param_attrs (MonoImage
*m
, int def
);
954 mono_metadata_generic_context_hash (const MonoGenericContext
*context
);
957 mono_metadata_generic_context_equal (const MonoGenericContext
*g1
,
958 const MonoGenericContext
*g2
);
961 mono_metadata_parse_generic_inst (MonoImage
*image
,
962 MonoGenericContainer
*container
,
969 mono_metadata_get_generic_inst (int type_argc
,
970 MonoType
**type_argv
);
973 mono_metadata_get_canonical_generic_inst (MonoGenericInst
*candidate
);
976 mono_metadata_lookup_generic_class (MonoClass
*gclass
,
977 MonoGenericInst
*inst
,
978 gboolean is_dynamic
);
980 MonoGenericInst
* mono_metadata_inflate_generic_inst (MonoGenericInst
*ginst
, MonoGenericContext
*context
, MonoError
*error
);
983 mono_metadata_generic_param_hash (MonoGenericParam
*p
);
986 mono_metadata_generic_param_equal (MonoGenericParam
*p1
, MonoGenericParam
*p2
);
988 void mono_dynamic_stream_reset (MonoDynamicStream
* stream
);
989 MONO_API
void mono_assembly_addref (MonoAssembly
*assembly
);
990 void mono_assembly_load_friends (MonoAssembly
* ass
);
991 gboolean
mono_assembly_has_skip_verification (MonoAssembly
* ass
);
993 void mono_assembly_release_gc_roots (MonoAssembly
*assembly
);
994 gboolean
mono_assembly_close_except_image_pools (MonoAssembly
*assembly
);
995 void mono_assembly_close_finish (MonoAssembly
*assembly
);
998 gboolean
mono_public_tokens_are_equal (const unsigned char *pubt1
, const unsigned char *pubt2
);
1000 void mono_config_parse_publisher_policy (const char *filename
, MonoAssemblyBindingInfo
*binding_info
);
1001 void mono_config_parse_assembly_bindings (const char *filename
, int major
, int minor
, void *user_data
,
1002 void (*infocb
)(MonoAssemblyBindingInfo
*info
, void *user_data
));
1005 mono_assembly_name_parse_full (const char *name
,
1006 MonoAssemblyName
*aname
,
1007 gboolean save_public_key
,
1008 gboolean
*is_version_defined
,
1009 gboolean
*is_token_defined
);
1012 mono_assembly_fill_assembly_name_full (MonoImage
*image
, MonoAssemblyName
*aname
, gboolean copyBlobs
);
1015 MONO_API guint32
mono_metadata_get_generic_param_row (MonoImage
*image
, guint32 token
, guint32
*owner
);
1018 mono_metadata_create_anon_gparam (MonoImage
*image
, gint32 param_num
, gboolean is_mvar
);
1020 void mono_unload_interface_ids (MonoBitSet
*bitset
);
1023 MonoType
*mono_metadata_type_dup (MonoImage
*image
, const MonoType
*original
);
1024 MonoType
*mono_metadata_type_dup_with_cmods (MonoImage
*image
, const MonoType
*original
, const MonoType
*cmods_source
);
1026 MonoMethodSignature
*mono_metadata_signature_dup_full (MonoImage
*image
,MonoMethodSignature
*sig
);
1027 MonoMethodSignature
*mono_metadata_signature_dup_mempool (MonoMemPool
*mp
, MonoMethodSignature
*sig
);
1028 MonoMethodSignature
*mono_metadata_signature_dup_add_this (MonoImage
*image
, MonoMethodSignature
*sig
, MonoClass
*klass
);
1031 mono_get_shared_generic_inst (MonoGenericContainer
*container
);
1034 mono_type_stack_size_internal (MonoType
*t
, int *align
, gboolean allow_open
);
1036 MONO_API
void mono_type_get_desc (GString
*res
, MonoType
*type
, mono_bool include_namespace
);
1039 mono_metadata_type_equal_full (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
);
1042 mono_metadata_parse_marshal_spec_full (MonoImage
*image
, MonoImage
*parent_image
, const char *ptr
);
1044 guint
mono_metadata_generic_inst_hash (gconstpointer data
);
1045 gboolean
mono_metadata_generic_inst_equal (gconstpointer ka
, gconstpointer kb
);
1048 mono_metadata_field_info_with_mempool (
1050 guint32 table_index
,
1053 MonoMarshalSpec
**marshal_spec
);
1056 mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField
*field
);
1059 mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent
*event
);
1062 mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty
*property
);
1065 mono_metadata_signature_size (MonoMethodSignature
*sig
);
1067 guint
mono_metadata_str_hash (gconstpointer v1
);
1069 gboolean
mono_image_load_pe_data (MonoImage
*image
);
1071 gboolean
mono_image_load_cli_data (MonoImage
*image
);
1073 void mono_image_load_names (MonoImage
*image
);
1075 MonoImage
*mono_image_open_raw (const char *fname
, MonoImageOpenStatus
*status
);
1077 MonoImage
*mono_image_open_metadata_only (const char *fname
, MonoImageOpenStatus
*status
);
1079 MonoImage
*mono_image_open_from_data_internal (char *data
, guint32 data_len
, gboolean need_copy
, MonoImageOpenStatus
*status
, gboolean refonly
, gboolean metadata_only
, const char *name
);
1081 MonoException
*mono_get_exception_field_access_msg (const char *msg
);
1083 MonoException
*mono_get_exception_method_access_msg (const char *msg
);
1085 MonoMethod
* mono_method_from_method_def_or_ref (MonoImage
*m
, guint32 tok
, MonoGenericContext
*context
, MonoError
*error
);
1087 MonoMethod
*mono_get_method_constrained_with_method (MonoImage
*image
, MonoMethod
*method
, MonoClass
*constrained_class
, MonoGenericContext
*context
, MonoError
*error
);
1088 MonoMethod
*mono_get_method_constrained_checked (MonoImage
*image
, guint32 token
, MonoClass
*constrained_class
, MonoGenericContext
*context
, MonoMethod
**cil_method
, MonoError
*error
);
1090 void mono_type_set_alignment (MonoTypeEnum type
, int align
);
1092 MonoAotCacheConfig
*mono_get_aot_cache_config (void);
1094 mono_type_create_from_typespec_checked (MonoImage
*image
, guint32 type_spec
, MonoError
*error
);
1096 MonoMethodSignature
*
1097 mono_method_get_signature_checked (MonoMethod
*method
, MonoImage
*image
, guint32 token
, MonoGenericContext
*context
, MonoError
*error
);
1100 mono_get_method_checked (MonoImage
*image
, guint32 token
, MonoClass
*klass
, MonoGenericContext
*context
, MonoError
*error
);
1103 mono_metadata_localscope_from_methoddef (MonoImage
*meta
, guint32 index
);
1106 mono_wrapper_caches_free (MonoWrapperCaches
*cache
);
1109 mono_method_get_wrapper_cache (MonoMethod
*method
);
1112 mono_method_get_wrapper_cache (MonoMethod
*method
);
1115 mono_metadata_parse_type_checked (MonoImage
*m
, MonoGenericContainer
*container
, short opt_attrs
, gboolean transient
, const char *ptr
, const char **rptr
, MonoError
*error
);
1117 MonoGenericContainer
*
1118 mono_get_anonymous_container_for_image (MonoImage
*image
, gboolean is_mvar
);
1121 mono_image_set_description (MonoImageSet
*);
1124 mono_find_image_set_owner (void *ptr
);
1127 mono_loader_register_module (const char *name
, MonoDl
*module
);
1130 mono_assembly_is_problematic_version (const char *name
, guint16 major
, guint16 minor
, guint16 build
, guint16 revision
);
1133 mono_ginst_get_desc (GString
*str
, MonoGenericInst
*ginst
);
1136 mono_loader_set_strict_strong_names (gboolean enabled
);
1139 mono_loader_get_strict_strong_names (void);
1142 mono_type_in_image (MonoType
*type
, MonoImage
*image
);
1145 mono_type_is_valid_generic_argument (MonoType
*type
);
1147 MonoAssemblyContextKind
1148 mono_asmctx_get_kind (const MonoAssemblyContext
*ctx
);
1150 #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)))
1152 static inline gboolean
1153 m_image_is_raw_data_allocated (MonoImage
*image
)
1155 return image
->storage
? image
->storage
->raw_data_allocated
: FALSE
;
1158 static inline gboolean
1159 m_image_is_fileio_used (MonoImage
*image
)
1161 return image
->storage
? image
->storage
->fileio_used
: FALSE
;
1165 static inline gboolean
1166 m_image_is_module_handle (MonoImage
*image
)
1168 return image
->storage
? image
->storage
->is_module_handle
: FALSE
;
1171 static inline gboolean
1172 m_image_has_entry_point (MonoImage
*image
)
1174 return image
->storage
? image
->storage
->has_entry_point
: FALSE
;
1179 #endif /* __MONO_METADATA_INTERNALS_H__ */